Print this page


Split Close
Expand all
Collapse all
          --- old/src/solaris/native/java/net/PlainDatagramSocketImpl.c
          +++ new/src/solaris/native/java/net/PlainDatagramSocketImpl.c
↓ open down ↓ 75 lines elided ↑ open up ↑
  76   76  #ifdef __linux__
  77   77  static jboolean isOldKernel;
  78   78  #endif
  79   79  
  80   80  #if defined(__linux__) && defined(AF_INET6)
  81   81  static jfieldID pdsi_multicastInterfaceID;
  82   82  static jfieldID pdsi_loopbackID;
  83   83  static jfieldID pdsi_ttlID;
  84   84  #endif
  85   85  
  86      -/*
  87      - * Returns a java.lang.Integer based on 'i'
  88      - */
  89      -static jobject createInteger(JNIEnv *env, int i) {
  90      -    static jclass i_class;
  91      -    static jmethodID i_ctrID;
       86 +static jclass i_class;
       87 +static jmethodID i_ctrID;
       88 +static jfieldID i_valueID;
  92   89  
       90 +int initIntegerIDs(JNIEnv* env) {
  93   91      if (i_class == NULL) {
  94   92          jclass c = (*env)->FindClass(env, "java/lang/Integer");
  95   93          CHECK_NULL_RETURN(c, NULL);
  96   94          i_ctrID = (*env)->GetMethodID(env, c, "<init>", "(I)V");
  97   95          CHECK_NULL_RETURN(i_ctrID, NULL);
       96 +        i_valueID = (*env)->GetFieldID(env, c, "value", "I");
       97 +        CHECK_NULL_RETURN(i_valueID, NULL);
  98   98          i_class = (*env)->NewGlobalRef(env, c);
  99   99          CHECK_NULL_RETURN(i_class, NULL);
 100  100      }
      101 +    return 1;
      102 +}
 101  103  
      104 +/* Returns a java.lang.Integer based on 'i' */
      105 +static jobject createInteger(JNIEnv *env, int i) {
      106 +    CHECK_NULL_RETURN(initIntegerIDs(env), NULL);
 102  107      return ( (*env)->NewObject(env, i_class, i_ctrID, i) );
 103  108  }
 104  109  
 105      -/*
 106      - * Returns a java.lang.Boolean based on 'b'
 107      - */
 108      -static jobject createBoolean(JNIEnv *env, int b) {
 109      -    static jclass b_class;
 110      -    static jmethodID b_ctrID;
      110 +/* Returns a jint based on the given java.lang.Integer */
      111 +static jint retrieveInteger(JNIEnv *env, jobject i) {
      112 +    CHECK_NULL_RETURN(initIntegerIDs(env), NULL);
      113 +    return (*env)->GetIntField(env, i, i_valueID);
      114 +}
 111  115  
      116 +static jclass b_class;
      117 +static jmethodID b_ctrID;
      118 +static jfieldID b_valueID;
      119 +
      120 +int initBooleanIDs(JNIEnv* env) {
 112  121      if (b_class == NULL) {
 113  122          jclass c = (*env)->FindClass(env, "java/lang/Boolean");
 114  123          CHECK_NULL_RETURN(c, NULL);
 115  124          b_ctrID = (*env)->GetMethodID(env, c, "<init>", "(Z)V");
 116  125          CHECK_NULL_RETURN(b_ctrID, NULL);
      126 +        b_valueID = (*env)->GetFieldID(env, c, "value", "Z");
      127 +        CHECK_NULL_RETURN(b_valueID, NULL);
 117  128          b_class = (*env)->NewGlobalRef(env, c);
 118  129          CHECK_NULL_RETURN(b_class, NULL);
 119  130      }
      131 +    return 1;
      132 +}
 120  133  
      134 +/* Returns a java.lang.Boolean based on 'b' */
      135 +static jobject createBoolean(JNIEnv *env, int b) {
      136 +    CHECK_NULL_RETURN(initBooleanIDs(env), NULL);
 121  137      return( (*env)->NewObject(env, b_class, b_ctrID, (jboolean)(b!=0)) );
 122  138  }
 123  139  
      140 +/* Returns a jboolean based on the given java.lang.Boolean */
      141 +static jboolean retrieveBoolean(JNIEnv *env, jobject b) {
      142 +    CHECK_NULL_RETURN(initBooleanIDs(env), NULL);
      143 +    return (*env)->GetBooleanField(env, b, b_valueID);
      144 +}
 124  145  
 125  146  /*
 126  147   * Returns the fd for a PlainDatagramSocketImpl or -1
 127  148   * if closed.
 128  149   */
 129  150  static int getFD(JNIEnv *env, jobject this) {
 130  151      jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 131  152      if (fdObj == NULL) {
 132  153          return -1;
 133  154      }
↓ open down ↓ 994 lines elided ↑ open up ↑
1128 1149      (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
1129 1150      NET_SocketClose(fd);
1130 1151  }
1131 1152  
1132 1153  
1133 1154  /*
1134 1155   * Set outgoing multicast interface designated by a NetworkInterface.
1135 1156   * Throw exception if failed.
1136 1157   */
1137 1158  static void mcast_set_if_by_if_v4(JNIEnv *env, jobject this, int fd, jobject value) {
1138      -    static jfieldID ni_addrsID;
1139      -    static jfieldID ia_addressID;
1140 1159      struct in_addr in;
1141 1160      jobjectArray addrArray;
1142 1161      jsize len;
1143 1162      jobject addr;
1144 1163      int i;
1145 1164  
1146      -    if (ni_addrsID == NULL) {
1147      -        jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1148      -        CHECK_NULL(c);
1149      -        ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1150      -                                        "[Ljava/net/InetAddress;");
1151      -        CHECK_NULL(ni_addrsID);
1152      -        c = (*env)->FindClass(env,"java/net/InetAddress");
1153      -        CHECK_NULL(c);
1154      -        ia_addressID = (*env)->GetFieldID(env, c, "address", "I");
1155      -        CHECK_NULL(ia_addressID);
1156      -    }
1157      -
1158 1165      addrArray = (*env)->GetObjectField(env, value, ni_addrsID);
1159 1166      len = (*env)->GetArrayLength(env, addrArray);
1160 1167  
1161 1168      /*
1162 1169       * Check that there is at least one address bound to this
1163 1170       * interface.
1164 1171       */
1165 1172      if (len < 1) {
1166 1173          JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1167 1174              "bad argument for IP_MULTICAST_IF2: No IP addresses bound to interface");
↓ open down ↓ 17 lines elided ↑ open up ↑
1185 1192                         "Error setting socket option");
1186 1193      }
1187 1194  }
1188 1195  
1189 1196  /*
1190 1197   * Set outgoing multicast interface designated by a NetworkInterface.
1191 1198   * Throw exception if failed.
1192 1199   */
1193 1200  #ifdef AF_INET6
1194 1201  static void mcast_set_if_by_if_v6(JNIEnv *env, jobject this, int fd, jobject value) {
1195      -    static jfieldID ni_indexID;
1196 1202      int index;
1197 1203  
1198      -    if (ni_indexID == NULL) {
1199      -        jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1200      -        CHECK_NULL(c);
1201      -        ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1202      -        CHECK_NULL(ni_indexID);
1203      -    }
1204 1204      index = (*env)->GetIntField(env, value, ni_indexID);
1205 1205  
1206 1206      if (JVM_SetSockOpt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
1207 1207                         (const char*)&index, sizeof(index)) < 0) {
1208 1208          if (errno == EINVAL && index > 0) {
1209 1209              JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1210 1210                  "IPV6_MULTICAST_IF failed (interface has IPv4 "
1211 1211                  "address only?)");
1212 1212          } else {
1213 1213              NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
↓ open down ↓ 13 lines elided ↑ open up ↑
1227 1227      }
1228 1228  #endif
1229 1229  }
1230 1230  #endif /* AF_INET6 */
1231 1231  
1232 1232  /*
1233 1233   * Set outgoing multicast interface designated by an InetAddress.
1234 1234   * Throw exception if failed.
1235 1235   */
1236 1236  static void mcast_set_if_by_addr_v4(JNIEnv *env, jobject this, int fd, jobject value) {
1237      -    static jfieldID ia_addressID;
1238 1237      struct in_addr in;
1239 1238  
1240      -    if (ia_addressID == NULL) {
1241      -        jclass c = (*env)->FindClass(env,"java/net/InetAddress");
1242      -        CHECK_NULL(c);
1243      -        ia_addressID = (*env)->GetFieldID(env, c, "address", "I");
1244      -        CHECK_NULL(ia_addressID);
1245      -    }
1246      -
1247 1239      in.s_addr = htonl( (*env)->GetIntField(env, value, ia_addressID) );
1248 1240  
1249 1241      if (JVM_SetSockOpt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1250 1242                         (const char*)&in, sizeof(in)) < 0) {
1251 1243          NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1252 1244                           "Error setting socket option");
1253 1245      }
1254 1246  }
1255 1247  
1256 1248  /*
1257 1249   * Set outgoing multicast interface designated by an InetAddress.
1258 1250   * Throw exception if failed.
1259 1251   */
1260 1252  #ifdef AF_INET6
1261 1253  static void mcast_set_if_by_addr_v6(JNIEnv *env, jobject this, int fd, jobject value) {
1262      -    static jclass ni_class;
1263      -    if (ni_class == NULL) {
1264      -        jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1265      -        CHECK_NULL(c);
1266      -        ni_class = (*env)->NewGlobalRef(env, c);
1267      -        CHECK_NULL(ni_class);
1268      -    }
1269      -
1270 1254      value = Java_java_net_NetworkInterface_getByInetAddress0(env, ni_class, value);
1271 1255      if (value == NULL) {
1272 1256          if (!(*env)->ExceptionOccurred(env)) {
1273 1257              JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1274 1258                   "bad argument for IP_MULTICAST_IF"
1275 1259                   ": address not bound to any interface");
1276 1260          }
1277 1261          return;
1278 1262      }
1279 1263  
↓ open down ↓ 75 lines elided ↑ open up ↑
1355 1339  #else
1356 1340          mcast_set_if_by_if_v4(env, this, fd, value);
1357 1341  #endif  /* AF_INET6 */
1358 1342      }
1359 1343  }
1360 1344  
1361 1345  /*
1362 1346   * Enable/disable local loopback of multicast datagrams.
1363 1347   */
1364 1348  static void mcast_set_loop_v4(JNIEnv *env, jobject this, int fd, jobject value) {
1365      -    jclass cls;
1366      -    jfieldID fid;
1367 1349      jboolean on;
1368 1350      char loopback;
1369 1351  
1370      -    cls = (*env)->FindClass(env, "java/lang/Boolean");
1371      -    CHECK_NULL(cls);
1372      -    fid =  (*env)->GetFieldID(env, cls, "value", "Z");
1373      -    CHECK_NULL(fid);
1374      -
1375      -    on = (*env)->GetBooleanField(env, value, fid);
     1352 +    on = retrieveBoolean(env, value);
1376 1353      loopback = (!on ? 1 : 0);
1377 1354  
1378 1355      if (NET_SetSockOpt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, (const void *)&loopback, sizeof(char)) < 0) {
1379 1356          NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1380 1357          return;
1381 1358      }
1382 1359  }
1383 1360  
1384 1361  /*
1385 1362   * Enable/disable local loopback of multicast datagrams.
1386 1363   */
1387 1364  #ifdef AF_INET6
1388 1365  static void mcast_set_loop_v6(JNIEnv *env, jobject this, int fd, jobject value) {
1389      -    jclass cls;
1390      -    jfieldID fid;
1391 1366      jboolean on;
1392 1367      int loopback;
1393 1368  
1394      -    cls = (*env)->FindClass(env, "java/lang/Boolean");
1395      -    CHECK_NULL(cls);
1396      -    fid =  (*env)->GetFieldID(env, cls, "value", "Z");
1397      -    CHECK_NULL(fid);
1398      -
1399      -    on = (*env)->GetBooleanField(env, value, fid);
     1369 +    on = retrieveBoolean(env, value);
1400 1370      loopback = (!on ? 1 : 0);
1401 1371  
1402 1372      if (NET_SetSockOpt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (const void *)&loopback, sizeof(int)) < 0) {
1403 1373          NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1404 1374          return;
1405 1375      }
1406 1376  
1407 1377  #ifdef __linux__
1408 1378      /*
1409 1379       * Can't query IPV6_MULTICAST_LOOP on Linux 2.2 kernel so
↓ open down ↓ 90 lines elided ↑ open up ↑
1500 1470      if (NET_MapSocketOption(opt, &level, &optname)) {
1501 1471          JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Invalid option");
1502 1472          return;
1503 1473      }
1504 1474  
1505 1475      switch (opt) {
1506 1476          case java_net_SocketOptions_SO_SNDBUF :
1507 1477          case java_net_SocketOptions_SO_RCVBUF :
1508 1478          case java_net_SocketOptions_IP_TOS :
1509 1479              {
1510      -                jclass cls;
1511      -                jfieldID fid;
1512      -
1513      -                cls = (*env)->FindClass(env, "java/lang/Integer");
1514      -                CHECK_NULL(cls);
1515      -                fid =  (*env)->GetFieldID(env, cls, "value", "I");
1516      -                CHECK_NULL(fid);
1517      -
1518      -                optval.i = (*env)->GetIntField(env, value, fid);
     1480 +                optval.i = retrieveInteger(env, value);
1519 1481                  optlen = sizeof(optval.i);
1520 1482                  break;
1521 1483              }
1522 1484  
1523 1485          case java_net_SocketOptions_SO_REUSEADDR:
1524 1486          case java_net_SocketOptions_SO_BROADCAST:
1525 1487              {
1526      -                jclass cls;
1527      -                jfieldID fid;
1528      -                jboolean on;
     1488 +                jboolean on = retrieveBoolean(env, value);
1529 1489  
1530      -                cls = (*env)->FindClass(env, "java/lang/Boolean");
1531      -                CHECK_NULL(cls);
1532      -                fid =  (*env)->GetFieldID(env, cls, "value", "Z");
1533      -                CHECK_NULL(fid);
1534      -
1535      -                on = (*env)->GetBooleanField(env, value, fid);
1536      -
1537 1490                  /* SO_REUSEADDR or SO_BROADCAST */
1538 1491                  optval.i = (on ? 1 : 0);
1539 1492                  optlen = sizeof(optval.i);
1540 1493  
1541 1494                  break;
1542 1495              }
1543 1496  
1544 1497          default :
1545 1498              JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1546 1499                  "Socket option not supported by PlainDatagramSocketImp");
↓ open down ↓ 39 lines elided ↑ open up ↑
1586 1539  #ifdef AF_INET6
1587 1540      if (ipv6_available()) {
1588 1541          isIPV4 = JNI_FALSE;
1589 1542      }
1590 1543  #endif
1591 1544  
1592 1545      /*
1593 1546       * IPv4 implementation
1594 1547       */
1595 1548      if (isIPV4) {
1596      -        static jclass inet4_class;
1597      -        static jmethodID inet4_ctrID;
1598      -        static jfieldID inet4_addrID;
1599      -
1600      -        static jclass ni_class;
1601      -        static jmethodID ni_ctrID;
1602      -        static jfieldID ni_indexID;
1603      -        static jfieldID ni_addrsID;
1604      -
1605 1549          jobjectArray addrArray;
1606 1550          jobject addr;
1607 1551          jobject ni;
1608 1552  
1609 1553          struct in_addr in;
1610 1554          struct in_addr *inP = &in;
1611 1555          int len = sizeof(struct in_addr);
1612 1556  
1613 1557  #ifdef __linux__
1614 1558          struct ip_mreqn mreqn;
↓ open down ↓ 6 lines elided ↑ open up ↑
1621 1565          if (JVM_GetSockOpt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1622 1566                             (char *)inP, &len) < 0) {
1623 1567              NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1624 1568                               "Error getting socket option");
1625 1569              return NULL;
1626 1570          }
1627 1571  
1628 1572          /*
1629 1573           * Construct and populate an Inet4Address
1630 1574           */
1631      -        if (inet4_class == NULL) {
1632      -            jclass c = (*env)->FindClass(env, "java/net/Inet4Address");
1633      -            CHECK_NULL_RETURN(c, NULL);
1634      -            inet4_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1635      -            CHECK_NULL_RETURN(inet4_ctrID, NULL);
1636      -            inet4_addrID = (*env)->GetFieldID(env, c, "address", "I");
1637      -            CHECK_NULL_RETURN(inet4_addrID, NULL);
1638      -            inet4_class = (*env)->NewGlobalRef(env, c);
1639      -            CHECK_NULL_RETURN(inet4_class, NULL);
1640      -        }
1641      -        addr = (*env)->NewObject(env, inet4_class, inet4_ctrID, 0);
     1575 +        addr = (*env)->NewObject(env, ia4_class, ia4_ctrID, 0);
1642 1576          CHECK_NULL_RETURN(addr, NULL);
1643 1577  
1644 1578  #ifdef __linux__
1645      -        (*env)->SetIntField(env, addr, inet4_addrID,
     1579 +        (*env)->SetIntField(env, addr, ia_addressID,
1646 1580                  (isOldKernel ? ntohl(mreqn.imr_address.s_addr) : ntohl(in.s_addr)) );
1647 1581  #else
1648      -        (*env)->SetIntField(env, addr, inet4_addrID, ntohl(in.s_addr));
     1582 +        (*env)->SetIntField(env, addr, ia_addressID, ntohl(in.s_addr));
1649 1583  #endif
1650 1584  
1651 1585          /*
1652 1586           * For IP_MULTICAST_IF return InetAddress
1653 1587           */
1654 1588          if (opt == java_net_SocketOptions_IP_MULTICAST_IF) {
1655 1589              return addr;
1656 1590          }
1657 1591  
1658 1592          /*
1659 1593           * For IP_MULTICAST_IF2 we get the NetworkInterface for
1660 1594           * this address and return it
1661 1595           */
1662      -        if (ni_class == NULL) {
1663      -            jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1664      -            CHECK_NULL_RETURN(c, NULL);
1665      -            ni_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1666      -            CHECK_NULL_RETURN(ni_ctrID, NULL);
1667      -            ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1668      -            CHECK_NULL_RETURN(ni_indexID, NULL);
1669      -            ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1670      -                                            "[Ljava/net/InetAddress;");
1671      -            CHECK_NULL_RETURN(ni_addrsID, NULL);
1672      -            ni_class = (*env)->NewGlobalRef(env, c);
1673      -            CHECK_NULL_RETURN(ni_class, NULL);
1674      -        }
1675 1596          ni = Java_java_net_NetworkInterface_getByInetAddress0(env, ni_class, addr);
1676 1597          if (ni) {
1677 1598              return ni;
1678 1599          }
1679 1600  
1680 1601          /*
1681 1602           * The address doesn't appear to be bound at any known
1682 1603           * NetworkInterface. Therefore we construct a NetworkInterface
1683 1604           * with this address.
1684 1605           */
1685 1606          ni = (*env)->NewObject(env, ni_class, ni_ctrID, 0);
1686 1607          CHECK_NULL_RETURN(ni, NULL);
1687 1608  
1688 1609          (*env)->SetIntField(env, ni, ni_indexID, -1);
1689      -        addrArray = (*env)->NewObjectArray(env, 1, inet4_class, NULL);
     1610 +        addrArray = (*env)->NewObjectArray(env, 1, ia4_class, NULL);
1690 1611          CHECK_NULL_RETURN(addrArray, NULL);
1691 1612          (*env)->SetObjectArrayElement(env, addrArray, 0, addr);
1692 1613          (*env)->SetObjectField(env, ni, ni_addrsID, addrArray);
1693 1614          return ni;
1694 1615      }
1695 1616  
1696 1617  
1697 1618  #ifdef AF_INET6
1698 1619      /*
1699 1620       * IPv6 implementation
1700 1621       */
1701 1622      if ((opt == java_net_SocketOptions_IP_MULTICAST_IF) ||
1702 1623          (opt == java_net_SocketOptions_IP_MULTICAST_IF2)) {
1703      -
1704      -        static jclass ni_class;
1705      -        static jmethodID ni_ctrID;
1706      -        static jfieldID ni_indexID;
1707      -        static jfieldID ni_addrsID;
1708      -        static jclass ia_class;
1709 1624          static jmethodID ia_anyLocalAddressID;
1710 1625  
1711 1626          int index;
1712 1627          int len = sizeof(index);
1713 1628  
1714 1629          jobjectArray addrArray;
1715 1630          jobject addr;
1716 1631          jobject ni;
1717 1632  
1718 1633  #ifdef __linux__
↓ open down ↓ 7 lines elided ↑ open up ↑
1726 1641  #endif
1727 1642          {
1728 1643              if (JVM_GetSockOpt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
1729 1644                                 (char*)&index, &len) < 0) {
1730 1645                  NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1731 1646                                 "Error getting socket option");
1732 1647                  return NULL;
1733 1648              }
1734 1649          }
1735 1650  
1736      -        if (ni_class == NULL) {
1737      -            jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1738      -            CHECK_NULL_RETURN(c, NULL);
1739      -            ni_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1740      -            CHECK_NULL_RETURN(ni_ctrID, NULL);
1741      -            ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1742      -            CHECK_NULL_RETURN(ni_indexID, NULL);
1743      -            ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1744      -                                            "[Ljava/net/InetAddress;");
1745      -            CHECK_NULL_RETURN(ni_addrsID, NULL);
1746      -
1747      -            ia_class = (*env)->FindClass(env, "java/net/InetAddress");
1748      -            CHECK_NULL_RETURN(ia_class, NULL);
1749      -            ia_class = (*env)->NewGlobalRef(env, ia_class);
1750      -            CHECK_NULL_RETURN(ia_class, NULL);
     1651 +        if (ia_anyLocalAddressID == NULL) {
1751 1652              ia_anyLocalAddressID = (*env)->GetStaticMethodID(env,
1752 1653                                                               ia_class,
1753 1654                                                               "anyLocalAddress",
1754 1655                                                               "()Ljava/net/InetAddress;");
1755 1656              CHECK_NULL_RETURN(ia_anyLocalAddressID, NULL);
1756      -            ni_class = (*env)->NewGlobalRef(env, c);
1757      -            CHECK_NULL_RETURN(ni_class, NULL);
1758 1657          }
1759 1658  
1760 1659          /*
1761 1660           * If multicast to a specific interface then return the
1762 1661           * interface (for IF2) or the any address on that interface
1763 1662           * (for IF).
1764 1663           */
1765 1664          if (index > 0) {
1766 1665              ni = Java_java_net_NetworkInterface_getByIndex0(env, ni_class,
1767 1666                                                                     index);
↓ open down ↓ 393 lines elided ↑ open up ↑
2161 2060           * Linux/IPv6:  use ip_mreqn structure populated with multicast
2162 2061           *              address and interface index.
2163 2062           *
2164 2063           * IPv4:        use ip_mreq structure populated with multicast
2165 2064           *              address and first address obtained from
2166 2065           *              NetworkInterface
2167 2066           */
2168 2067          if (niObj != NULL) {
2169 2068  #if defined(__linux__) && defined(AF_INET6)
2170 2069              if (ipv6_available()) {
2171      -                static jfieldID ni_indexID;
2172      -
2173      -                if (ni_indexID == NULL) {
2174      -                    jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
2175      -                    CHECK_NULL(c);
2176      -                    ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
2177      -                    CHECK_NULL(ni_indexID);
2178      -                }
2179      -
2180 2070                  mname.imr_multiaddr.s_addr = htonl((*env)->GetIntField(env, iaObj, ia_addressID));
2181 2071                  mname.imr_address.s_addr = 0;
2182 2072                  mname.imr_ifindex =  (*env)->GetIntField(env, niObj, ni_indexID);
2183 2073                  mname_len = sizeof(struct ip_mreqn);
2184 2074              } else
2185 2075  #endif
2186 2076              {
2187 2077                  jobjectArray addrArray = (*env)->GetObjectField(env, niObj, ni_addrsID);
2188 2078                  jobject addr;
2189 2079  
↓ open down ↓ 247 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX