This source file includes following definitions.
- pmix_ifnametoaddr
- pmix_ifnametoindex
- pmix_ifnametokindex
- pmix_ifindextokindex
- pmix_ifaddrtoname
- pmix_ifaddrtokindex
- pmix_ifcount
- pmix_ifbegin
- pmix_ifnext
- pmix_ifindextoaddr
- pmix_ifkindextoaddr
- pmix_ifindextomask
- pmix_ifindextomac
- pmix_ifindextomtu
- pmix_ifindextoflags
- pmix_ifindextoname
- pmix_ifkindextoname
- pmix_ifislocal
- parse_ipv4_dots
- pmix_iftupletoaddr
- pmix_ifisloopback
- pmix_ifmatches
- pmix_ifgetaliases
- pmix_ifnametoaddr
- pmix_ifaddrtoname
- pmix_ifnametoindex
- pmix_ifnametokindex
- pmix_ifindextokindex
- pmix_ifcount
- pmix_ifbegin
- pmix_ifnext
- pmix_ifindextoname
- pmix_ifkindextoname
- pmix_ifindextoaddr
- pmix_ifindextomask
- pmix_ifislocal
- pmix_iftupletoaddr
- pmix_ifmatches
- pmix_ifgetaliases
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 
  23 
  24 
  25 
  26 
  27 #include "pmix_config.h"
  28 #include "pmix_common.h"
  29 
  30 #include <string.h>
  31 #ifdef HAVE_UNISTD_H
  32 #include <unistd.h>
  33 #endif
  34 #include <errno.h>
  35 #ifdef HAVE_SYS_TYPES_H
  36 #include <sys/types.h>
  37 #endif
  38 #ifdef HAVE_SYS_SOCKET_H
  39 #include <sys/socket.h>
  40 #endif
  41 #ifdef HAVE_SYS_SOCKIO_H
  42 #include <sys/sockio.h>
  43 #endif
  44 #ifdef HAVE_SYS_IOCTL_H
  45 #include <sys/ioctl.h>
  46 #endif
  47 #ifdef HAVE_NETINET_IN_H
  48 #include <netinet/in.h>
  49 #endif
  50 #ifdef HAVE_ARPA_INET_H
  51 #include <arpa/inet.h>
  52 #endif
  53 #ifdef HAVE_NET_IF_H
  54 #include <net/if.h>
  55 #endif
  56 #ifdef HAVE_NETDB_H
  57 #include <netdb.h>
  58 #endif
  59 #ifdef HAVE_IFADDRS_H
  60 #include <ifaddrs.h>
  61 #endif
  62 #include <ctype.h>
  63 
  64 #include "src/class/pmix_list.h"
  65 #include "src/util/error.h"
  66 #include "src/util/pif.h"
  67 #include "src/util/net.h"
  68 #include "src/util/output.h"
  69 #include "src/util/argv.h"
  70 #include "src/util/show_help.h"
  71 
  72 #include "src/mca/pif/base/base.h"
  73 
  74 #ifdef HAVE_STRUCT_SOCKADDR_IN
  75 
  76 #ifndef MIN
  77 #  define MIN(a,b)                ((a) < (b) ? (a) : (b))
  78 #endif
  79 
  80 
  81 
  82 
  83 
  84 
  85 int pmix_ifnametoaddr(const char* if_name, struct sockaddr* addr, int length)
  86 {
  87     pmix_pif_t* intf;
  88 
  89     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
  90         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
  91         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
  92         if (strcmp(intf->if_name, if_name) == 0) {
  93             memcpy(addr, &intf->if_addr, length);
  94             return PMIX_SUCCESS;
  95         }
  96     }
  97     return PMIX_ERROR;
  98 }
  99 
 100 
 101 
 102 
 103 
 104 
 105 
 106 int pmix_ifnametoindex(const char* if_name)
 107 {
 108     pmix_pif_t* intf;
 109 
 110     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 111         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 112         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 113         if (strcmp(intf->if_name, if_name) == 0) {
 114             return intf->if_index;
 115         }
 116     }
 117     return -1;
 118 }
 119 
 120 
 121 
 122 
 123 
 124 
 125 
 126 int16_t pmix_ifnametokindex(const char* if_name)
 127 {
 128     pmix_pif_t* intf;
 129 
 130     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 131         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 132         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 133         if (strcmp(intf->if_name, if_name) == 0) {
 134             return intf->if_kernel_index;
 135         }
 136     }
 137     return -1;
 138 }
 139 
 140 
 141 
 142 
 143 
 144 
 145 
 146 int pmix_ifindextokindex(int if_index)
 147 {
 148     pmix_pif_t* intf;
 149 
 150     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 151         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 152         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 153         if (if_index == intf->if_index) {
 154             return intf->if_kernel_index;
 155         }
 156     }
 157     return -1;
 158 }
 159 
 160 
 161 
 162 
 163 
 164 
 165 
 166 int pmix_ifaddrtoname(const char* if_addr, char* if_name, int length)
 167 {
 168     pmix_pif_t* intf;
 169     int error;
 170     struct addrinfo hints, *res = NULL, *r;
 171 
 172     
 173     if (pmix_if_do_not_resolve) {
 174         
 175 
 176 
 177         return PMIX_ERR_NOT_FOUND;
 178     }
 179 
 180     memset(&hints, 0, sizeof(hints));
 181     hints.ai_family = PF_UNSPEC;
 182     hints.ai_socktype = SOCK_STREAM;
 183     error = getaddrinfo(if_addr, NULL, &hints, &res);
 184 
 185     if (error) {
 186         if (NULL != res) {
 187             freeaddrinfo (res);
 188         }
 189         return PMIX_ERR_NOT_FOUND;
 190     }
 191 
 192     for (r = res; r != NULL; r = r->ai_next) {
 193         for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 194             intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 195             intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 196 
 197             if (AF_INET == r->ai_family) {
 198                 struct sockaddr_in ipv4;
 199                 struct sockaddr_in *inaddr;
 200 
 201                 inaddr = (struct sockaddr_in*) &intf->if_addr;
 202                 memcpy (&ipv4, r->ai_addr, r->ai_addrlen);
 203 
 204                 if (inaddr->sin_addr.s_addr == ipv4.sin_addr.s_addr) {
 205                     pmix_strncpy(if_name, intf->if_name, length-1);
 206                     freeaddrinfo (res);
 207                     return PMIX_SUCCESS;
 208                 }
 209             }
 210             else {
 211                 if (IN6_ARE_ADDR_EQUAL(&((struct sockaddr_in6*) &intf->if_addr)->sin6_addr,
 212                     &((struct sockaddr_in6*) r->ai_addr)->sin6_addr)) {
 213                     pmix_strncpy(if_name, intf->if_name, length-1);
 214                     freeaddrinfo (res);
 215                     return PMIX_SUCCESS;
 216                 }
 217             }
 218         }
 219     }
 220     if (NULL != res) {
 221         freeaddrinfo (res);
 222     }
 223 
 224     
 225     return PMIX_ERR_NOT_FOUND;
 226 }
 227 
 228 
 229 
 230 
 231 
 232 
 233 int16_t pmix_ifaddrtokindex(const char* if_addr)
 234 {
 235     pmix_pif_t* intf;
 236     int error;
 237     struct addrinfo hints, *res = NULL, *r;
 238     int if_kernel_index;
 239     size_t len;
 240 
 241     memset(&hints, 0, sizeof(hints));
 242     hints.ai_family = PF_UNSPEC;
 243     hints.ai_socktype = SOCK_STREAM;
 244     error = getaddrinfo(if_addr, NULL, &hints, &res);
 245 
 246     if (error) {
 247         if (NULL != res) {
 248             freeaddrinfo (res);
 249         }
 250         return PMIX_ERR_NOT_FOUND;
 251     }
 252 
 253     for (r = res; r != NULL; r = r->ai_next) {
 254         PMIX_LIST_FOREACH(intf, &pmix_if_list, pmix_pif_t) {
 255             if (AF_INET == r->ai_family && AF_INET == intf->af_family) {
 256                 struct sockaddr_in ipv4, intv4;
 257                 memset(&ipv4, 0, sizeof(struct sockaddr_in));
 258                 len = (r->ai_addrlen < sizeof(struct sockaddr_in)) ? r->ai_addrlen : sizeof(struct sockaddr_in);
 259                 memcpy(&ipv4, r->ai_addr, len);
 260                 memset(&intv4, 0, sizeof(struct sockaddr_in));
 261                 memcpy(&intv4, &intf->if_addr, sizeof(struct sockaddr_in));
 262                 if (pmix_net_samenetwork((struct sockaddr*)&ipv4, (struct sockaddr*)&intv4, intf->if_mask)) {
 263                     if_kernel_index = intf->if_kernel_index;
 264                     freeaddrinfo (res);
 265                     return if_kernel_index;
 266                 }
 267             } else if (AF_INET6 == r->ai_family && AF_INET6 == intf->af_family) {
 268                 struct sockaddr_in6 ipv6, intv6;
 269                 memset(&ipv6, 0, sizeof(struct sockaddr));
 270                 len = (r->ai_addrlen < sizeof(struct sockaddr_in6)) ? r->ai_addrlen : sizeof(struct sockaddr_in6);
 271                 memcpy(&ipv6, r->ai_addr, len);
 272                 memset(&intv6, 0, sizeof(struct sockaddr));
 273                 memcpy(&intv6, &intf->if_addr, sizeof(struct sockaddr_in6));
 274                 if (pmix_net_samenetwork((struct sockaddr*)&intv6,
 275                                          (struct sockaddr*)&ipv6, intf->if_mask)) {
 276                     if_kernel_index = intf->if_kernel_index;
 277                     freeaddrinfo (res);
 278                     return if_kernel_index;
 279                 }
 280             }
 281         }
 282     }
 283     if (NULL != res) {
 284         freeaddrinfo (res);
 285     }
 286     return PMIX_ERR_NOT_FOUND;
 287 }
 288 
 289 
 290 
 291 
 292 
 293 int pmix_ifcount(void)
 294 {
 295     return pmix_list_get_size(&pmix_if_list);
 296 }
 297 
 298 
 299 
 300 
 301 
 302 
 303 
 304 int pmix_ifbegin(void)
 305 {
 306     pmix_pif_t *intf;
 307 
 308     intf = (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 309     if (NULL != intf)
 310         return intf->if_index;
 311     return (-1);
 312 }
 313 
 314 
 315 
 316 
 317 
 318 
 319 
 320 
 321 int pmix_ifnext(int if_index)
 322 {
 323     pmix_pif_t *intf;
 324 
 325     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 326         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 327         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 328         if (intf->if_index == if_index) {
 329             do {
 330                 pmix_pif_t* if_next = (pmix_pif_t*)pmix_list_get_next(intf);
 331                 pmix_pif_t* if_end =  (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 332                 if (if_next == if_end) {
 333                     return -1;
 334                 }
 335                 intf = if_next;
 336             } while(intf->if_index == if_index);
 337             return intf->if_index;
 338         }
 339     }
 340     return (-1);
 341 }
 342 
 343 
 344 
 345 
 346 
 347 
 348 
 349 int pmix_ifindextoaddr(int if_index, struct sockaddr* if_addr, unsigned int length)
 350 {
 351     pmix_pif_t* intf;
 352 
 353     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 354          intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 355          intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 356         if (intf->if_index == if_index) {
 357             memcpy(if_addr, &intf->if_addr, MIN(length, sizeof (intf->if_addr)));
 358             return PMIX_SUCCESS;
 359         }
 360     }
 361     return PMIX_ERROR;
 362 }
 363 
 364 
 365 
 366 
 367 
 368 
 369 int pmix_ifkindextoaddr(int if_kindex, struct sockaddr* if_addr, unsigned int length)
 370 {
 371     pmix_pif_t* intf;
 372 
 373     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 374          intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 375          intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 376         if (intf->if_kernel_index == if_kindex) {
 377             memcpy(if_addr, &intf->if_addr, MIN(length, sizeof (intf->if_addr)));
 378             return PMIX_SUCCESS;
 379         }
 380     }
 381     return PMIX_ERROR;
 382 }
 383 
 384 
 385 
 386 
 387 
 388 
 389 
 390 int pmix_ifindextomask(int if_index, uint32_t* if_mask, int length)
 391 {
 392     pmix_pif_t* intf;
 393 
 394     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 395         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 396         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 397         if (intf->if_index == if_index) {
 398             memcpy(if_mask, &intf->if_mask, length);
 399             return PMIX_SUCCESS;
 400         }
 401     }
 402     return PMIX_ERROR;
 403 }
 404 
 405 
 406 
 407 
 408 
 409 
 410 int pmix_ifindextomac(int if_index, uint8_t mac[6])
 411 {
 412     pmix_pif_t* intf;
 413 
 414     for (intf = (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 415         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 416         intf = (pmix_pif_t*)pmix_list_get_next(intf)) {
 417         if (intf->if_index == if_index) {
 418             memcpy(mac, &intf->if_mac, 6);
 419             return PMIX_SUCCESS;
 420         }
 421     }
 422     return PMIX_ERROR;
 423 }
 424 
 425 
 426 
 427 
 428 
 429 
 430 int pmix_ifindextomtu(int if_index, int *mtu)
 431 {
 432     pmix_pif_t* intf;
 433 
 434     for (intf = (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 435         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 436         intf = (pmix_pif_t*)pmix_list_get_next(intf)) {
 437         if (intf->if_index == if_index) {
 438             *mtu = intf->ifmtu;
 439             return PMIX_SUCCESS;
 440         }
 441     }
 442     return PMIX_ERROR;
 443 }
 444 
 445 
 446 
 447 
 448 
 449 
 450 int pmix_ifindextoflags(int if_index, uint32_t* if_flags)
 451 {
 452     pmix_pif_t* intf;
 453 
 454     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 455         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 456         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 457         if (intf->if_index == if_index) {
 458             memcpy(if_flags, &intf->if_flags, sizeof(uint32_t));
 459             return PMIX_SUCCESS;
 460         }
 461     }
 462     return PMIX_ERROR;
 463 }
 464 
 465 
 466 
 467 
 468 
 469 
 470 
 471 
 472 int pmix_ifindextoname(int if_index, char* if_name, int length)
 473 {
 474     pmix_pif_t *intf;
 475 
 476     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 477         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 478         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 479         if (intf->if_index == if_index) {
 480             pmix_strncpy(if_name, intf->if_name, length-1);
 481             return PMIX_SUCCESS;
 482         }
 483     }
 484     return PMIX_ERROR;
 485 }
 486 
 487 
 488 
 489 
 490 
 491 
 492 
 493 int pmix_ifkindextoname(int if_kindex, char* if_name, int length)
 494 {
 495     pmix_pif_t *intf;
 496 
 497     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 498         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 499         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 500         if (intf->if_kernel_index == if_kindex) {
 501             pmix_strncpy(if_name, intf->if_name, length-1);
 502             return PMIX_SUCCESS;
 503         }
 504     }
 505     return PMIX_ERROR;
 506 }
 507 
 508 
 509 #define ADDRLEN 100
 510 bool
 511 pmix_ifislocal(const char *hostname)
 512 {
 513     char addrname[NI_MAXHOST]; 
 514 
 515 
 516     if (PMIX_SUCCESS == pmix_ifaddrtoname(hostname, addrname, ADDRLEN)) {
 517         return true;
 518     }
 519 
 520     return false;
 521 }
 522 
 523 static int parse_ipv4_dots(const char *addr, uint32_t* net, int* dots)
 524 {
 525     const char *start = addr, *end;
 526     uint32_t n[]={0,0,0,0};
 527     int i;
 528 
 529     
 530     for( i = 0; i < 4; i++ ) {
 531         n[i] = strtoul(start, (char**)&end, 10);
 532         if( end == start ) {
 533             
 534 
 535 
 536 
 537 
 538             break;
 539         }
 540         
 541         if( n[i] > 255 ) {
 542             return PMIX_ERR_NETWORK_NOT_PARSEABLE;
 543         }
 544         
 545         for( start = end; '\0' != *start; start++ )
 546             if( '.' != *start ) break;
 547     }
 548     *dots = i;
 549     *net = PMIX_PIF_ASSEMBLE_NETWORK(n[0], n[1], n[2], n[3]);
 550     return PMIX_SUCCESS;
 551 }
 552 
 553 int
 554 pmix_iftupletoaddr(const char *inaddr, uint32_t *net, uint32_t *mask)
 555 {
 556     int pval, dots, rc = PMIX_SUCCESS;
 557     const char *ptr;
 558 
 559     
 560     if (NULL != mask) {
 561         
 562         *mask = 0xFFFFFFFF;
 563 
 564         
 565         if (NULL != (ptr = strchr(inaddr, '/'))) {
 566             ptr = ptr + 1;  
 567             
 568             if (NULL != strchr(ptr, '.')) {
 569                 
 570                 rc = parse_ipv4_dots(ptr, mask, &dots);
 571             } else {
 572                 
 573 
 574 
 575                 pval = strtol(ptr, NULL, 10);
 576                 if ((pval > 31) || (pval < 1)) {
 577                     pmix_output(0, "pmix_iftupletoaddr: unknown mask");
 578                     return PMIX_ERR_NETWORK_NOT_PARSEABLE;
 579                 }
 580                 *mask = 0xFFFFFFFF << (32 - pval);
 581             }
 582         } else {
 583             
 584             for (ptr = inaddr, pval = 0; '\0'!= *ptr; ptr++) {
 585                 if ('.' == *ptr) {
 586                     pval++;
 587                 }
 588             }
 589             
 590 
 591 
 592 
 593             if (3 == pval) {
 594                 *mask = 0xFFFFFFFF;
 595             } else if (2 == pval) {         
 596                 *mask = 0xFFFFFF00;
 597             } else if (1 == pval) {  
 598                 *mask = 0xFFFF0000;
 599             } else if (0 == pval) {  
 600                 *mask = 0xFF000000;
 601             } else {
 602                 pmix_output(0, "pmix_iftupletoaddr: unknown mask");
 603                 return PMIX_ERR_NETWORK_NOT_PARSEABLE;
 604             }
 605         }
 606     }
 607 
 608     
 609     if (NULL != net) {
 610         
 611         rc = parse_ipv4_dots(inaddr, net, &dots);
 612     }
 613 
 614     return rc;
 615 }
 616 
 617 
 618 
 619 
 620 
 621 bool pmix_ifisloopback(int if_index)
 622 {
 623     pmix_pif_t* intf;
 624 
 625     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 626         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 627         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 628         if (intf->if_index == if_index) {
 629             if ((intf->if_flags & IFF_LOOPBACK) != 0) {
 630                 return true;
 631             }
 632         }
 633     }
 634     return false;
 635 }
 636 
 637 
 638 
 639 
 640 
 641 int pmix_ifmatches(int kidx, char **nets)
 642 {
 643     bool named_if;
 644     int i, rc;
 645     size_t j;
 646     int kindex;
 647     struct sockaddr_in inaddr;
 648     uint32_t addr, netaddr, netmask;
 649 
 650     
 651     if (PMIX_SUCCESS != (rc = pmix_ifkindextoaddr(kidx, (struct sockaddr*)&inaddr, sizeof(inaddr)))) {
 652         return rc;
 653     }
 654     addr = ntohl(inaddr.sin_addr.s_addr);
 655 
 656     for (i=0; NULL != nets[i]; i++) {
 657         
 658 
 659 
 660         named_if = false;
 661         for (j=0; j < strlen(nets[i]); j++) {
 662             if (isalpha(nets[i][j]) && '.' != nets[i][j]) {
 663                 named_if = true;
 664                 break;
 665             }
 666         }
 667         if (named_if) {
 668             if (0 > (kindex = pmix_ifnametokindex(nets[i]))) {
 669                 continue;
 670             }
 671             if (kindex == kidx) {
 672                 return PMIX_SUCCESS;
 673             }
 674         } else {
 675             if (PMIX_SUCCESS != (rc = pmix_iftupletoaddr(nets[i], &netaddr, &netmask))) {
 676                 pmix_show_help("help-pmix-util.txt", "invalid-net-mask", true, nets[i]);
 677                 return rc;
 678             }
 679             if (netaddr == (addr & netmask)) {
 680                 return PMIX_SUCCESS;
 681             }
 682         }
 683     }
 684     
 685     return PMIX_ERR_NOT_FOUND;
 686 }
 687 
 688 void pmix_ifgetaliases(char ***aliases)
 689 {
 690     pmix_pif_t* intf;
 691     char ipv4[INET_ADDRSTRLEN];
 692     struct sockaddr_in *addr;
 693     char ipv6[INET6_ADDRSTRLEN];
 694     struct sockaddr_in6 *addr6;
 695 
 696     
 697     *aliases = NULL;
 698 
 699     for (intf =  (pmix_pif_t*)pmix_list_get_first(&pmix_if_list);
 700         intf != (pmix_pif_t*)pmix_list_get_end(&pmix_if_list);
 701         intf =  (pmix_pif_t*)pmix_list_get_next(intf)) {
 702         addr = (struct sockaddr_in*) &intf->if_addr;
 703         
 704         if ((intf->if_flags & IFF_LOOPBACK) != 0) {
 705             continue;
 706         }
 707         if (addr->sin_family == AF_INET) {
 708             inet_ntop(AF_INET, &(addr->sin_addr.s_addr), ipv4, INET_ADDRSTRLEN);
 709             pmix_argv_append_nosize(aliases, ipv4);
 710         } else {
 711             addr6 = (struct sockaddr_in6*) &intf->if_addr;
 712             inet_ntop(AF_INET6, &(addr6->sin6_addr), ipv6, INET6_ADDRSTRLEN);
 713             pmix_argv_append_nosize(aliases, ipv6);
 714         }
 715     }
 716 }
 717 
 718 #else 
 719 
 720 
 721 
 722 
 723 int
 724 pmix_ifnametoaddr(const char* if_name,
 725                   struct sockaddr* if_addr, int size)
 726 {
 727     return PMIX_ERR_NOT_SUPPORTED;
 728 }
 729 
 730 int
 731 pmix_ifaddrtoname(const char* if_addr,
 732                   char* if_name, int size)
 733 {
 734     return PMIX_ERR_NOT_SUPPORTED;
 735 }
 736 
 737 int
 738 pmix_ifnametoindex(const char* if_name)
 739 {
 740     return PMIX_ERR_NOT_SUPPORTED;
 741 }
 742 
 743 int16_t
 744 pmix_ifnametokindex(const char* if_name)
 745 {
 746     return PMIX_ERR_NOT_SUPPORTED;
 747 }
 748 
 749 int
 750 pmix_ifindextokindex(int if_index)
 751 {
 752     return PMIX_ERR_NOT_SUPPORTED;
 753 }
 754 
 755 int
 756 pmix_ifcount(void)
 757 {
 758     return PMIX_ERR_NOT_SUPPORTED;
 759 }
 760 
 761 int
 762 pmix_ifbegin(void)
 763 {
 764     return PMIX_ERR_NOT_SUPPORTED;
 765 }
 766 
 767 int
 768 pmix_ifnext(int if_index)
 769 {
 770     return PMIX_ERR_NOT_SUPPORTED;
 771 }
 772 
 773 int
 774 pmix_ifindextoname(int if_index, char* if_name, int length)
 775 {
 776     return PMIX_ERR_NOT_SUPPORTED;
 777 }
 778 
 779 int
 780 pmix_ifkindextoname(int kif_index, char* if_name, int length)
 781 {
 782     return PMIX_ERR_NOT_SUPPORTED;
 783 }
 784 
 785 int
 786 pmix_ifindextoaddr(int if_index, struct sockaddr* if_addr, unsigned int length)
 787 {
 788     return PMIX_ERR_NOT_SUPPORTED;
 789 }
 790 
 791 int
 792 pmix_ifindextomask(int if_index, uint32_t* if_addr, int length)
 793 {
 794     return PMIX_ERR_NOT_SUPPORTED;
 795 }
 796 
 797 bool
 798 pmix_ifislocal(const char *hostname)
 799 {
 800     return false;
 801 }
 802 
 803 int
 804 pmix_iftupletoaddr(const char *inaddr, uint32_t *net, uint32_t *mask)
 805 {
 806     return 0;
 807 }
 808 
 809 int pmix_ifmatches(int idx, char **nets)
 810 {
 811     return PMIX_ERR_NOT_SUPPORTED;
 812 }
 813 
 814 void pmix_ifgetaliases(char ***aliases)
 815 {
 816     
 817     *aliases = NULL;
 818 }
 819 
 820 #endif