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 #ifdef HAVE_LINUX_RTNETLINK_H
  83 #include <linux/rtnetlink.h>
  84 #endif
  85
  86 #include "ifenum.h"
  87 #include "ws2ipdef.h"
  88
  89 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
  90 #define ifreq_len(ifr) \
  91  max(sizeof(struct ifreq), sizeof((ifr)->ifr_name)+(ifr)->ifr_addr.sa_len)
  92 #else
  93 #define ifreq_len(ifr) sizeof(struct ifreq)
  94 #endif
  95
  96 #ifndef ETH_ALEN
  97 #define ETH_ALEN 6
  98 #endif
  99
 100 #ifndef IF_NAMESIZE
 101 #define IF_NAMESIZE 16
 102 #endif
 103
 104 #ifndef INADDR_NONE
 105 #define INADDR_NONE (~0U)
 106 #endif
 107
 108 #define INITIAL_INTERFACES_ASSUMED 4
 109
 110 /* Functions */
 111
 112 static BOOL isLoopbackInterface(int fd, const char *name)
 113 {
 114   BOOL ret = FALSE;
 115
 116   if (name) {
 117     struct ifreq ifr;
 118
 119     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 120     if (ioctl(fd, SIOCGIFFLAGS, &ifr) == 0)
 121       ret = ifr.ifr_flags & IFF_LOOPBACK;
 122   }
 123   return !!ret;
 124 }
 125
 126 /* The comments say MAX_ADAPTER_NAME is required, but really only IF_NAMESIZE
 127  * bytes are necessary.
 128  */
 129 char *getInterfaceNameByIndex(IF_INDEX index, char *name)
 130 {
 131   return if_indextoname(index, name);
 132 }
 133
 134 DWORD getInterfaceIndexByName(const char *name, IF_INDEX *index)
 135 {
 136   DWORD ret;
 137   unsigned int idx;
 138
 139   if (!name)
 140     return ERROR_INVALID_PARAMETER;
 141   if (!index)
 142     return ERROR_INVALID_PARAMETER;
 143   idx = if_nametoindex(name);
 144   if (idx) {
 145     *index = idx;
 146     ret = NO_ERROR;
 147   }
 148   else
 149     ret = ERROR_INVALID_DATA;
 150   return ret;
 151 }
 152
 153 BOOL isIfIndexLoopback(ULONG idx)
 154 {
 155   BOOL ret = FALSE;
 156   char name[IFNAMSIZ];
 157   int fd;
 158
 159   getInterfaceNameByIndex(idx, name);
 160   fd = socket(PF_INET, SOCK_DGRAM, 0);
 161   if (fd != -1) {
 162     ret = isLoopbackInterface(fd, name);
 163     close(fd);
 164   }
 165   return ret;
 166 }
 167
 168 #ifdef HAVE_IF_NAMEINDEX
 169 DWORD get_interface_indices( BOOL skip_loopback, InterfaceIndexTable **table )
 170 {
 171     DWORD count = 0, i;
 172     struct if_nameindex *p, *indices = if_nameindex();
 173     InterfaceIndexTable *ret;
 174
 175     if (table) *table = NULL;
 176     if (!indices) return 0;
 177
 178     for (p = indices; p->if_name; p++)
 179     {
 180         if (skip_loopback && isIfIndexLoopback( p->if_index )) continue;
 181         count++;
 182     }
 183
 184     if (table)
 185     {
 186         ret = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET(InterfaceIndexTable, indexes[count]) );
 187         if (!ret)
 188         {
 189             count = 0;
 190             goto end;
 191         }
 192         for (p = indices, i = 0; p->if_name && i < count; p++)
 193         {
 194             if (skip_loopback && isIfIndexLoopback( p->if_index )) continue;
 195             ret->indexes[i++] = p->if_index;
 196         }
 197         ret->numIndexes = count = i;
 198         *table = ret;
 199     }
 200
 201 end:
 202     if_freenameindex( indices );
 203     return count;
 204 }
 205
 206 #elif defined(HAVE_LINUX_RTNETLINK_H)
 207 static int open_netlink( int *pid )
 208 {
 209     int fd = socket( AF_NETLINK, SOCK_RAW, NETLINK_ROUTE );
 210     struct sockaddr_nl addr;
 211     socklen_t len;
 212
 213     if (fd < 0) return fd;
 214
 215     memset( &addr, 0, sizeof(addr) );
 216     addr.nl_family = AF_NETLINK;
 217
 218     if (bind( fd, (struct sockaddr *)&addr, sizeof(addr) ) < 0)
 219         goto fail;
 220
 221     len = sizeof(addr);
 222     if (getsockname( fd, (struct sockaddr *)&addr, &len ) < 0)
 223         goto fail;
 224
 225     *pid = addr.nl_pid;
 226     return fd;
 227 fail:
 228     close( fd );
 229     return -1;
 230 }
 231
 232 static int send_netlink_req( int fd, int pid, int type, int *seq_no )
 233 {
 234     static LONG seq;
 235     struct request
 236     {
 237         struct nlmsghdr hdr;
 238         struct rtgenmsg gen;
 239     } req;
 240     struct sockaddr_nl addr;
 241
 242     req.hdr.nlmsg_len = sizeof(req);
 243     req.hdr.nlmsg_type = type;
 244     req.hdr.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
 245     req.hdr.nlmsg_pid = pid;
 246     req.hdr.nlmsg_seq = InterlockedIncrement( &seq );
 247     req.gen.rtgen_family = AF_UNSPEC;
 248
 249     memset( &addr, 0, sizeof(addr) );
 250     addr.nl_family = AF_NETLINK;
 251     if (sendto( fd, &req, sizeof(req), 0, (struct sockaddr *)&addr, sizeof(addr) ) != sizeof(req))
 252         return -1;
 253     *seq_no = req.hdr.nlmsg_seq;
 254     return 0;
 255 }
 256
 257 struct netlink_reply
 258 {
 259     struct netlink_reply *next;
 260     int size;
 261     struct nlmsghdr *hdr;
 262 };
 263
 264 static void free_netlink_reply( struct netlink_reply *data )
 265 {
 266     struct netlink_reply *ptr;
 267     while( data )
 268     {
 269         ptr = data->next;
 270         HeapFree( GetProcessHeap(), 0, data );
 271         data = ptr;
 272     }
 273 }
 274
 275 static int recv_netlink_reply( int fd, int pid, int seq, struct netlink_reply **data )
 276 {
 277     int bufsize = getpagesize();
 278     int left, read;
 279     BOOL done = FALSE;
 280     socklen_t sa_len;
 281     struct sockaddr_nl addr;
 282     struct netlink_reply *cur, *last = NULL;
 283     struct nlmsghdr *hdr;
 284     char *buf;
 285
 286     *data = NULL;
 287     buf = HeapAlloc( GetProcessHeap(), 0, bufsize );
 288     if (!buf) return -1;
 289
 290     do
 291     {
 292         left = read = recvfrom( fd, buf, bufsize, 0, (struct sockaddr *)&addr, &sa_len );
 293         if (read < 0) goto fail;
 294         if (addr.nl_pid != 0) continue; /* not from kernel */
 295
 296         for (hdr = (struct nlmsghdr *)buf; NLMSG_OK(hdr, left); hdr = NLMSG_NEXT(hdr, left))
 297         {
 298             if (hdr->nlmsg_pid != pid || hdr->nlmsg_seq != seq) continue;
 299             if (hdr->nlmsg_type == NLMSG_DONE)
 300             {
 301                 done = TRUE;
 302                 break;
 303             }
 304         }
 305
 306         cur = HeapAlloc( GetProcessHeap(), 0, sizeof(*cur) + read );
 307         if (!cur) goto fail;
 308         cur->next = NULL;
 309         cur->size = read;
 310         cur->hdr = (struct nlmsghdr *)(cur + 1);
 311         memcpy( cur->hdr, buf, read );
 312         if (last) last->next = cur;
 313         else *data = cur;
 314         last = cur;
 315     } while (!done);
 316
 317     HeapFree( GetProcessHeap(), 0, buf );
 318     return 0;
 319
 320 fail:
 321     free_netlink_reply( *data );
 322     HeapFree( GetProcessHeap(), 0, buf );
 323     return -1;
 324 }
 325
 326
 327 static DWORD get_indices_from_reply( struct netlink_reply *reply, int pid, int seq,
 328                                      BOOL skip_loopback, InterfaceIndexTable *table )
 329 {
 330     struct nlmsghdr *hdr;
 331     struct netlink_reply *r;
 332     int count = 0;
 333
 334     for (r = reply; r; r = r->next)
 335     {
 336         int size = r->size;
 337         for (hdr = r->hdr; NLMSG_OK(hdr, size); hdr = NLMSG_NEXT(hdr, size))
 338         {
 339             if (hdr->nlmsg_pid != pid || hdr->nlmsg_seq != seq) continue;
 340             if (hdr->nlmsg_type == NLMSG_DONE) break;
 341
 342             if (hdr->nlmsg_type == RTM_NEWLINK)
 343             {
 344                 struct ifinfomsg *info = NLMSG_DATA(hdr);
 345
 346                 if (skip_loopback && (info->ifi_flags & IFF_LOOPBACK)) continue;
 347                 if (table) table->indexes[count] = info->ifi_index;
 348                 count++;
 349             }
 350         }
 351     }
 352     return count;
 353 }
 354
 355 DWORD get_interface_indices( BOOL skip_loopback, InterfaceIndexTable **table )
 356 {
 357     int fd, pid, seq;
 358     struct netlink_reply *reply = NULL;
 359     DWORD count = 0;
 360
 361     if (table) *table = NULL;
 362     fd = open_netlink( &pid );
 363     if (fd < 0) return 0;
 364
 365     if (send_netlink_req( fd, pid, RTM_GETLINK, &seq ) < 0)
 366         goto end;
 367
 368     if (recv_netlink_reply( fd, pid, seq, &reply ) < 0)
 369         goto end;
 370
 371     count = get_indices_from_reply( reply, pid, seq, skip_loopback, NULL );
 372
 373     if (table)
 374     {
 375         InterfaceIndexTable *ret = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET(InterfaceIndexTable, indexes[count]) );
 376         if (!ret)
 377         {
 378             count = 0;
 379             goto end;
 380         }
 381
 382         ret->numIndexes = count;
 383         get_indices_from_reply( reply, pid, seq, skip_loopback, ret );
 384         *table = ret;
 385     }
 386
 387 end:
 388     free_netlink_reply( reply );
 389     close( fd );
 390     return count;
 391 }
 392
 393 #else
 394 DWORD get_interface_indices( BOOL skip_loopback, InterfaceIndexTable **table )
 395 {
 396     if (table) *table = NULL;
 397     return 0;
 398 }
 399 #endif
 400
 401 static DWORD getInterfaceBCastAddrByName(const char *name)
 402 {
 403   DWORD ret = INADDR_ANY;
 404
 405   if (name) {
 406     int fd = socket(PF_INET, SOCK_DGRAM, 0);
 407
 408     if (fd != -1) {
 409       struct ifreq ifr;
 410
 411       lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 412       if (ioctl(fd, SIOCGIFBRDADDR, &ifr) == 0)
 413         memcpy(&ret, ifr.ifr_addr.sa_data + 2, sizeof(DWORD));
 414       close(fd);
 415     }
 416   }
 417   return ret;
 418 }
 419
 420 static DWORD getInterfaceMaskByName(const char *name)
 421 {
 422   DWORD ret = INADDR_NONE;
 423
 424   if (name) {
 425     int fd = socket(PF_INET, SOCK_DGRAM, 0);
 426
 427     if (fd != -1) {
 428       struct ifreq ifr;
 429
 430       lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 431       if (ioctl(fd, SIOCGIFNETMASK, &ifr) == 0)
 432         memcpy(&ret, ifr.ifr_addr.sa_data + 2, sizeof(DWORD));
 433       close(fd);
 434     }
 435   }
 436   return ret;
 437 }
 438
 439 #if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
 440 static DWORD getInterfacePhysicalByName(const char *name, PDWORD len, PBYTE addr,
 441  PDWORD type)
 442 {
 443   DWORD ret;
 444   int fd;
 445
 446   if (!name || !len || !addr || !type)
 447     return ERROR_INVALID_PARAMETER;
 448
 449   fd = socket(PF_INET, SOCK_DGRAM, 0);
 450   if (fd != -1) {
 451     struct ifreq ifr;
 452
 453     memset(&ifr, 0, sizeof(struct ifreq));
 454     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 455     if ((ioctl(fd, SIOCGIFHWADDR, &ifr)))
 456       ret = ERROR_INVALID_DATA;
 457     else {
 458       unsigned int addrLen;
 459
 460       switch (ifr.ifr_hwaddr.sa_family)
 461       {
 462 #ifdef ARPHRD_LOOPBACK
 463         case ARPHRD_LOOPBACK:
 464           addrLen = 0;
 465           *type = MIB_IF_TYPE_LOOPBACK;
 466           break;
 467 #endif
 468 #ifdef ARPHRD_ETHER
 469         case ARPHRD_ETHER:
 470           addrLen = ETH_ALEN;
 471           *type = MIB_IF_TYPE_ETHERNET;
 472           break;
 473 #endif
 474 #ifdef ARPHRD_FDDI
 475         case ARPHRD_FDDI:
 476           addrLen = ETH_ALEN;
 477           *type = MIB_IF_TYPE_FDDI;
 478           break;
 479 #endif
 480 #ifdef ARPHRD_IEEE802
 481         case ARPHRD_IEEE802: /* 802.2 Ethernet && Token Ring, guess TR? */
 482           addrLen = ETH_ALEN;
 483           *type = MIB_IF_TYPE_TOKENRING;
 484           break;
 485 #endif
 486 #ifdef ARPHRD_IEEE802_TR
 487         case ARPHRD_IEEE802_TR: /* also Token Ring? */
 488           addrLen = ETH_ALEN;
 489           *type = MIB_IF_TYPE_TOKENRING;
 490           break;
 491 #endif
 492 #ifdef ARPHRD_SLIP
 493         case ARPHRD_SLIP:
 494           addrLen = 0;
 495           *type = MIB_IF_TYPE_SLIP;
 496           break;
 497 #endif
 498 #ifdef ARPHRD_PPP
 499         case ARPHRD_PPP:
 500           addrLen = 0;
 501           *type = MIB_IF_TYPE_PPP;
 502           break;
 503 #endif
 504         default:
 505           addrLen = min(MAX_INTERFACE_PHYSADDR, sizeof(ifr.ifr_hwaddr.sa_data));
 506           *type = MIB_IF_TYPE_OTHER;
 507       }
 508       if (addrLen > *len) {
 509         ret = ERROR_INSUFFICIENT_BUFFER;
 510         *len = addrLen;
 511       }
 512       else {
 513         if (addrLen > 0)
 514           memcpy(addr, ifr.ifr_hwaddr.sa_data, addrLen);
 515         /* zero out remaining bytes for broken implementations */
 516         memset(addr + addrLen, 0, *len - addrLen);
 517         *len = addrLen;
 518         ret = NO_ERROR;
 519       }
 520     }
 521     close(fd);
 522   }
 523   else
 524     ret = ERROR_NO_MORE_FILES;
 525   return ret;
 526 }
 527 #elif defined (SIOCGARP)
 528 static DWORD getInterfacePhysicalByName(const char *name, PDWORD len, PBYTE addr,
 529  PDWORD type)
 530 {
 531   DWORD ret;
 532   int fd;
 533
 534   if (!name || !len || !addr || !type)
 535     return ERROR_INVALID_PARAMETER;
 536
 537   fd = socket(PF_INET, SOCK_DGRAM, 0);
 538   if (fd != -1) {
 539     if (isLoopbackInterface(fd, name)) {
 540       *type = MIB_IF_TYPE_LOOPBACK;
 541       memset(addr, 0, *len);
 542       *len = 0;
 543       ret=NOERROR;
 544     }
 545     else {
 546       struct arpreq arp;
 547       struct sockaddr_in *saddr;
 548       struct ifreq ifr;
 549
 550       /* get IP addr */
 551       lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 552       ioctl(fd, SIOCGIFADDR, &ifr);
 553       memset(&arp, 0, sizeof(struct arpreq));
 554       arp.arp_pa.sa_family = AF_INET;
 555       saddr = (struct sockaddr_in *)&arp; /* proto addr is first member */
 556       saddr->sin_family = AF_INET;
 557       memcpy(&saddr->sin_addr.s_addr, ifr.ifr_addr.sa_data + 2, sizeof(DWORD));
 558       if ((ioctl(fd, SIOCGARP, &arp)))
 559         ret = ERROR_INVALID_DATA;
 560       else {
 561         /* FIXME:  heh:  who said it was ethernet? */
 562         int addrLen = ETH_ALEN;
 563
 564         if (addrLen > *len) {
 565           ret = ERROR_INSUFFICIENT_BUFFER;
 566           *len = addrLen;
 567         }
 568         else {
 569           if (addrLen > 0)
 570             memcpy(addr, &arp.arp_ha.sa_data[0], addrLen);
 571           /* zero out remaining bytes for broken implementations */
 572           memset(addr + addrLen, 0, *len - addrLen);
 573           *len = addrLen;
 574           *type = MIB_IF_TYPE_ETHERNET;
 575           ret = NO_ERROR;
 576         }
 577       }
 578     }
 579     close(fd);
 580   }
 581     else
 582       ret = ERROR_NO_MORE_FILES;
 583
 584   return ret;
 585 }
 586 #elif defined (HAVE_SYS_SYSCTL_H) && defined (HAVE_NET_IF_DL_H)
 587 static DWORD getInterfacePhysicalByName(const char *name, PDWORD len, PBYTE addr,
 588  PDWORD type)
 589 {
 590   DWORD ret;
 591   struct if_msghdr *ifm;
 592   struct sockaddr_dl *sdl;
 593   u_char *p, *buf;
 594   size_t mibLen;
 595   int mib[] = { CTL_NET, AF_ROUTE, 0, AF_LINK, NET_RT_IFLIST, 0 };
 596   unsigned addrLen;
 597   BOOL found = FALSE;
 598
 599   if (!name || !len || !addr || !type)
 600     return ERROR_INVALID_PARAMETER;
 601
 602   if (sysctl(mib, 6, NULL, &mibLen, NULL, 0) < 0)
 603     return ERROR_NO_MORE_FILES;
 604
 605   buf = HeapAlloc(GetProcessHeap(), 0, mibLen);
 606   if (!buf)
 607     return ERROR_NOT_ENOUGH_MEMORY;
 608
 609   if (sysctl(mib, 6, buf, &mibLen, NULL, 0) < 0) {
 610     HeapFree(GetProcessHeap(), 0, buf);
 611     return ERROR_NO_MORE_FILES;
 612   }
 613
 614   ret = ERROR_INVALID_DATA;
 615   for (p = buf; !found && p < buf + mibLen; p += ifm->ifm_msglen) {
 616     ifm = (struct if_msghdr *)p;
 617     sdl = (struct sockaddr_dl *)(ifm + 1);
 618
 619     if (ifm->ifm_type != RTM_IFINFO || (ifm->ifm_addrs & RTA_IFP) == 0)
 620       continue;
 621
 622     if (sdl->sdl_family != AF_LINK || sdl->sdl_nlen == 0 ||
 623      memcmp(sdl->sdl_data, name, max(sdl->sdl_nlen, strlen(name))) != 0)
 624       continue;
 625
 626     found = TRUE;
 627     addrLen = min(MAX_INTERFACE_PHYSADDR, sdl->sdl_alen);
 628     if (addrLen > *len) {
 629       ret = ERROR_INSUFFICIENT_BUFFER;
 630       *len = addrLen;
 631     }
 632     else {
 633       if (addrLen > 0)
 634         memcpy(addr, LLADDR(sdl), addrLen);
 635       /* zero out remaining bytes for broken implementations */
 636       memset(addr + addrLen, 0, *len - addrLen);
 637       *len = addrLen;
 638 #if defined(HAVE_NET_IF_TYPES_H)
 639       switch (sdl->sdl_type)
 640       {
 641         case IFT_ETHER:
 642           *type = MIB_IF_TYPE_ETHERNET;
 643           break;
 644         case IFT_FDDI:
 645           *type = MIB_IF_TYPE_FDDI;
 646           break;
 647         case IFT_ISO88024: /* Token Bus */
 648           *type = MIB_IF_TYPE_TOKENRING;
 649           break;
 650         case IFT_ISO88025: /* Token Ring */
 651           *type = MIB_IF_TYPE_TOKENRING;
 652           break;
 653         case IFT_PPP:
 654           *type = MIB_IF_TYPE_PPP;
 655           break;
 656         case IFT_SLIP:
 657           *type = MIB_IF_TYPE_SLIP;
 658           break;
 659         case IFT_LOOP:
 660           *type = MIB_IF_TYPE_LOOPBACK;
 661           break;
 662         default:
 663           *type = MIB_IF_TYPE_OTHER;
 664       }
 665 #else
 666       /* default if we don't know */
 667       *type = MIB_IF_TYPE_ETHERNET;
 668 #endif
 669       ret = NO_ERROR;
 670     }
 671   }
 672   HeapFree(GetProcessHeap(), 0, buf);
 673   return ret;
 674 }
 675 #endif
 676
 677 DWORD getInterfacePhysicalByIndex(IF_INDEX index, PDWORD len, PBYTE addr,
 678  PDWORD type)
 679 {
 680   char nameBuf[IF_NAMESIZE];
 681   char *name = getInterfaceNameByIndex(index, nameBuf);
 682
 683   if (name)
 684     return getInterfacePhysicalByName(name, len, addr, type);
 685   else
 686     return ERROR_INVALID_DATA;
 687 }
 688
 689 DWORD getInterfaceMtuByName(const char *name, PDWORD mtu)
 690 {
 691   DWORD ret;
 692   int fd;
 693
 694   if (!name)
 695     return ERROR_INVALID_PARAMETER;
 696   if (!mtu)
 697     return ERROR_INVALID_PARAMETER;
 698
 699   fd = socket(PF_INET, SOCK_DGRAM, 0);
 700   if (fd != -1) {
 701     struct ifreq ifr;
 702
 703     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 704     if ((ioctl(fd, SIOCGIFMTU, &ifr)))
 705       ret = ERROR_INVALID_DATA;
 706     else {
 707 #ifndef __sun
 708       *mtu = ifr.ifr_mtu;
 709 #else
 710       *mtu = ifr.ifr_metric;
 711 #endif
 712       ret = NO_ERROR;
 713     }
 714     close(fd);
 715   }
 716   else
 717     ret = ERROR_NO_MORE_FILES;
 718   return ret;
 719 }
 720
 721 DWORD getInterfaceStatusByName(const char *name, INTERNAL_IF_OPER_STATUS *status)
 722 {
 723   DWORD ret;
 724   int fd;
 725
 726   if (!name)
 727     return ERROR_INVALID_PARAMETER;
 728   if (!status)
 729     return ERROR_INVALID_PARAMETER;
 730
 731   fd = socket(PF_INET, SOCK_DGRAM, 0);
 732   if (fd != -1) {
 733     struct ifreq ifr;
 734
 735     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 736     if ((ioctl(fd, SIOCGIFFLAGS, &ifr)))
 737       ret = ERROR_INVALID_DATA;
 738     else {
 739       if (ifr.ifr_flags & IFF_UP)
 740         *status = MIB_IF_OPER_STATUS_OPERATIONAL;
 741       else
 742         *status = MIB_IF_OPER_STATUS_NON_OPERATIONAL;
 743       ret = NO_ERROR;
 744     }
 745     close(fd);
 746   }
 747   else
 748     ret = ERROR_NO_MORE_FILES;
 749   return ret;
 750 }
 751
 752 DWORD getInterfaceEntryByName(const char *name, PMIB_IFROW entry)
 753 {
 754   BYTE addr[MAX_INTERFACE_PHYSADDR];
 755   DWORD ret, len = sizeof(addr), type;
 756
 757   if (!name)
 758     return ERROR_INVALID_PARAMETER;
 759   if (!entry)
 760     return ERROR_INVALID_PARAMETER;
 761
 762   if (getInterfacePhysicalByName(name, &len, addr, &type) == NO_ERROR) {
 763     WCHAR *assigner;
 764     const char *walker;
 765
 766     memset(entry, 0, sizeof(MIB_IFROW));
 767     for (assigner = entry->wszName, walker = name; *walker;
 768      walker++, assigner++)
 769       *assigner = *walker;
 770     *assigner = 0;
 771     getInterfaceIndexByName(name, &entry->dwIndex);
 772     entry->dwPhysAddrLen = len;
 773     memcpy(entry->bPhysAddr, addr, len);
 774     memset(entry->bPhysAddr + len, 0, sizeof(entry->bPhysAddr) - len);
 775     entry->dwType = type;
 776     /* FIXME: how to calculate real speed? */
 777     getInterfaceMtuByName(name, &entry->dwMtu);
 778     /* lie, there's no "administratively down" here */
 779     entry->dwAdminStatus = MIB_IF_ADMIN_STATUS_UP;
 780     getInterfaceStatusByName(name, &entry->dwOperStatus);
 781     /* punt on dwLastChange? */
 782     entry->dwDescrLen = min(strlen(name), MAX_INTERFACE_DESCRIPTION - 1);
 783     memcpy(entry->bDescr, name, entry->dwDescrLen);
 784     entry->bDescr[entry->dwDescrLen] = '\0';
 785     entry->dwDescrLen++;
 786     ret = NO_ERROR;
 787   }
 788   else
 789     ret = ERROR_INVALID_DATA;
 790   return ret;
 791 }
 792
 793 static DWORD getIPAddrRowByName(PMIB_IPADDRROW ipAddrRow, const char *ifName,
 794  const struct sockaddr *sa)
 795 {
 796   DWORD ret, bcast;
 797
 798   ret = getInterfaceIndexByName(ifName, &ipAddrRow->dwIndex);
 799   memcpy(&ipAddrRow->dwAddr, sa->sa_data + 2, sizeof(DWORD));
 800   ipAddrRow->dwMask = getInterfaceMaskByName(ifName);
 801   /* the dwBCastAddr member isn't the broadcast address, it indicates whether
 802    * the interface uses the 1's broadcast address (1) or the 0's broadcast
 803    * address (0).
 804    */
 805   bcast = getInterfaceBCastAddrByName(ifName);
 806   ipAddrRow->dwBCastAddr = (bcast & ipAddrRow->dwMask) ? 1 : 0;
 807   /* FIXME: hardcoded reasm size, not sure where to get it */
 808   ipAddrRow->dwReasmSize = 65535;
 809   ipAddrRow->unused1 = 0;
 810   ipAddrRow->wType = 0;
 811   return ret;
 812 }
 813
 814 #ifdef HAVE_IFADDRS_H
 815
 816 /* Counts the IPv4 addresses in the system using the return value from
 817  * getifaddrs, returning the count.
 818  */
 819 static DWORD countIPv4Addresses(struct ifaddrs *ifa)
 820 {
 821   DWORD numAddresses = 0;
 822
 823   for (; ifa; ifa = ifa->ifa_next)
 824     if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET)
 825       numAddresses++;
 826   return numAddresses;
 827 }
 828
 829 DWORD getNumIPAddresses(void)
 830 {
 831   DWORD numAddresses = 0;
 832   struct ifaddrs *ifa;
 833
 834   if (!getifaddrs(&ifa))
 835   {
 836     numAddresses = countIPv4Addresses(ifa);
 837     freeifaddrs(ifa);
 838   }
 839   return numAddresses;
 840 }
 841
 842 DWORD getIPAddrTable(PMIB_IPADDRTABLE *ppIpAddrTable, HANDLE heap, DWORD flags)
 843 {
 844   DWORD ret;
 845
 846   if (!ppIpAddrTable)
 847     ret = ERROR_INVALID_PARAMETER;
 848   else
 849   {
 850     struct ifaddrs *ifa;
 851
 852     if (!getifaddrs(&ifa))
 853     {
 854       DWORD size = sizeof(MIB_IPADDRTABLE);
 855       DWORD numAddresses = countIPv4Addresses(ifa);
 856
 857       if (numAddresses > 1)
 858         size += (numAddresses - 1) * sizeof(MIB_IPADDRROW);
 859       *ppIpAddrTable = HeapAlloc(heap, flags, size);
 860       if (*ppIpAddrTable)
 861       {
 862         DWORD i = 0;
 863         struct ifaddrs *ifp;
 864
 865         ret = NO_ERROR;
 866         (*ppIpAddrTable)->dwNumEntries = numAddresses;
 867         for (ifp = ifa; !ret && ifp; ifp = ifp->ifa_next)
 868         {
 869           if (!ifp->ifa_addr || ifp->ifa_addr->sa_family != AF_INET)
 870             continue;
 871
 872           ret = getIPAddrRowByName(&(*ppIpAddrTable)->table[i], ifp->ifa_name,
 873            ifp->ifa_addr);
 874           i++;
 875         }
 876         if (ret)
 877           HeapFree(GetProcessHeap(), 0, *ppIpAddrTable);
 878       }
 879       else
 880         ret = ERROR_OUTOFMEMORY;
 881       freeifaddrs(ifa);
 882     }
 883     else
 884       ret = ERROR_INVALID_PARAMETER;
 885   }
 886   return ret;
 887 }
 888
 889 ULONG v6addressesFromIndex(IF_INDEX index, SOCKET_ADDRESS **addrs, ULONG *num_addrs, SOCKET_ADDRESS **masks)
 890 {
 891   struct ifaddrs *ifa;
 892   ULONG ret;
 893
 894   if (!getifaddrs(&ifa))
 895   {
 896     struct ifaddrs *p;
 897     ULONG n;
 898     char name[IFNAMSIZ];
 899
 900     getInterfaceNameByIndex(index, name);
 901     for (p = ifa, n = 0; p; p = p->ifa_next)
 902       if (p->ifa_addr && p->ifa_addr->sa_family == AF_INET6 &&
 903           !strcmp(name, p->ifa_name))
 904         n++;
 905     if (n)
 906     {
 907       *addrs = HeapAlloc(GetProcessHeap(), 0, n * (sizeof(SOCKET_ADDRESS) +
 908                          sizeof(struct WS_sockaddr_in6)));
 909       *masks = HeapAlloc(GetProcessHeap(), 0, n * (sizeof(SOCKET_ADDRESS) +
 910                          sizeof(struct WS_sockaddr_in6)));
 911       if (*addrs && *masks)
 912       {
 913         struct WS_sockaddr_in6 *next_addr = (struct WS_sockaddr_in6 *)(
 914             (BYTE *)*addrs + n * sizeof(SOCKET_ADDRESS));
 915         struct WS_sockaddr_in6 *mask_addr = (struct WS_sockaddr_in6 *)(
 916             (BYTE *)*masks + n * sizeof(SOCKET_ADDRESS));
 917
 918         for (p = ifa, n = 0; p; p = p->ifa_next)
 919         {
 920           if (p->ifa_addr && p->ifa_addr->sa_family == AF_INET6 &&
 921               !strcmp(name, p->ifa_name))
 922           {
 923             struct sockaddr_in6 *addr = (struct sockaddr_in6 *)p->ifa_addr;
 924             struct sockaddr_in6 *mask = (struct sockaddr_in6 *)p->ifa_netmask;
 925
 926             next_addr->sin6_family = WS_AF_INET6;
 927             next_addr->sin6_port = addr->sin6_port;
 928             next_addr->sin6_flowinfo = addr->sin6_flowinfo;
 929             memcpy(&next_addr->sin6_addr, &addr->sin6_addr,
 930              sizeof(next_addr->sin6_addr));
 931             next_addr->sin6_scope_id = addr->sin6_scope_id;
 932             (*addrs)[n].lpSockaddr = (LPSOCKADDR)next_addr;
 933             (*addrs)[n].iSockaddrLength = sizeof(struct WS_sockaddr_in6);
 934             next_addr++;
 935
 936             mask_addr->sin6_family = WS_AF_INET6;
 937             mask_addr->sin6_port = mask->sin6_port;
 938             mask_addr->sin6_flowinfo = mask->sin6_flowinfo;
 939             memcpy(&mask_addr->sin6_addr, &mask->sin6_addr,
 940              sizeof(mask_addr->sin6_addr));
 941             mask_addr->sin6_scope_id = mask->sin6_scope_id;
 942             (*masks)[n].lpSockaddr = (LPSOCKADDR)mask_addr;
 943             (*masks)[n].iSockaddrLength = sizeof(struct WS_sockaddr_in6);
 944             mask_addr++;
 945             n++;
 946           }
 947         }
 948         *num_addrs = n;
 949         ret = ERROR_SUCCESS;
 950       }
 951       else
 952       {
 953         HeapFree(GetProcessHeap(), 0, *addrs);
 954         HeapFree(GetProcessHeap(), 0, *masks);
 955         ret = ERROR_OUTOFMEMORY;
 956       }
 957     }
 958     else
 959     {
 960       *addrs = NULL;
 961       *num_addrs = 0;
 962       *masks = NULL;
 963       ret = ERROR_SUCCESS;
 964     }
 965     freeifaddrs(ifa);
 966   }
 967   else
 968     ret = ERROR_NO_DATA;
 969   return ret;
 970 }
 971
 972 #else
 973
 974 /* Enumerates the IP addresses in the system using SIOCGIFCONF, returning
 975  * the count to you in *pcAddresses.  It also returns to you the struct ifconf
 976  * used by the call to ioctl, so that you may process the addresses further.
 977  * Free ifc->ifc_buf using HeapFree.
 978  * Returns NO_ERROR on success, something else on failure.
 979  */
 980 static DWORD enumIPAddresses(PDWORD pcAddresses, struct ifconf *ifc)
 981 {
 982   DWORD ret;
 983   int fd;
 984
 985   fd = socket(PF_INET, SOCK_DGRAM, 0);
 986   if (fd != -1) {
 987     int ioctlRet = 0;
 988     DWORD guessedNumAddresses = 0, numAddresses = 0;
 989     caddr_t ifPtr;
 990     int lastlen;
 991
 992     ret = NO_ERROR;
 993     ifc->ifc_len = 0;
 994     ifc->ifc_buf = NULL;
 995     /* there is no way to know the interface count beforehand,
 996        so we need to loop again and again upping our max each time
 997        until returned is constant across 2 calls */
 998     do {
 999       lastlen = ifc->ifc_len;
1000       HeapFree(GetProcessHeap(), 0, ifc->ifc_buf);
1001       if (guessedNumAddresses == 0)
1002         guessedNumAddresses = INITIAL_INTERFACES_ASSUMED;
1003       else
1004         guessedNumAddresses *= 2;
1005       ifc->ifc_len = sizeof(struct ifreq) * guessedNumAddresses;
1006       ifc->ifc_buf = HeapAlloc(GetProcessHeap(), 0, ifc->ifc_len);
1007       ioctlRet = ioctl(fd, SIOCGIFCONF, ifc);
1008     } while ((ioctlRet == 0) && (ifc->ifc_len != lastlen));
1009
1010     if (ioctlRet == 0) {
1011       ifPtr = ifc->ifc_buf;
1012       while (ifPtr && ifPtr < ifc->ifc_buf + ifc->ifc_len) {
1013         struct ifreq *ifr = (struct ifreq *)ifPtr;
1014
1015         if (ifr->ifr_addr.sa_family == AF_INET)
1016           numAddresses++;
1017
1018         ifPtr += ifreq_len((struct ifreq *)ifPtr);
1019       }
1020     }
1021     else
1022       ret = ERROR_INVALID_PARAMETER; /* FIXME: map from errno to Win32 */
1023     if (!ret)
1024       *pcAddresses = numAddresses;
1025     else
1026     {
1027       HeapFree(GetProcessHeap(), 0, ifc->ifc_buf);
1028       ifc->ifc_buf = NULL;
1029     }
1030     close(fd);
1031   }
1032   else
1033     ret = ERROR_NO_SYSTEM_RESOURCES;
1034   return ret;
1035 }
1036
1037 DWORD getNumIPAddresses(void)
1038 {
1039   DWORD numAddresses = 0;
1040   struct ifconf ifc;
1041
1042   if (!enumIPAddresses(&numAddresses, &ifc))
1043     HeapFree(GetProcessHeap(), 0, ifc.ifc_buf);
1044   return numAddresses;
1045 }
1046
1047 DWORD getIPAddrTable(PMIB_IPADDRTABLE *ppIpAddrTable, HANDLE heap, DWORD flags)
1048 {
1049   DWORD ret;
1050
1051   if (!ppIpAddrTable)
1052     ret = ERROR_INVALID_PARAMETER;
1053   else
1054   {
1055     DWORD numAddresses = 0;
1056     struct ifconf ifc;
1057
1058     ret = enumIPAddresses(&numAddresses, &ifc);
1059     if (!ret)
1060     {
1061       DWORD size = sizeof(MIB_IPADDRTABLE);
1062
1063       if (numAddresses > 1)
1064         size += (numAddresses - 1) * sizeof(MIB_IPADDRROW);
1065       *ppIpAddrTable = HeapAlloc(heap, flags, size);
1066       if (*ppIpAddrTable) {
1067         DWORD i = 0;
1068         caddr_t ifPtr;
1069
1070         ret = NO_ERROR;
1071         (*ppIpAddrTable)->dwNumEntries = numAddresses;
1072         ifPtr = ifc.ifc_buf;
1073         while (!ret && ifPtr && ifPtr < ifc.ifc_buf + ifc.ifc_len) {
1074           struct ifreq *ifr = (struct ifreq *)ifPtr;
1075
1076           ifPtr += ifreq_len(ifr);
1077
1078           if (ifr->ifr_addr.sa_family != AF_INET)
1079              continue;
1080
1081           ret = getIPAddrRowByName(&(*ppIpAddrTable)->table[i], ifr->ifr_name,
1082            &ifr->ifr_addr);
1083           i++;
1084         }
1085         if (ret)
1086           HeapFree(GetProcessHeap(), 0, *ppIpAddrTable);
1087       }
1088       else
1089         ret = ERROR_OUTOFMEMORY;
1090       HeapFree(GetProcessHeap(), 0, ifc.ifc_buf);
1091     }
1092   }
1093   return ret;
1094 }
1095
1096 ULONG v6addressesFromIndex(IF_INDEX index, SOCKET_ADDRESS **addrs, ULONG *num_addrs, SOCKET_ADDRESS **masks)
1097 {
1098   *addrs = NULL;
1099   *num_addrs = 0;
1100   *masks = NULL;
1101   return ERROR_SUCCESS;
1102 }
1103
1104 #endif
1105
1106 char *toIPAddressString(unsigned int addr, char string[16])
1107 {
1108   if (string) {
1109     struct in_addr iAddr;
1110
1111     iAddr.s_addr = addr;
1112     /* extra-anal, just to make auditors happy */
1113     lstrcpynA(string, inet_ntoa(iAddr), 16);
1114   }
1115   return string;
1116 }