1 /*
   2  * Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 
  27 #include <errno.h>
  28 #include <strings.h>
  29 #include <netinet/in.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <sys/types.h>
  33 #include <sys/socket.h>
  34 #include <arpa/inet.h>
  35 #include <net/if.h>
  36 #include <net/if_arp.h>
  37 
  38 #ifdef __solaris__
  39 #include <sys/dlpi.h>
  40 #include <fcntl.h>
  41 #include <stropts.h>
  42 #include <sys/sockio.h>
  43 #endif
  44 
  45 #ifdef __linux__
  46 #include <sys/ioctl.h>
  47 #include <bits/ioctls.h>
  48 #include <linux/sockios.h>
  49 #include <sys/utsname.h>
  50 #include <stdio.h>
  51 #endif
  52 
  53 #ifdef __linux__
  54 #define _PATH_PROCNET_IFINET6           "/proc/net/if_inet6"
  55 #endif
  56 
  57 #include "jvm.h"
  58 #include "jni_util.h"
  59 #include "net_util.h"
  60 
  61 typedef struct _netaddr  {
  62     struct sockaddr *addr;
  63     struct sockaddr *brdcast;
  64     short mask;
  65     int family; /* to make searches simple */
  66     struct _netaddr *next;
  67 } netaddr;
  68 
  69 typedef struct _netif {
  70     char *name;
  71     int index;
  72     char virtual;
  73     netaddr *addr;
  74     struct _netif *childs;
  75     struct _netif *next;
  76 } netif;
  77 
  78 /************************************************************************
  79  * NetworkInterface
  80  */
  81 
  82 #include "java_net_NetworkInterface.h"
  83 
  84 /************************************************************************
  85  * NetworkInterface
  86  */
  87 jclass ni_class;
  88 jfieldID ni_nameID;
  89 jfieldID ni_indexID;
  90 jfieldID ni_descID;
  91 jfieldID ni_addrsID;
  92 jfieldID ni_bindsID;
  93 jfieldID ni_virutalID;
  94 jfieldID ni_childsID;
  95 jfieldID ni_parentID;
  96 jmethodID ni_ctrID;
  97 
  98 static jclass ni_iacls;
  99 static jclass ni_ia4cls;
 100 static jclass ni_ia6cls;
 101 static jclass ni_ibcls;
 102 static jmethodID ni_ia4ctrID;
 103 static jmethodID ni_ia6ctrID;
 104 static jmethodID ni_ibctrID;
 105 static jfieldID ni_iaaddressID;
 106 static jfieldID ni_iafamilyID;
 107 static jfieldID ni_ia6ipaddressID;
 108 static jfieldID ni_ibaddressID;
 109 static jfieldID ni_ib4broadcastID;
 110 static jfieldID ni_ib4maskID;
 111 
 112 /** Private methods declarations **/
 113 static jobject createNetworkInterface(JNIEnv *env, netif *ifs);
 114 static int     getFlags0(JNIEnv *env, jstring  ifname);
 115 
 116 static netif  *enumInterfaces(JNIEnv *env);
 117 static netif  *enumIPv4Interfaces(JNIEnv *env, int sock, netif *ifs);
 118 
 119 #ifdef AF_INET6
 120 static netif  *enumIPv6Interfaces(JNIEnv *env, int sock, netif *ifs);
 121 #endif
 122 
 123 static netif  *addif(JNIEnv *env, int sock, const char * if_name, netif *ifs, struct sockaddr* ifr_addrP, int family, short prefix);
 124 static void    freeif(netif *ifs);
 125 
 126 static int     openSocket(JNIEnv *env, int proto);
 127 static int     openSocketWithFallback(JNIEnv *env, const char *ifname);
 128 
 129 
 130 static struct  sockaddr *getBroadcast(JNIEnv *env, int sock, const char *name, struct sockaddr *brdcast_store);
 131 static short   getSubnet(JNIEnv *env, int sock, const char *ifname);
 132 static int     getIndex(int sock, const char *ifname);
 133 
 134 static int     getFlags(int sock, const char *ifname);
 135 static int     getMacAddress(JNIEnv *env, int sock,  const char* ifname, const struct in_addr* addr, unsigned char *buf);
 136 static int     getMTU(JNIEnv *env, int sock, const char *ifname);
 137 
 138 
 139 
 140 #ifdef __solaris__
 141 static netif *enumIPvXInterfaces(JNIEnv *env, int sock, netif *ifs, int family);
 142 static int    getMacFromDevice(JNIEnv *env, const char* ifname, unsigned char* retbuf);
 143 #endif
 144 
 145 
 146 /******************* Java entry points *****************************/
 147 
 148 /*
 149  * Class:     java_net_NetworkInterface
 150  * Method:    init
 151  * Signature: ()V
 152  */
 153 JNIEXPORT void JNICALL
 154 Java_java_net_NetworkInterface_init(JNIEnv *env, jclass cls) {
 155     ni_class = (*env)->FindClass(env,"java/net/NetworkInterface");
 156     ni_class = (*env)->NewGlobalRef(env, ni_class);
 157     ni_nameID = (*env)->GetFieldID(env, ni_class,"name", "Ljava/lang/String;");
 158     ni_indexID = (*env)->GetFieldID(env, ni_class, "index", "I");
 159     ni_addrsID = (*env)->GetFieldID(env, ni_class, "addrs", "[Ljava/net/InetAddress;");
 160     ni_bindsID = (*env)->GetFieldID(env, ni_class, "bindings", "[Ljava/net/InterfaceAddress;");
 161     ni_descID = (*env)->GetFieldID(env, ni_class, "displayName", "Ljava/lang/String;");
 162     ni_virutalID = (*env)->GetFieldID(env, ni_class, "virtual", "Z");
 163     ni_childsID = (*env)->GetFieldID(env, ni_class, "childs", "[Ljava/net/NetworkInterface;");
 164     ni_parentID = (*env)->GetFieldID(env, ni_class, "parent", "Ljava/net/NetworkInterface;");
 165     ni_ctrID = (*env)->GetMethodID(env, ni_class, "<init>", "()V");
 166 
 167     ni_iacls = (*env)->FindClass(env, "java/net/InetAddress");
 168     ni_iacls = (*env)->NewGlobalRef(env, ni_iacls);
 169     ni_ia4cls = (*env)->FindClass(env, "java/net/Inet4Address");
 170     ni_ia4cls = (*env)->NewGlobalRef(env, ni_ia4cls);
 171     ni_ia6cls = (*env)->FindClass(env, "java/net/Inet6Address");
 172     ni_ia6cls = (*env)->NewGlobalRef(env, ni_ia6cls);
 173     ni_ibcls = (*env)->FindClass(env, "java/net/InterfaceAddress");
 174     ni_ibcls = (*env)->NewGlobalRef(env, ni_ibcls);
 175     ni_ia4ctrID = (*env)->GetMethodID(env, ni_ia4cls, "<init>", "()V");
 176     ni_ia6ctrID = (*env)->GetMethodID(env, ni_ia6cls, "<init>", "()V");
 177     ni_ibctrID = (*env)->GetMethodID(env, ni_ibcls, "<init>", "()V");
 178     ni_iaaddressID = (*env)->GetFieldID(env, ni_iacls, "address", "I");
 179     ni_iafamilyID = (*env)->GetFieldID(env, ni_iacls, "family", "I");
 180     ni_ia6ipaddressID = (*env)->GetFieldID(env, ni_ia6cls, "ipaddress", "[B");
 181     ni_ibaddressID = (*env)->GetFieldID(env, ni_ibcls, "address", "Ljava/net/InetAddress;");
 182     ni_ib4broadcastID = (*env)->GetFieldID(env, ni_ibcls, "broadcast", "Ljava/net/Inet4Address;");
 183     ni_ib4maskID = (*env)->GetFieldID(env, ni_ibcls, "maskLength", "S");
 184 }
 185 
 186 
 187 /*
 188  * Class:     java_net_NetworkInterface
 189  * Method:    getByName0
 190  * Signature: (Ljava/lang/String;)Ljava/net/NetworkInterface;
 191  */
 192 JNIEXPORT jobject JNICALL Java_java_net_NetworkInterface_getByName0
 193     (JNIEnv *env, jclass cls, jstring name) {
 194 
 195     netif *ifs, *curr;
 196     jboolean isCopy;
 197     const char* name_utf;
 198     jobject obj = NULL;
 199 
 200     ifs = enumInterfaces(env);
 201     if (ifs == NULL) {
 202         return NULL;
 203     }
 204 
 205     name_utf = (*env)->GetStringUTFChars(env, name, &isCopy);
 206 
 207     /*
 208      * Search the list of interface based on name
 209      */
 210     curr = ifs;
 211     while (curr != NULL) {
 212         if (strcmp(name_utf, curr->name) == 0) {
 213             break;
 214         }
 215         curr = curr->next;
 216     }
 217 
 218     /* if found create a NetworkInterface */
 219     if (curr != NULL) {;
 220         obj = createNetworkInterface(env, curr);
 221     }
 222 
 223     /* release the UTF string and interface list */
 224     (*env)->ReleaseStringUTFChars(env, name, name_utf);
 225     freeif(ifs);
 226 
 227     return obj;
 228 }
 229 
 230 
 231 /*
 232  * Class:     java_net_NetworkInterface
 233  * Method:    getByIndex0
 234  * Signature: (Ljava/lang/String;)Ljava/net/NetworkInterface;
 235  */
 236 JNIEXPORT jobject JNICALL Java_java_net_NetworkInterface_getByIndex0
 237     (JNIEnv *env, jclass cls, jint index) {
 238 
 239     netif *ifs, *curr;
 240     jobject obj = NULL;
 241 
 242     if (index <= 0) {
 243         return NULL;
 244     }
 245 
 246     ifs = enumInterfaces(env);
 247     if (ifs == NULL) {
 248         return NULL;
 249     }
 250 
 251     /*
 252      * Search the list of interface based on index
 253      */
 254     curr = ifs;
 255     while (curr != NULL) {
 256         if (index == curr->index) {
 257             break;
 258         }
 259         curr = curr->next;
 260     }
 261 
 262     /* if found create a NetworkInterface */
 263     if (curr != NULL) {;
 264         obj = createNetworkInterface(env, curr);
 265     }
 266 
 267     freeif(ifs);
 268     return obj;
 269 }
 270 
 271 /*
 272  * Class:     java_net_NetworkInterface
 273  * Method:    getByInetAddress0
 274  * Signature: (Ljava/net/InetAddress;)Ljava/net/NetworkInterface;
 275  */
 276 JNIEXPORT jobject JNICALL Java_java_net_NetworkInterface_getByInetAddress0
 277     (JNIEnv *env, jclass cls, jobject iaObj) {
 278 
 279     netif *ifs, *curr;
 280 
 281 #ifdef AF_INET6
 282     int family = (  (*env)->GetIntField(env, iaObj, ni_iafamilyID) == IPv4 ) ? AF_INET : AF_INET6;
 283 #else
 284     int family =  AF_INET;
 285 #endif
 286 
 287     jobject obj = NULL;
 288     jboolean match = JNI_FALSE;
 289 
 290     ifs = enumInterfaces(env);
 291     if (ifs == NULL) {
 292         return NULL;
 293     }
 294 
 295     curr = ifs;
 296     while (curr != NULL) {
 297         netaddr *addrP = curr->addr;
 298 
 299         /*
 300          * Iterate through each address on the interface
 301          */
 302         while (addrP != NULL) {
 303 
 304             if (family == addrP->family) {
 305                 if (family == AF_INET) {
 306                     int address1 = htonl(((struct sockaddr_in*)addrP->addr)->sin_addr.s_addr);
 307                     int address2 = (*env)->GetIntField(env, iaObj, ni_iaaddressID);
 308 
 309                     if (address1 == address2) {
 310                         match = JNI_TRUE;
 311                         break;
 312                     }
 313                 }
 314 
 315 #ifdef AF_INET6
 316                 if (family == AF_INET6) {
 317                     jbyte *bytes = (jbyte *)&(((struct sockaddr_in6*)addrP->addr)->sin6_addr);
 318                     jbyteArray ipaddress = (*env)->GetObjectField(env, iaObj, ni_ia6ipaddressID);
 319                     jbyte caddr[16];
 320                     int i;
 321 
 322                     (*env)->GetByteArrayRegion(env, ipaddress, 0, 16, caddr);
 323                     i = 0;
 324                     while (i < 16) {
 325                         if (caddr[i] != bytes[i]) {
 326                             break;
 327                         }
 328                         i++;
 329                     }
 330                     if (i >= 16) {
 331                         match = JNI_TRUE;
 332                         break;
 333                     }
 334                 }
 335 #endif
 336 
 337             }
 338 
 339             if (match) {
 340                 break;
 341             }
 342             addrP = addrP->next;
 343         }
 344 
 345         if (match) {
 346             break;
 347         }
 348         curr = curr->next;
 349     }
 350 
 351     /* if found create a NetworkInterface */
 352     if (match) {;
 353         obj = createNetworkInterface(env, curr);
 354     }
 355 
 356     freeif(ifs);
 357     return obj;
 358 }
 359 
 360 
 361 /*
 362  * Class:     java_net_NetworkInterface
 363  * Method:    getAll
 364  * Signature: ()[Ljava/net/NetworkInterface;
 365  */
 366 JNIEXPORT jobjectArray JNICALL Java_java_net_NetworkInterface_getAll
 367     (JNIEnv *env, jclass cls) {
 368 
 369     netif *ifs, *curr;
 370     jobjectArray netIFArr;
 371     jint arr_index, ifCount;
 372 
 373     ifs = enumInterfaces(env);
 374     if (ifs == NULL) {
 375         return NULL;
 376     }
 377 
 378     /* count the interface */
 379     ifCount = 0;
 380     curr = ifs;
 381     while (curr != NULL) {
 382         ifCount++;
 383         curr = curr->next;
 384     }
 385 
 386     /* allocate a NetworkInterface array */
 387     netIFArr = (*env)->NewObjectArray(env, ifCount, cls, NULL);
 388     if (netIFArr == NULL) {
 389         freeif(ifs);
 390         return NULL;
 391     }
 392 
 393     /*
 394      * Iterate through the interfaces, create a NetworkInterface instance
 395      * for each array element and populate the object.
 396      */
 397     curr = ifs;
 398     arr_index = 0;
 399     while (curr != NULL) {
 400         jobject netifObj;
 401 
 402         netifObj = createNetworkInterface(env, curr);
 403         if (netifObj == NULL) {
 404             freeif(ifs);
 405             return NULL;
 406         }
 407 
 408         /* put the NetworkInterface into the array */
 409         (*env)->SetObjectArrayElement(env, netIFArr, arr_index++, netifObj);
 410 
 411         curr = curr->next;
 412     }
 413 
 414     freeif(ifs);
 415     return netIFArr;
 416 }
 417 
 418 
 419 /*
 420  * Class:     java_net_NetworkInterface
 421  * Method:    isUp0
 422  * Signature: (Ljava/lang/String;I)Z
 423  */
 424 JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isUp0(JNIEnv *env, jclass cls, jstring name, jint index) {
 425     int ret = getFlags0(env, name);
 426     return ((ret & IFF_UP) && (ret & IFF_RUNNING)) ? JNI_TRUE :  JNI_FALSE;
 427 }
 428 
 429 /*
 430  * Class:     java_net_NetworkInterface
 431  * Method:    isP2P0
 432  * Signature: (Ljava/lang/String;I)Z
 433  */
 434 JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isP2P0(JNIEnv *env, jclass cls, jstring name, jint index) {
 435     int ret = getFlags0(env, name);
 436     return (ret & IFF_POINTOPOINT) ? JNI_TRUE :  JNI_FALSE;
 437 }
 438 
 439 /*
 440  * Class:     java_net_NetworkInterface
 441  * Method:    isLoopback0
 442  * Signature: (Ljava/lang/String;I)Z
 443  */
 444 JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isLoopback0(JNIEnv *env, jclass cls, jstring name, jint index) {
 445     int ret = getFlags0(env, name);
 446     return (ret & IFF_LOOPBACK) ? JNI_TRUE :  JNI_FALSE;
 447 }
 448 
 449 /*
 450  * Class:     java_net_NetworkInterface
 451  * Method:    supportsMulticast0
 452  * Signature: (Ljava/lang/String;I)Z
 453  */
 454 JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_supportsMulticast0(JNIEnv *env, jclass cls, jstring name, jint index) {
 455     int ret = getFlags0(env, name);
 456     return (ret & IFF_MULTICAST) ? JNI_TRUE :  JNI_FALSE;
 457 }
 458 
 459 /*
 460  * Class:     java_net_NetworkInterface
 461  * Method:    getMacAddr0
 462  * Signature: ([bLjava/lang/String;I)[b
 463  */
 464 JNIEXPORT jbyteArray JNICALL Java_java_net_NetworkInterface_getMacAddr0(JNIEnv *env, jclass class, jbyteArray addrArray, jstring name, jint index) {
 465     jint addr;
 466     jbyte caddr[4];
 467     struct in_addr iaddr;
 468     jbyteArray ret = NULL;
 469     unsigned char mac[16];
 470     int len;
 471     int sock;
 472     jboolean isCopy;
 473     const char* name_utf;
 474 
 475     name_utf = (*env)->GetStringUTFChars(env, name, &isCopy);
 476 
 477     if ((sock =openSocketWithFallback(env, name_utf)) < 0) {
 478        (*env)->ReleaseStringUTFChars(env, name, name_utf);
 479        return JNI_FALSE;
 480     }
 481 
 482 
 483     if (!IS_NULL(addrArray)) {
 484        (*env)->GetByteArrayRegion(env, addrArray, 0, 4, caddr);
 485        addr = ((caddr[0]<<24) & 0xff000000);
 486        addr |= ((caddr[1] <<16) & 0xff0000);
 487        addr |= ((caddr[2] <<8) & 0xff00);
 488        addr |= (caddr[3] & 0xff);
 489        iaddr.s_addr = htonl(addr);
 490        len = getMacAddress(env, sock, name_utf, &iaddr, mac);
 491     } else {
 492        len = getMacAddress(env, sock, name_utf,NULL, mac);
 493     }
 494     if (len > 0) {
 495        ret = (*env)->NewByteArray(env, len);
 496        if (IS_NULL(ret)) {
 497           /* we may have memory to free at the end of this */
 498           goto fexit;
 499        }
 500        (*env)->SetByteArrayRegion(env, ret, 0, len, (jbyte *) (mac));
 501     }
 502  fexit:
 503    /* release the UTF string and interface list */
 504    (*env)->ReleaseStringUTFChars(env, name, name_utf);
 505 
 506    close(sock);
 507    return ret;
 508 }
 509 
 510 /*
 511  * Class:       java_net_NetworkInterface
 512  * Method:      getMTU0
 513  * Signature:   ([bLjava/lang/String;I)I
 514  */
 515 
 516 JNIEXPORT jint JNICALL Java_java_net_NetworkInterface_getMTU0(JNIEnv *env, jclass class, jstring name, jint index) {
 517     jboolean isCopy;
 518     int ret = -1;
 519     int sock;
 520     const char* name_utf;
 521 
 522     name_utf = (*env)->GetStringUTFChars(env, name, &isCopy);
 523 
 524     if ((sock =openSocketWithFallback(env, name_utf)) < 0) {
 525        (*env)->ReleaseStringUTFChars(env, name, name_utf);
 526        return JNI_FALSE;
 527     }
 528 
 529     ret = getMTU(env, sock, name_utf);
 530 
 531     (*env)->ReleaseStringUTFChars(env, name, name_utf);
 532 
 533     close(sock);
 534     return ret;
 535 }
 536 
 537 /*** Private methods definitions ****/
 538 
 539 static int getFlags0(JNIEnv *env, jstring name) {
 540     jboolean isCopy;
 541     int ret, sock;
 542     const char* name_utf;
 543 
 544     name_utf = (*env)->GetStringUTFChars(env, name, &isCopy);
 545 
 546     if ((sock = openSocketWithFallback(env, name_utf)) < 0) {
 547         (*env)->ReleaseStringUTFChars(env, name, name_utf);
 548          return -1;
 549     }
 550 
 551     name_utf = (*env)->GetStringUTFChars(env, name, &isCopy);
 552 
 553     ret = getFlags(sock, name_utf);
 554 
 555     close(sock);
 556     (*env)->ReleaseStringUTFChars(env, name, name_utf);
 557 
 558     if (ret < 0) {
 559         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL  SIOCGLIFFLAGS failed");
 560         return -1;
 561     }
 562 
 563     return ret;
 564 }
 565 
 566 
 567 
 568 
 569 /*
 570  * Create a NetworkInterface object, populate the name and index, and
 571  * populate the InetAddress array based on the IP addresses for this
 572  * interface.
 573  */
 574 jobject createNetworkInterface(JNIEnv *env, netif *ifs) {
 575     jobject netifObj;
 576     jobject name;
 577     jobjectArray addrArr;
 578     jobjectArray bindArr;
 579     jobjectArray childArr;
 580     netaddr *addrs;
 581     jint addr_index, addr_count, bind_index;
 582     jint child_count, child_index;
 583     netaddr *addrP;
 584     netif *childP;
 585     jobject tmp;
 586 
 587     /*
 588      * Create a NetworkInterface object and populate it
 589      */
 590     netifObj = (*env)->NewObject(env, ni_class, ni_ctrID);
 591     name = (*env)->NewStringUTF(env, ifs->name);
 592     if (netifObj == NULL || name == NULL) {
 593         return NULL;
 594     }
 595     (*env)->SetObjectField(env, netifObj, ni_nameID, name);
 596     (*env)->SetObjectField(env, netifObj, ni_descID, name);
 597     (*env)->SetIntField(env, netifObj, ni_indexID, ifs->index);
 598     (*env)->SetBooleanField(env, netifObj, ni_virutalID, ifs->virtual ? JNI_TRUE : JNI_FALSE);
 599 
 600     /*
 601      * Count the number of address on this interface
 602      */
 603     addr_count = 0;
 604     addrP = ifs->addr;
 605     while (addrP != NULL) {
 606         addr_count++;
 607         addrP = addrP->next;
 608     }
 609 
 610     /*
 611      * Create the array of InetAddresses
 612      */
 613     addrArr = (*env)->NewObjectArray(env, addr_count,  ni_iacls, NULL);
 614     if (addrArr == NULL) {
 615         return NULL;
 616     }
 617 
 618     bindArr = (*env)->NewObjectArray(env, addr_count, ni_ibcls, NULL);
 619     if (bindArr == NULL) {
 620        return NULL;
 621     }
 622     addrP = ifs->addr;
 623     addr_index = 0;
 624     bind_index = 0;
 625     while (addrP != NULL) {
 626         jobject iaObj = NULL;
 627         jobject ibObj = NULL;
 628 
 629         if (addrP->family == AF_INET) {
 630             iaObj = (*env)->NewObject(env, ni_ia4cls, ni_ia4ctrID);
 631             if (iaObj) {
 632                  (*env)->SetIntField(env, iaObj, ni_iaaddressID, htonl(((struct sockaddr_in*)addrP->addr)->sin_addr.s_addr));
 633             }
 634             ibObj = (*env)->NewObject(env, ni_ibcls, ni_ibctrID);
 635             if (ibObj) {
 636                  (*env)->SetObjectField(env, ibObj, ni_ibaddressID, iaObj);
 637                  if (addrP->brdcast) {
 638                     jobject ia2Obj = NULL;
 639                     ia2Obj = (*env)->NewObject(env, ni_ia4cls, ni_ia4ctrID);
 640                     if (ia2Obj) {
 641                        (*env)->SetIntField(env, ia2Obj, ni_iaaddressID,
 642                                                                htonl(((struct sockaddr_in*)addrP->brdcast)->sin_addr.s_addr));
 643                        (*env)->SetObjectField(env, ibObj, ni_ib4broadcastID, ia2Obj);
 644                        (*env)->SetShortField(env, ibObj, ni_ib4maskID, addrP->mask);
 645                     }
 646                  }
 647                  (*env)->SetObjectArrayElement(env, bindArr, bind_index++, ibObj);
 648             }
 649         }
 650 
 651 #ifdef AF_INET6
 652         if (addrP->family == AF_INET6) {
 653             int scope=0;
 654             iaObj = (*env)->NewObject(env, ni_ia6cls, ni_ia6ctrID);
 655             if (iaObj) {
 656                 jbyteArray ipaddress = (*env)->NewByteArray(env, 16);
 657                 if (ipaddress == NULL) {
 658                     return NULL;
 659                 }
 660                 (*env)->SetByteArrayRegion(env, ipaddress, 0, 16,
 661                                                                         (jbyte *)&(((struct sockaddr_in6*)addrP->addr)->sin6_addr));
 662 
 663                 scope = ((struct sockaddr_in6*)addrP->addr)->sin6_scope_id;
 664 
 665                 if (scope != 0) { /* zero is default value, no need to set */
 666                     (*env)->SetIntField(env, iaObj, ia6_scopeidID, scope);
 667                     (*env)->SetBooleanField(env, iaObj, ia6_scopeidsetID, JNI_TRUE);
 668                     (*env)->SetObjectField(env, iaObj, ia6_scopeifnameID, netifObj);
 669                 }
 670                 (*env)->SetObjectField(env, iaObj, ni_ia6ipaddressID, ipaddress);
 671             }
 672             ibObj = (*env)->NewObject(env, ni_ibcls, ni_ibctrID);
 673             if (ibObj) {
 674                 (*env)->SetObjectField(env, ibObj, ni_ibaddressID, iaObj);
 675                 (*env)->SetShortField(env, ibObj, ni_ib4maskID, addrP->mask);
 676                 (*env)->SetObjectArrayElement(env, bindArr, bind_index++, ibObj);
 677             }
 678         }
 679 #endif
 680 
 681         if (iaObj == NULL) {
 682             return NULL;
 683         }
 684 
 685         (*env)->SetObjectArrayElement(env, addrArr, addr_index++, iaObj);
 686         addrP = addrP->next;
 687     }
 688 
 689     /*
 690      * See if there is any virtual interface attached to this one.
 691      */
 692     child_count = 0;
 693     childP = ifs->childs;
 694     while (childP) {
 695         child_count++;
 696         childP = childP->next;
 697     }
 698 
 699     childArr = (*env)->NewObjectArray(env, child_count, ni_class, NULL);
 700     if (childArr == NULL) {
 701         return NULL;
 702     }
 703 
 704     /*
 705      * Create the NetworkInterface instances for the sub-interfaces as
 706      * well.
 707      */
 708     child_index = 0;
 709     childP = ifs->childs;
 710     while(childP) {
 711       tmp = createNetworkInterface(env, childP);
 712       if (tmp == NULL) {
 713          return NULL;
 714       }
 715       (*env)->SetObjectField(env, tmp, ni_parentID, netifObj);
 716       (*env)->SetObjectArrayElement(env, childArr, child_index++, tmp);
 717       childP = childP->next;
 718     }
 719     (*env)->SetObjectField(env, netifObj, ni_addrsID, addrArr);
 720     (*env)->SetObjectField(env, netifObj, ni_bindsID, bindArr);
 721     (*env)->SetObjectField(env, netifObj, ni_childsID, childArr);
 722 
 723     /* return the NetworkInterface */
 724     return netifObj;
 725 }
 726 
 727 /*
 728  * Enumerates all interfaces
 729  */
 730 static netif *enumInterfaces(JNIEnv *env) {
 731     netif *ifs;
 732     int sock;
 733 
 734     /*
 735      * Enumerate IPv4 addresses
 736      */
 737 
 738     sock = openSocket(env, AF_INET);
 739     if (sock < 0 && (*env)->ExceptionOccurred(env)) {
 740         return NULL;
 741     }
 742 
 743     ifs = enumIPv4Interfaces(env, sock, NULL);
 744     close(sock);
 745 
 746     if (ifs == NULL && (*env)->ExceptionOccurred(env)) {
 747         return NULL;
 748     }
 749 
 750     /* return partial list if exception occure in the middle of process ???*/
 751 
 752     /*
 753      * If IPv6 is available then enumerate IPv6 addresses.
 754      */
 755 #ifdef AF_INET6
 756 
 757         /* User can disable ipv6 expicitly by -Djava.net.preferIPv4Stack=true,
 758          * so we have to call ipv6_available()
 759          */
 760         if (ipv6_available()) {
 761 
 762            sock =  openSocket(env, AF_INET6);
 763            if (sock < 0 && (*env)->ExceptionOccurred(env)) {
 764                freeif(ifs);
 765                return NULL;
 766            }
 767 
 768            ifs = enumIPv6Interfaces(env, sock, ifs);
 769            close(sock);
 770 
 771            if ((*env)->ExceptionOccurred(env)) {
 772               freeif(ifs);
 773               return NULL;
 774            }
 775 
 776        }
 777 #endif
 778 
 779     return ifs;
 780 }
 781 
 782 #define CHECKED_MALLOC3(_pointer,_type,_size) \
 783        do{ \
 784         _pointer = (_type)malloc( _size ); \
 785         if (_pointer == NULL) { \
 786             JNU_ThrowOutOfMemoryError(env, "heap allocation failed"); \
 787             return ifs; /* return untouched list */ \
 788         } \
 789        } while(0)
 790 
 791 
 792 /*
 793  * Free an interface list (including any attached addresses)
 794  */
 795 void freeif(netif *ifs) {
 796     netif *currif = ifs;
 797     netif *child = NULL;
 798 
 799     while (currif != NULL) {
 800         netaddr *addrP = currif->addr;
 801         while (addrP != NULL) {
 802             netaddr *next = addrP->next;
 803             free(addrP);
 804             addrP = next;
 805          }
 806 
 807             /*
 808             * Don't forget to free the sub-interfaces.
 809             */
 810           if (currif->childs != NULL) {
 811                 freeif(currif->childs);
 812           }
 813 
 814           ifs = currif->next;
 815           free(currif);
 816           currif = ifs;
 817     }
 818 }
 819 
 820 netif *addif(JNIEnv *env, int sock, const char * if_name, netif *ifs, struct sockaddr* ifr_addrP, int family, short prefix) {
 821     netif *currif = ifs, *parent;
 822     netaddr *addrP;
 823 
 824     #ifdef __solaris__
 825     char name[LIFNAMSIZ],  vname[LIFNAMSIZ];
 826     #else
 827     char name[IFNAMSIZ],  vname[IFNAMSIZ];
 828     #endif
 829 
 830     char  *name_colonP;
 831     int mask;
 832     int isVirtual = 0;
 833     int addr_size;
 834 
 835     /*
 836      * If the interface name is a logical interface then we
 837      * remove the unit number so that we have the physical
 838      * interface (eg: hme0:1 -> hme0). NetworkInterface
 839      * currently doesn't have any concept of physical vs.
 840      * logical interfaces.
 841      */
 842     strcpy(name, if_name);
 843     *vname = 0;
 844 
 845     /*
 846      * Create and populate the netaddr node. If allocation fails
 847      * return an un-updated list.
 848      */
 849     /*Allocate for addr and brdcast at once*/
 850 
 851 #ifdef AF_INET6
 852     addr_size = (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
 853 #else
 854     addr_size = sizeof(struct sockaddr_in);
 855 #endif
 856 
 857     CHECKED_MALLOC3(addrP, netaddr *, sizeof(netaddr)+2*addr_size);
 858     addrP->addr = (struct sockaddr *)( (char *) addrP+sizeof(netaddr) );
 859     memcpy(addrP->addr, ifr_addrP, addr_size);
 860 
 861     addrP->family = family;
 862     addrP->brdcast = NULL;
 863     addrP->mask = prefix;
 864     addrP->next = 0;
 865     if (family == AF_INET) {
 866       /*
 867        * Deal with brodcast addr & subnet mask
 868        */
 869        struct sockaddr * brdcast_to = (struct sockaddr *) ((char *) addrP + sizeof(netaddr) + addr_size);
 870        addrP->brdcast = getBroadcast(env, sock, name,  brdcast_to );
 871 
 872        if (addrP->brdcast && (mask = getSubnet(env, sock, name)) != -1) {
 873            addrP->mask = mask;
 874        }
 875      }
 876 
 877     /**
 878      * Deal with virtual interface with colon notaion e.g. eth0:1
 879      */
 880     name_colonP = strchr(name, ':');
 881     if (name_colonP != NULL) {
 882       /**
 883        * This is a virtual interface. If we are able to access the parent
 884        * we need to create a new entry if it doesn't exist yet *and* update
 885        * the 'parent' interface with the new records.
 886        */
 887         *name_colonP = 0;
 888         if (getFlags(sock, name) < 0) {
 889             // failed to access parent interface do not create parent.
 890             // We are a virtual interface with no parent.
 891             isVirtual = 1;
 892             *name_colonP = ':';
 893         }
 894         else{
 895            // Got access to parent, so create it if necessary.
 896            // Save original name to vname and truncate name by ':'
 897             memcpy(vname, name, sizeof(vname) );
 898             vname[name_colonP - name] = ':';
 899         }
 900     }
 901 
 902     /*
 903      * Check if this is a "new" interface. Use the interface
 904      * name for matching because index isn't supported on
 905      * Solaris 2.6 & 7.
 906      */
 907     while (currif != NULL) {
 908         if (strcmp(name, currif->name) == 0) {
 909             break;
 910         }
 911         currif = currif->next;
 912     }
 913 
 914     /*
 915      * If "new" then create an netif structure and
 916      * insert it onto the list.
 917      */
 918     if (currif == NULL) {
 919          CHECKED_MALLOC3(currif, netif *, sizeof(netif)+IFNAMSIZ );
 920          currif->name = (char *) currif+sizeof(netif);
 921          strcpy(currif->name, name);
 922          currif->index = getIndex(sock, name);
 923          currif->addr = NULL;
 924          currif->childs = NULL;
 925          currif->virtual = isVirtual;
 926          currif->next = ifs;
 927          ifs = currif;
 928     }
 929 
 930     /*
 931      * Finally insert the address on the interface
 932      */
 933     addrP->next = currif->addr;
 934     currif->addr = addrP;
 935 
 936     parent = currif;
 937 
 938     /**
 939      * Let's deal with the virtual interface now.
 940      */
 941     if (vname[0]) {
 942         netaddr *tmpaddr;
 943 
 944         currif = parent->childs;
 945 
 946         while (currif != NULL) {
 947             if (strcmp(vname, currif->name) == 0) {
 948                 break;
 949             }
 950             currif = currif->next;
 951         }
 952 
 953         if (currif == NULL) {
 954             CHECKED_MALLOC3(currif, netif *, sizeof(netif)+ IFNAMSIZ );
 955             currif->name = (char *) currif + sizeof(netif);
 956             strcpy(currif->name, vname);
 957             currif->index = getIndex(sock, vname);
 958             currif->addr = NULL;
 959            /* Need to duplicate the addr entry? */
 960             currif->virtual = 1;
 961             currif->childs = NULL;
 962             currif->next = parent->childs;
 963             parent->childs = currif;
 964         }
 965 
 966         CHECKED_MALLOC3(tmpaddr, netaddr *, sizeof(netaddr)+2*addr_size);
 967         memcpy(tmpaddr, addrP, sizeof(netaddr));
 968         if (addrP->addr != NULL) {
 969             tmpaddr->addr = (struct sockaddr *) ( (char*)tmpaddr + sizeof(netaddr) ) ;
 970             memcpy(tmpaddr->addr, addrP->addr, addr_size);
 971         }
 972 
 973         if (addrP->brdcast != NULL) {
 974             tmpaddr->brdcast = (struct sockaddr *) ((char *) tmpaddr + sizeof(netaddr)+addr_size);
 975             memcpy(tmpaddr->brdcast, addrP->brdcast, addr_size);
 976         }
 977 
 978         tmpaddr->next = currif->addr;
 979         currif->addr = tmpaddr;
 980     }
 981 
 982     return ifs;
 983 }
 984 
 985 /* Open socket for further ioct calls
 986  * proto is AF_INET/AF_INET6
 987  */
 988 static int  openSocket(JNIEnv *env, int proto){
 989     int sock;
 990 
 991     if ((sock = JVM_Socket(proto, SOCK_DGRAM, 0)) < 0) {
 992         /*
 993          * If EPROTONOSUPPORT is returned it means we don't have
 994          * support  for this proto so don't throw an exception.
 995          */
 996         if (errno != EPROTONOSUPPORT) {
 997             NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "Socket creation failed");
 998         }
 999         return -1;
1000     }
1001 
1002     return sock;
1003 }
1004 
1005 
1006 /** Linux **/
1007 #ifdef __linux__
1008 /* Open socket for further ioct calls, try v4 socket first and
1009  * if it falls return v6 socket
1010  */
1011 
1012 #ifdef AF_INET6
1013 static int openSocketWithFallback(JNIEnv *env, const char *ifname){
1014     int sock;
1015     struct ifreq if2;
1016 
1017      if ((sock = JVM_Socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
1018          if (errno == EPROTONOSUPPORT){
1019               if ( (sock = JVM_Socket(AF_INET6, SOCK_DGRAM, 0)) < 0 ){
1020                  NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "IPV6 Socket creation failed");
1021                  return -1;
1022               }
1023          }
1024          else{ // errno is not NOSUPPORT
1025              NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "IPV4 Socket creation failed");
1026              return -1;
1027          }
1028    }
1029 
1030      /* Linux starting from 2.6.? kernel allows ioctl call with either IPv4 or IPv6 socket regardless of type
1031         of address of an interface */
1032 
1033        return sock;
1034 }
1035 
1036 #else
1037 static int openSocketWithFallback(JNIEnv *env, const char *ifname){
1038     return openSocket(env,AF_INET);
1039 }
1040 #endif
1041 
1042 static netif *enumIPv4Interfaces(JNIEnv *env, int sock, netif *ifs) {
1043     struct ifconf ifc;
1044     struct ifreq *ifreqP;
1045     char *buf;
1046     int numifs;
1047     unsigned i;
1048 
1049 
1050     /* need to do a dummy SIOCGIFCONF to determine the buffer size.
1051      * SIOCGIFCOUNT doesn't work
1052      */
1053     ifc.ifc_buf = NULL;
1054     if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0) {
1055         NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "ioctl SIOCGIFCONF failed");
1056         return ifs;
1057     }
1058 
1059     CHECKED_MALLOC3(buf,char *, ifc.ifc_len);
1060 
1061     ifc.ifc_buf = buf;
1062     if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0) {
1063         NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "ioctl SIOCGIFCONF failed");
1064         (void) free(buf);
1065         return ifs;
1066     }
1067 
1068     /*
1069      * Iterate through each interface
1070      */
1071     ifreqP = ifc.ifc_req;
1072     for (i=0; i<ifc.ifc_len/sizeof (struct ifreq); i++, ifreqP++) {
1073         /*
1074          * Add to the list
1075          */
1076         ifs = addif(env, sock, ifreqP->ifr_name, ifs, (struct sockaddr *) & (ifreqP->ifr_addr), AF_INET, 0);
1077 
1078         /*
1079          * If an exception occurred then free the list
1080          */
1081         if ((*env)->ExceptionOccurred(env)) {
1082             free(buf);
1083             freeif(ifs);
1084             return NULL;
1085         }
1086     }
1087 
1088     /*
1089      * Free socket and buffer
1090      */
1091     free(buf);
1092     return ifs;
1093 }
1094 
1095 
1096 /*
1097  * Enumerates and returns all IPv6 interfaces on Linux
1098  */
1099 
1100 #ifdef AF_INET6
1101 static netif *enumIPv6Interfaces(JNIEnv *env, int sock, netif *ifs) {
1102     FILE *f;
1103     char addr6[40], devname[20];
1104     char addr6p[8][5];
1105     int plen, scope, dad_status, if_idx;
1106     uint8_t ipv6addr[16];
1107 
1108     if ((f = fopen(_PATH_PROCNET_IFINET6, "r")) != NULL) {
1109         while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
1110                          addr6p[0], addr6p[1], addr6p[2], addr6p[3], addr6p[4], addr6p[5], addr6p[6], addr6p[7],
1111                          &if_idx, &plen, &scope, &dad_status, devname) != EOF) {
1112 
1113             struct netif *ifs_ptr = NULL;
1114             struct netif *last_ptr = NULL;
1115             struct sockaddr_in6 addr;
1116 
1117             sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
1118                            addr6p[0], addr6p[1], addr6p[2], addr6p[3], addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
1119             inet_pton(AF_INET6, addr6, ipv6addr);
1120 
1121             memset(&addr, 0, sizeof(struct sockaddr_in6));
1122             memcpy((void*)addr.sin6_addr.s6_addr, (const void*)ipv6addr, 16);
1123 
1124             addr.sin6_scope_id = if_idx;
1125 
1126             ifs = addif(env, sock, devname, ifs, (struct sockaddr *)&addr, AF_INET6, plen);
1127 
1128 
1129             /*
1130              * If an exception occurred then return the list as is.
1131              */
1132             if ((*env)->ExceptionOccurred(env)) {
1133                 fclose(f);
1134                 return ifs;
1135             }
1136        }
1137        fclose(f);
1138     }
1139     return ifs;
1140 }
1141 #endif
1142 
1143 
1144 static int getIndex(int sock, const char *name){
1145      /*
1146       * Try to get the interface index
1147       * (Not supported on Solaris 2.6 or 7)
1148       */
1149     struct ifreq if2;
1150     strcpy(if2.ifr_name, name);
1151 
1152     if (ioctl(sock, SIOCGIFINDEX, (char *)&if2) < 0) {
1153         return -1;
1154     }
1155 
1156     return if2.ifr_ifindex;
1157 }
1158 
1159 /**
1160  * Returns the IPv4 broadcast address of a named interface, if it exists.
1161  * Returns 0 if it doesn't have one.
1162  */
1163 static struct sockaddr *getBroadcast(JNIEnv *env, int sock, const char *ifname, struct sockaddr *brdcast_store) {
1164   struct sockaddr *ret = NULL;
1165   struct ifreq if2;
1166 
1167   memset((char *) &if2, 0, sizeof(if2));
1168   strcpy(if2.ifr_name, ifname);
1169 
1170   /* Let's make sure the interface does have a broadcast address */
1171   if (ioctl(sock, SIOCGIFFLAGS, (char *)&if2)  < 0) {
1172       NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL  SIOCGIFFLAGS failed");
1173       return ret;
1174   }
1175 
1176   if (if2.ifr_flags & IFF_BROADCAST) {
1177       /* It does, let's retrieve it*/
1178       if (ioctl(sock, SIOCGIFBRDADDR, (char *)&if2) < 0) {
1179           NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL SIOCGIFBRDADDR failed");
1180           return ret;
1181       }
1182 
1183       ret = brdcast_store;
1184       memcpy(ret, &if2.ifr_broadaddr, sizeof(struct sockaddr));
1185   }
1186 
1187   return ret;
1188 }
1189 
1190 /**
1191  * Returns the IPv4 subnet prefix length (aka subnet mask) for the named
1192  * interface, if it has one, otherwise return -1.
1193  */
1194 static short getSubnet(JNIEnv *env, int sock, const char *ifname) {
1195     unsigned int mask;
1196     short ret;
1197     struct ifreq if2;
1198 
1199     memset((char *) &if2, 0, sizeof(if2));
1200     strcpy(if2.ifr_name, ifname);
1201 
1202     if (ioctl(sock, SIOCGIFNETMASK, (char *)&if2) < 0) {
1203         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL SIOCGIFNETMASK failed");
1204         return -1;
1205     }
1206 
1207     mask = ntohl(((struct sockaddr_in*)&(if2.ifr_addr))->sin_addr.s_addr);
1208     ret = 0;
1209     while (mask) {
1210        mask <<= 1;
1211        ret++;
1212     }
1213 
1214     return ret;
1215 }
1216 
1217 /**
1218  * Get the Hardware address (usually MAC address) for the named interface.
1219  * return puts the data in buf, and returns the length, in byte, of the
1220  * MAC address. Returns -1 if there is no hardware address on that interface.
1221  */
1222 static int getMacAddress(JNIEnv *env, int sock, const char* ifname, const struct in_addr* addr, unsigned char *buf) {
1223     static struct ifreq ifr;
1224     int i;
1225 
1226     strcpy(ifr.ifr_name, ifname);
1227     if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0) {
1228         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL SIOCGIFHWADDR failed");
1229         return -1;
1230     }
1231 
1232     memcpy(buf, &ifr.ifr_hwaddr.sa_data, IFHWADDRLEN);
1233 
1234    /*
1235     * All bytes to 0 means no hardware address.
1236     */
1237 
1238     for (i = 0; i < IFHWADDRLEN; i++) {
1239         if (buf[i] != 0)
1240             return IFHWADDRLEN;
1241     }
1242 
1243     return -1;
1244 }
1245 
1246 static int getMTU(JNIEnv *env, int sock,  const char *ifname) {
1247     struct ifreq if2;
1248 
1249     memset((char *) &if2, 0, sizeof(if2));
1250     strcpy(if2.ifr_name, ifname);
1251 
1252     if (ioctl(sock, SIOCGIFMTU, (char *)&if2) < 0) {
1253         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL SIOCGIFMTU failed");
1254         return -1;
1255     }
1256 
1257     return  if2.ifr_mtu;
1258 }
1259 
1260 static int getFlags(int sock, const char *ifname) {
1261   struct ifreq if2;
1262   int ret = -1;
1263 
1264   memset((char *) &if2, 0, sizeof(if2));
1265   strcpy(if2.ifr_name, ifname);
1266 
1267   if (ioctl(sock, SIOCGIFFLAGS, (char *)&if2) < 0){
1268       return -1;
1269   }
1270 
1271   return if2.ifr_flags;
1272 }
1273 
1274 #endif
1275 
1276 /** Solaris **/
1277 #ifdef __solaris__
1278 /* Open socket for further ioct calls, try v4 socket first and
1279  * if it falls return v6 socket
1280  */
1281 
1282 #ifdef AF_INET6
1283 static int openSocketWithFallback(JNIEnv *env, const char *ifname){
1284     int sock, alreadyV6 = 0;
1285     struct lifreq if2;
1286 
1287      if ((sock = JVM_Socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
1288          if (errno == EPROTONOSUPPORT){
1289               if ( (sock = JVM_Socket(AF_INET6, SOCK_DGRAM, 0)) < 0 ){
1290                  NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "IPV6 Socket creation failed");
1291                  return -1;
1292               }
1293 
1294               alreadyV6=1;
1295          }
1296          else{ // errno is not NOSUPPORT
1297              NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "IPV4 Socket creation failed");
1298              return -1;
1299          }
1300    }
1301 
1302      /**
1303       * Solaris requires that we have IPv6 socket to query an
1304       * interface without IPv4 address - check it here
1305       * POSIX 1 require the kernell to return ENOTTY if the call is
1306       * unappropriate for device e.g. NETMASK for device having IPv6
1307       * only address but not all devices follows the standart so
1308       * fallback on any error.  It's not an ecology friendly but more
1309       * reliable.
1310       */
1311 
1312     if (! alreadyV6 ){
1313         memset((char *) &if2, 0, sizeof(if2));
1314         strcpy(if2.lifr_name, ifname);
1315         if (ioctl(sock, SIOCGLIFNETMASK, (char *)&if2) < 0) {
1316                 close(sock);
1317                 if ( (sock = JVM_Socket(AF_INET6, SOCK_DGRAM, 0)) < 0 ){
1318                       NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "IPV6 Socket creation failed");
1319                       return -1;
1320                 }
1321         }
1322     }
1323 
1324     return sock;
1325 }
1326 
1327 #else
1328 static int openSocketWithFallback(JNIEnv *env, const char *ifname){
1329     return openSocket(env,AF_INET);
1330 }
1331 #endif
1332 
1333 /*
1334  * Enumerates and returns all IPv4 interfaces
1335  * (linux verison)
1336  */
1337 
1338 static netif *enumIPv4Interfaces(JNIEnv *env, int sock, netif *ifs) {
1339      return enumIPvXInterfaces(env,sock, ifs, AF_INET);
1340 }
1341 
1342 #ifdef AF_INET6
1343 static netif *enumIPv6Interfaces(JNIEnv *env, int sock, netif *ifs) {
1344     return enumIPvXInterfaces(env,sock, ifs, AF_INET6);
1345 }
1346 #endif
1347 
1348 /*
1349    Enumerates and returns all interfaces on Solaris
1350    use the same code for IPv4 and IPv6
1351  */
1352 static netif *enumIPvXInterfaces(JNIEnv *env, int sock, netif *ifs, int family) {
1353     struct lifconf ifc;
1354     struct lifreq *ifr;
1355     int n;
1356     char *buf;
1357     struct lifnum numifs;
1358     unsigned bufsize;
1359 
1360     /*
1361      * Get the interface count
1362      */
1363     numifs.lifn_family = family;
1364     numifs.lifn_flags = 0;
1365     if (ioctl(sock, SIOCGLIFNUM, (char *)&numifs) < 0) {
1366         NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "ioctl SIOCGLIFNUM failed");
1367         return ifs;
1368     }
1369 
1370     /*
1371      *  Enumerate the interface configurations
1372      */
1373     bufsize = numifs.lifn_count * sizeof (struct lifreq);
1374     CHECKED_MALLOC3(buf, char *, bufsize);
1375 
1376     ifc.lifc_family = family;
1377     ifc.lifc_flags = 0;
1378     ifc.lifc_len = bufsize;
1379     ifc.lifc_buf = buf;
1380     if (ioctl(sock, SIOCGLIFCONF, (char *)&ifc) < 0) {
1381         NET_ThrowByNameWithLastError(env , JNU_JAVANETPKG "SocketException", "ioctl SIOCGLIFCONF failed");
1382         free(buf);
1383         return ifs;
1384     }
1385 
1386     /*
1387      * Iterate through each interface
1388      */
1389     ifr = ifc.lifc_req;
1390     for (n=0; n<numifs.lifn_count; n++, ifr++) {
1391         int index = -1;
1392         struct lifreq if2;
1393 
1394         /*
1395         * Ignore either IPv4 or IPv6 addresses
1396         */
1397         if (ifr->lifr_addr.ss_family != family) {
1398             continue;
1399         }
1400 
1401 #ifdef AF_INET6
1402         if (ifr->lifr_addr.ss_family == AF_INET6) {
1403             struct sockaddr_in6 *s6= (struct sockaddr_in6 *)&(ifr->lifr_addr);
1404             s6->sin6_scope_id = getIndex(sock, ifr->lifr_name);
1405         }
1406 #endif
1407 
1408         /* add to the list */
1409         ifs = addif(env, sock,ifr->lifr_name, ifs, (struct sockaddr *)&(ifr->lifr_addr),family, (short) ifr->lifr_addrlen);
1410 
1411         /*
1412         * If an exception occurred we return immediately
1413         */
1414         if ((*env)->ExceptionOccurred(env)) {
1415             free(buf);
1416             return ifs;
1417         }
1418 
1419    }
1420 
1421     free(buf);
1422     return ifs;
1423 }
1424 
1425 static int getIndex(int sock, const char *name){
1426    /*
1427     * Try to get the interface index
1428     * (Not supported on Solaris 2.6 or 7)
1429     */
1430     struct lifreq if2;
1431     strcpy(if2.lifr_name, name);
1432 
1433     if (ioctl(sock, SIOCGLIFINDEX, (char *)&if2) < 0) {
1434         return -1;
1435     }
1436 
1437     return if2.lifr_index;
1438 }
1439 
1440 /**
1441  * Returns the IPv4 broadcast address of a named interface, if it exists.
1442  * Returns 0 if it doesn't have one.
1443  */
1444 static struct sockaddr *getBroadcast(JNIEnv *env, int sock, const char *ifname, struct sockaddr *brdcast_store) {
1445     struct sockaddr *ret = NULL;
1446     struct lifreq if2;
1447 
1448     memset((char *) &if2, 0, sizeof(if2));
1449     strcpy(if2.lifr_name, ifname);
1450 
1451     /* Let's make sure the interface does have a broadcast address */
1452     if (ioctl(sock, SIOCGLIFFLAGS, (char *)&if2)  < 0) {
1453         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL  SIOCGLIFFLAGS failed");
1454         return ret;
1455     }
1456 
1457     if (if2.lifr_flags & IFF_BROADCAST) {
1458         /* It does, let's retrieve it*/
1459         if (ioctl(sock, SIOCGLIFBRDADDR, (char *)&if2) < 0) {
1460             NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL SIOCGLIFBRDADDR failed");
1461             return ret;
1462         }
1463 
1464         ret = brdcast_store;
1465         memcpy(ret, &if2.lifr_broadaddr, sizeof(struct sockaddr));
1466     }
1467 
1468     return ret;
1469 }
1470 
1471 /**
1472  * Returns the IPv4 subnet prefix length (aka subnet mask) for the named
1473  * interface, if it has one, otherwise return -1.
1474  */
1475 static short getSubnet(JNIEnv *env, int sock, const char *ifname) {
1476     unsigned int mask;
1477     short ret;
1478     struct lifreq if2;
1479 
1480     memset((char *) &if2, 0, sizeof(if2));
1481     strcpy(if2.lifr_name, ifname);
1482 
1483     if (ioctl(sock, SIOCGLIFNETMASK, (char *)&if2) < 0) {
1484         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL SIOCGLIFNETMASK failed");
1485         return -1;
1486     }
1487 
1488     mask = ntohl(((struct sockaddr_in*)&(if2.lifr_addr))->sin_addr.s_addr);
1489     ret = 0;
1490 
1491     while (mask) {
1492        mask <<= 1;
1493        ret++;
1494     }
1495 
1496     return ret;
1497 }
1498 
1499 
1500 
1501 #define DEV_PREFIX  "/dev/"
1502 
1503 /**
1504  * Solaris specific DLPI code to get hardware address from a device.
1505  * Unfortunately, at least up to Solaris X, you have to have special
1506  * privileges (i.e. be root).
1507  */
1508 static int getMacFromDevice(JNIEnv *env, const char* ifname, unsigned char* retbuf) {
1509     char style1dev[MAXPATHLEN];
1510     int fd;
1511     dl_phys_addr_req_t dlpareq;
1512     dl_phys_addr_ack_t *dlpaack;
1513     struct strbuf msg;
1514     char buf[128];
1515     int flags = 0;
1516 
1517    /**
1518     * Device is in /dev
1519     * e.g.: /dev/bge0
1520     */
1521     strcpy(style1dev, DEV_PREFIX);
1522     strcat(style1dev, ifname);
1523     if ((fd = open(style1dev, O_RDWR)) < 0) {
1524         /*
1525          * Can't open it. We probably are missing the privilege.
1526          * We'll have to try something else
1527          */
1528          return 0;
1529     }
1530 
1531     dlpareq.dl_primitive = DL_PHYS_ADDR_REQ;
1532     dlpareq.dl_addr_type = DL_CURR_PHYS_ADDR;
1533 
1534     msg.buf = (char *)&dlpareq;
1535     msg.len = DL_PHYS_ADDR_REQ_SIZE;
1536 
1537     if (putmsg(fd, &msg, NULL, 0) < 0) {
1538         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "putmsg failed");
1539         return -1;
1540     }
1541 
1542     dlpaack = (dl_phys_addr_ack_t *)buf;
1543 
1544     msg.buf = (char *)buf;
1545     msg.len = 0;
1546     msg.maxlen = sizeof (buf);
1547     if (getmsg(fd, &msg, NULL, &flags) < 0) {
1548         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "getmsg failed");
1549         return -1;
1550     }
1551 
1552     if (msg.len < DL_PHYS_ADDR_ACK_SIZE || dlpaack->dl_primitive != DL_PHYS_ADDR_ACK) {
1553         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Couldn't obtain phys addr\n");
1554         return -1;
1555     }
1556 
1557     memcpy(retbuf, &buf[dlpaack->dl_addr_offset], dlpaack->dl_addr_length);
1558     return dlpaack->dl_addr_length;
1559 }
1560 
1561 /**
1562  * Get the Hardware address (usually MAC address) for the named interface.
1563  * return puts the data in buf, and returns the length, in byte, of the
1564  * MAC address. Returns -1 if there is no hardware address on that interface.
1565  */
1566 static int getMacAddress(JNIEnv *env, int sock, const char *ifname,  const struct in_addr* addr, unsigned char *buf) {
1567     struct arpreq arpreq;
1568     struct sockaddr_in* sin;
1569     struct sockaddr_in ipAddr;
1570     int len, i;
1571 
1572    /**
1573     * On Solaris we have to use DLPI, but it will only work if we have
1574     * privileged access (i.e. root). If that fails, we try a lookup
1575     * in the ARP table, which requires an IPv4 address.
1576     */
1577     if ((len = getMacFromDevice(env, ifname, buf))  == 0) {
1578         /*DLPI failed - trying to do arp lookup*/
1579 
1580        if (addr == NULL) {
1581           /**
1582            * No IPv4 address for that interface, so can't do an ARP lookup.
1583            */
1584            return -1;
1585       }
1586 
1587       len = 6; //???
1588 
1589       sin = (struct sockaddr_in *) &arpreq.arp_pa;
1590       memset((char *) &arpreq, 0, sizeof(struct arpreq));
1591       ipAddr.sin_port = 0;
1592       ipAddr.sin_family = AF_INET;
1593       memcpy(&ipAddr.sin_addr, addr, sizeof(struct in_addr));
1594       memcpy(&arpreq.arp_pa, &ipAddr, sizeof(struct sockaddr_in));
1595       arpreq.arp_flags= ATF_PUBL;
1596 
1597       if (ioctl(sock, SIOCGARP, &arpreq) < 0) {
1598           if (errno != ENXIO) {
1599               // "No such device or address" means no hardware address, so it's
1600               // normal don't throw an exception
1601               NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL failed");
1602               return -1;
1603           }
1604      }
1605 
1606      memcpy(buf, &arpreq.arp_ha.sa_data[0], len );
1607   }
1608 
1609     /*
1610      * All bytes to 0 means no hardware address.
1611      */
1612 
1613     for (i = 0; i < len; i++) {
1614       if (buf[i] != 0)
1615          return len;
1616     }
1617 
1618     return -1;
1619 }
1620 
1621 static int getMTU(JNIEnv *env, int sock,  const char *ifname) {
1622     struct lifreq if2;
1623 
1624     memset((char *) &if2, 0, sizeof(if2));
1625     strcpy(if2.lifr_name, ifname);
1626 
1627     if (ioctl(sock, SIOCGLIFMTU, (char *)&if2) < 0) {
1628         NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "IOCTL SIOCGLIFMTU failed");
1629         return -1;
1630     }
1631 
1632     return  if2.lifr_mtu;
1633 }
1634 
1635 
1636 static int getFlags(int sock, const char *ifname) {
1637      struct   lifreq lifr;
1638      memset((caddr_t)&lifr, 0, sizeof(lifr));
1639      strcpy((caddr_t)&(lifr.lifr_name), ifname);
1640 
1641      if (ioctl(sock, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
1642          return -1;
1643      }
1644 
1645      return  lifr.lifr_flags;
1646 }
1647 
1648 
1649 #endif
1650 
1651 
--- EOF ---