1 /*

     2  * Copyright (c) 1997, 2017, 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 #include <dlfcn.h>

    26 #include <errno.h>

    27 #include <net/if.h>

    28 #include <netinet/tcp.h> // defines TCP_NODELAY

    29 #include <stdlib.h>

    30 #include <string.h>

    31 #include <sys/ioctl.h>

    32 #include <sys/time.h>

    33 

    34 #if defined(__linux__)

    35 #include <arpa/inet.h>

    36 #include <net/route.h>

    37 #include <sys/utsname.h>

    38 #endif

    39 

    40 #if defined(__solaris__)

    41 #include <inet/nd.h>

    42 #include <limits.h>

    43 #include <stropts.h>

    44 #include <sys/filio.h>

    45 #include <sys/sockio.h>

    46 #endif

    47 

    48 #if defined(MACOSX)

    49 #include <sys/sysctl.h>

    50 #endif

    51 

    52 #include "jvm.h"

    53 #include "net_util.h"

    54 

    55 #include "java_net_SocketOptions.h"

    56 #include "java_net_InetAddress.h"

    57 

    58 #if defined(__linux__) && !defined(IPV6_FLOWINFO_SEND)

    59 #define IPV6_FLOWINFO_SEND      33

    60 #endif

    61 

    62 #if defined(__solaris__) && !defined(MAXINT)

    63 #define MAXINT INT_MAX

    64 #endif

    65 

    66 /*

    67  * EXCLBIND socket options only on Solaris

    68  */

    69 #if defined(__solaris__) && !defined(TCP_EXCLBIND)

    70 #define TCP_EXCLBIND            0x21

    71 #endif

    72 #if defined(__solaris__) && !defined(UDP_EXCLBIND)

    73 #define UDP_EXCLBIND            0x0101

    74 #endif

    75 

    76 void setDefaultScopeID(JNIEnv *env, struct sockaddr *him)

    77 {

    78 #ifdef MACOSX

    79     static jclass ni_class = NULL;

    80     static jfieldID ni_defaultIndexID;

    81     if (ni_class == NULL) {

    82         jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");

    83         CHECK_NULL(c);

    84         c = (*env)->NewGlobalRef(env, c);

    85         CHECK_NULL(c);

    86         ni_defaultIndexID = (*env)->GetStaticFieldID(env, c, "defaultIndex", "I");

    87         CHECK_NULL(ni_defaultIndexID);

    88         ni_class = c;

    89     }

    90     int defaultIndex;

    91     struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)him;

    92     if (sin6->sin6_family == AF_INET6 && (sin6->sin6_scope_id == 0)) {

    93         defaultIndex = (*env)->GetStaticIntField(env, ni_class,

    94                                                  ni_defaultIndexID);

    95         sin6->sin6_scope_id = defaultIndex;

    96     }

    97 #endif

    98 }

    99 

   100 int getDefaultScopeID(JNIEnv *env) {

   101     int defaultIndex = 0;

   102     static jclass ni_class = NULL;

   103     static jfieldID ni_defaultIndexID;

   104     if (ni_class == NULL) {

   105         jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");

   106         CHECK_NULL_RETURN(c, 0);

   107         c = (*env)->NewGlobalRef(env, c);

   108         CHECK_NULL_RETURN(c, 0);

   109         ni_defaultIndexID = (*env)->GetStaticFieldID(env, c, "defaultIndex", "I");

   110         CHECK_NULL_RETURN(ni_defaultIndexID, 0);

   111         ni_class = c;

   112     }

   113     defaultIndex = (*env)->GetStaticIntField(env, ni_class,

   114                                              ni_defaultIndexID);

   115     return defaultIndex;

   116 }

   117 

   118 #define RESTARTABLE(_cmd, _result) do { \

   119     do { \

   120         _result = _cmd; \

   121     } while((_result == -1) && (errno == EINTR)); \

   122 } while(0)

   123 

   124 int NET_SocketAvailable(int s, jint *pbytes) {

   125     int result;

   126     RESTARTABLE(ioctl(s, FIONREAD, pbytes), result);

   127     // note: ioctl can return 0 when successful, NET_SocketAvailable

   128     // is expected to return 0 on failure and 1 on success.

   129     return (result == -1) ? 0 : 1;

   130 }

   131 

   132 #ifdef __solaris__

   133 static int init_tcp_max_buf, init_udp_max_buf;

   134 static int tcp_max_buf;

   135 static int udp_max_buf;

   136 static int useExclBind = 0;

   137 

   138 /*

   139  * Get the specified parameter from the specified driver. The value

   140  * of the parameter is assumed to be an 'int'. If the parameter

   141  * cannot be obtained return -1

   142  */

   143 int net_getParam(char *driver, char *param)

   144 {

   145     struct strioctl stri;

   146     char buf [64];

   147     int s;

   148     int value;

   149 

   150     s = open (driver, O_RDWR);

   151     if (s < 0) {

   152         return -1;

   153     }

   154     strncpy (buf, param, sizeof(buf));

   155     stri.ic_cmd = ND_GET;

   156     stri.ic_timout = 0;

   157     stri.ic_dp = buf;

   158     stri.ic_len = sizeof(buf);

   159     if (ioctl (s, I_STR, &stri) < 0) {

   160         value = -1;

   161     } else {

   162         value = atoi(buf);

   163     }

   164     close (s);

   165     return value;

   166 }

   167 

   168 /*

   169  * Iterative way to find the max value that SO_SNDBUF or SO_RCVBUF

   170  * for Solaris versions that do not support the ioctl() in net_getParam().

   171  * Ugly, but only called once (for each sotype).

   172  *

   173  * As an optimization, we make a guess using the default values for Solaris

   174  * assuming they haven't been modified with ndd.

   175  */

   176 

   177 #define MAX_TCP_GUESS 1024 * 1024

   178 #define MAX_UDP_GUESS 2 * 1024 * 1024

   179 

   180 #define FAIL_IF_NOT_ENOBUFS if (errno != ENOBUFS) return -1

   181 

   182 static int findMaxBuf(int fd, int opt, int sotype) {

   183     int a = 0;

   184     int b = MAXINT;

   185     int initial_guess;

   186     int limit = -1;

   187 

   188     if (sotype == SOCK_DGRAM) {

   189         initial_guess = MAX_UDP_GUESS;

   190     } else {

   191         initial_guess = MAX_TCP_GUESS;

   192     }

   193 

   194     if (setsockopt(fd, SOL_SOCKET, opt, &initial_guess, sizeof(int)) == 0) {

   195         initial_guess++;

   196         if (setsockopt(fd, SOL_SOCKET, opt, &initial_guess,sizeof(int)) < 0) {

   197             FAIL_IF_NOT_ENOBUFS;

   198             return initial_guess - 1;

   199         }

   200         a = initial_guess;

   201     } else {

   202         FAIL_IF_NOT_ENOBUFS;

   203         b = initial_guess - 1;

   204     }

   205     do {

   206         int mid = a + (b-a)/2;

   207         if (setsockopt(fd, SOL_SOCKET, opt, &mid, sizeof(int)) == 0) {

   208             limit = mid;

   209             a = mid + 1;

   210         } else {

   211             FAIL_IF_NOT_ENOBUFS;

   212             b = mid - 1;

   213         }

   214     } while (b >= a);

   215 

   216     return limit;

   217 }

   218 #endif

   219 

   220 #ifdef __linux__

   221 static int vinit = 0;

   222 static int kernelV24 = 0;

   223 static int vinit24 = 0;

   224 

   225 int kernelIsV24 () {

   226     if (!vinit24) {

   227         struct utsname sysinfo;

   228         if (uname(&sysinfo) == 0) {

   229             sysinfo.release[3] = '\0';

   230             if (strcmp(sysinfo.release, "2.4") == 0) {

   231                 kernelV24 = JNI_TRUE;

   232             }

   233         }

   234         vinit24 = 1;

   235     }

   236     return kernelV24;

   237 }

   238 #endif

   239 

   240 void

   241 NET_ThrowByNameWithLastError(JNIEnv *env, const char *name,

   242                    const char *defaultDetail) {

   243     JNU_ThrowByNameWithMessageAndLastError(env, name, defaultDetail);

   244 }

   245 

   246 void

   247 NET_ThrowCurrent(JNIEnv *env, char *msg) {

   248     NET_ThrowNew(env, errno, msg);

   249 }

   250 

   251 void

   252 NET_ThrowNew(JNIEnv *env, int errorNumber, char *msg) {

   253     char fullMsg[512];

   254     if (!msg) {

   255         msg = "no further information";

   256     }

   257     switch(errorNumber) {

   258     case EBADF:

   259         jio_snprintf(fullMsg, sizeof(fullMsg), "socket closed: %s", msg);

   260         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", fullMsg);

   261         break;

   262     case EINTR:

   263         JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException", msg);

   264         break;

   265     default:

   266         errno = errorNumber;

   267         JNU_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", msg);

   268         break;

   269     }

   270 }

   271 

   272 

   273 jfieldID

   274 NET_GetFileDescriptorID(JNIEnv *env)

   275 {

   276     jclass cls = (*env)->FindClass(env, "java/io/FileDescriptor");

   277     CHECK_NULL_RETURN(cls, NULL);

   278     return (*env)->GetFieldID(env, cls, "fd", "I");

   279 }

   280 

   281 #if defined(DONT_ENABLE_IPV6)

   282 jint  IPv6_supported()

   283 {

   284     return JNI_FALSE;

   285 }

   286 

   287 #else /* !DONT_ENABLE_IPV6 */

   288 

   289 jint  IPv6_supported()

   290 {

   291     int fd;

   292     void *ipv6_fn;

   293     SOCKETADDRESS sa;

   294     socklen_t sa_len = sizeof(SOCKETADDRESS);

   295 

   296     fd = socket(AF_INET6, SOCK_STREAM, 0) ;

   297     if (fd < 0) {

   298         /*

   299          *  TODO: We really cant tell since it may be an unrelated error

   300          *  for now we will assume that AF_INET6 is not available

   301          */

   302         return JNI_FALSE;

   303     }

   304 

   305     /*

   306      * If fd 0 is a socket it means we've been launched from inetd or

   307      * xinetd. If it's a socket then check the family - if it's an

   308      * IPv4 socket then we need to disable IPv6.

   309      */

   310     if (getsockname(0, &sa.sa, &sa_len) == 0) {

   311         if (sa.sa.sa_family != AF_INET6) {

   312             close(fd);

   313             return JNI_FALSE;

   314         }

   315     }

   316 

   317     /**

   318      * Linux - check if any interface has an IPv6 address.

   319      * Don't need to parse the line - we just need an indication.

   320      */

   321 #ifdef __linux__

   322     {

   323         FILE *fP = fopen("/proc/net/if_inet6", "r");

   324         char buf[255];

   325         char *bufP;

   326 

   327         if (fP == NULL) {

   328             close(fd);

   329             return JNI_FALSE;

   330         }

   331         bufP = fgets(buf, sizeof(buf), fP);

   332         fclose(fP);

   333         if (bufP == NULL) {

   334             close(fd);

   335             return JNI_FALSE;

   336         }

   337     }

   338 #endif

   339 

   340     /**

   341      * On Solaris 8 it's possible to create INET6 sockets even

   342      * though IPv6 is not enabled on all interfaces. Thus we

   343      * query the number of IPv6 addresses to verify that IPv6

   344      * has been configured on at least one interface.

   345      *

   346      * On Linux it doesn't matter - if IPv6 is built-in the

   347      * kernel then IPv6 addresses will be bound automatically

   348      * to all interfaces.

   349      */

   350 #ifdef __solaris__

   351 

   352 #ifdef SIOCGLIFNUM

   353     {

   354         struct lifnum numifs;

   355 

   356         numifs.lifn_family = AF_INET6;

   357         numifs.lifn_flags = 0;

   358         if (ioctl(fd, SIOCGLIFNUM, (char *)&numifs) < 0) {

   359             /**

   360              * SIOCGLIFNUM failed - assume IPv6 not configured

   361              */

   362             close(fd);

   363             return JNI_FALSE;

   364         }

   365         /**

   366          * If no IPv6 addresses then return false. If count > 0

   367          * it's possible that all IPv6 addresses are "down" but

   368          * that's okay as they may be brought "up" while the

   369          * VM is running.

   370          */

   371         if (numifs.lifn_count == 0) {

   372             close(fd);

   373             return JNI_FALSE;

   374         }

   375     }

   376 #else

   377     /* SIOCGLIFNUM not defined in build environment ??? */

   378     close(fd);

   379     return JNI_FALSE;

   380 #endif

   381 

   382 #endif /* __solaris */

   383 

   384     /*

   385      *  OK we may have the stack available in the kernel,

   386      *  we should also check if the APIs are available.

   387      */

   388     ipv6_fn = JVM_FindLibraryEntry(RTLD_DEFAULT, "inet_pton");

   389     close(fd);

   390     if (ipv6_fn == NULL ) {

   391         return JNI_FALSE;

   392     } else {

   393         return JNI_TRUE;

   394     }

   395 }

   396 #endif /* DONT_ENABLE_IPV6 */

   397 

   398 jint reuseport_supported()

   399 {

   400     /* Do a simple dummy call, and try to figure out from that */

   401     int one = 1;

   402     int rv, s;

   403     s = socket(PF_INET, SOCK_STREAM, 0);

   404     if (s < 0) {

   405         return JNI_FALSE;

   406     }

   407     rv = setsockopt(s, SOL_SOCKET, SO_REUSEPORT, (void *)&one, sizeof(one));

   408     if (rv != 0) {

   409         rv = JNI_FALSE;

   410     } else {

   411         rv = JNI_TRUE;

   412     }

   413     close(s);

   414     return rv;

   415 }

   416 

   417 void NET_ThrowUnknownHostExceptionWithGaiError(JNIEnv *env,

   418                                                const char* hostname,

   419                                                int gai_error)

   420 {

   421     int size;

   422     char *buf;

   423     const char *format = "%s: %s";

   424     const char *error_string = gai_strerror(gai_error);

   425     if (error_string == NULL)

   426         error_string = "unknown error";

   427 

   428     size = strlen(format) + strlen(hostname) + strlen(error_string) + 2;

   429     buf = (char *) malloc(size);

   430     if (buf) {

   431         jstring s;

   432         sprintf(buf, format, hostname, error_string);

   433         s = JNU_NewStringPlatform(env, buf);

   434         if (s != NULL) {

   435             jobject x = JNU_NewObjectByName(env,

   436                                             "java/net/UnknownHostException",

   437                                             "(Ljava/lang/String;)V", s);

   438             if (x != NULL)

   439                 (*env)->Throw(env, x);

   440         }

   441         free(buf);

   442     }

   443 }

   444 

   445 #if defined(__linux__)

   446 

   447 /* following code creates a list of addresses from the kernel

   448  * routing table that are routed via the loopback address.

   449  * We check all destination addresses against this table

   450  * and override the scope_id field to use the relevant value for "lo"

   451  * in order to work-around the Linux bug that prevents packets destined

   452  * for certain local addresses from being sent via a physical interface.

   453  */

   454 

   455 struct loopback_route {

   456     struct in6_addr addr; /* destination address */

   457     int plen; /* prefix length */

   458 };

   459 

   460 static struct loopback_route *loRoutes = 0;

   461 static int nRoutes = 0; /* number of routes */

   462 static int loRoutes_size = 16; /* initial size */

   463 static int lo_scope_id = 0;

   464 

   465 static void initLoopbackRoutes();

   466 

   467 void printAddr (struct in6_addr *addr) {

   468     int i;

   469     for (i=0; i<16; i++) {

   470         printf ("%02x", addr->s6_addr[i]);

   471     }

   472     printf ("\n");

   473 }

   474 

   475 static jboolean needsLoopbackRoute (struct in6_addr* dest_addr) {

   476     int byte_count;

   477     int extra_bits, i;

   478     struct loopback_route *ptr;

   479 

   480     if (loRoutes == 0) {

   481         initLoopbackRoutes();

   482     }

   483 

   484     for (ptr = loRoutes, i=0; i<nRoutes; i++, ptr++) {

   485         struct in6_addr *target_addr=&ptr->addr;

   486         int dest_plen = ptr->plen;

   487         byte_count = dest_plen >> 3;

   488         extra_bits = dest_plen & 0x3;

   489 

   490         if (byte_count > 0) {

   491             if (memcmp(target_addr, dest_addr, byte_count)) {

   492                 continue;  /* no match */

   493             }

   494         }

   495 

   496         if (extra_bits > 0) {

   497             unsigned char c1 = ((unsigned char *)target_addr)[byte_count];

   498             unsigned char c2 = ((unsigned char *)&dest_addr)[byte_count];

   499             unsigned char mask = 0xff << (8 - extra_bits);

   500             if ((c1 & mask) != (c2 & mask)) {

   501                 continue;

   502             }

   503         }

   504         return JNI_TRUE;

   505     }

   506     return JNI_FALSE;

   507 }

   508 

   509 

   510 static void initLoopbackRoutes() {

   511     FILE *f;

   512     char srcp[8][5];

   513     char hopp[8][5];

   514     int dest_plen, src_plen, use, refcnt, metric;

   515     unsigned long flags;

   516     char dest_str[40];

   517     struct in6_addr dest_addr;

   518     char device[16];

   519     struct loopback_route *loRoutesTemp;

   520 

   521     if (loRoutes != 0) {

   522         free (loRoutes);

   523     }

   524     loRoutes = calloc (loRoutes_size, sizeof(struct loopback_route));

   525     if (loRoutes == 0) {

   526         return;

   527     }

   528     /*

   529      * Scan /proc/net/ipv6_route looking for a matching

   530      * route.

   531      */

   532     if ((f = fopen("/proc/net/ipv6_route", "r")) == NULL) {

   533         return ;

   534     }

   535     while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

   536                      "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

   537                      "%4s%4s%4s%4s%4s%4s%4s%4s "

   538                      "%08x %08x %08x %08lx %8s",

   539                      dest_str, &dest_str[5], &dest_str[10], &dest_str[15],

   540                      &dest_str[20], &dest_str[25], &dest_str[30], &dest_str[35],

   541                      &dest_plen,

   542                      srcp[0], srcp[1], srcp[2], srcp[3],

   543                      srcp[4], srcp[5], srcp[6], srcp[7],

   544                      &src_plen,

   545                      hopp[0], hopp[1], hopp[2], hopp[3],

   546                      hopp[4], hopp[5], hopp[6], hopp[7],

   547                      &metric, &use, &refcnt, &flags, device) == 31) {

   548 

   549         /*

   550          * Some routes should be ignored

   551          */

   552         if ( (dest_plen < 0 || dest_plen > 128)  ||

   553              (src_plen != 0) ||

   554              (flags & (RTF_POLICY | RTF_FLOW)) ||

   555              ((flags & RTF_REJECT) && dest_plen == 0) ) {

   556             continue;

   557         }

   558 

   559         /*

   560          * Convert the destination address

   561          */

   562         dest_str[4] = ':';

   563         dest_str[9] = ':';

   564         dest_str[14] = ':';

   565         dest_str[19] = ':';

   566         dest_str[24] = ':';

   567         dest_str[29] = ':';

   568         dest_str[34] = ':';

   569         dest_str[39] = '\0';

   570 

   571         if (inet_pton(AF_INET6, dest_str, &dest_addr) < 0) {

   572             /* not an Ipv6 address */

   573             continue;

   574         }

   575         if (strcmp(device, "lo") != 0) {

   576             /* Not a loopback route */

   577             continue;

   578         } else {

   579             if (nRoutes == loRoutes_size) {

   580                 loRoutesTemp = realloc (loRoutes, loRoutes_size *

   581                                         sizeof (struct loopback_route) * 2);

   582 

   583                 if (loRoutesTemp == 0) {

   584                     free(loRoutes);

   585                     fclose (f);

   586                     return;

   587                 }

   588                 loRoutes=loRoutesTemp;

   589                 loRoutes_size *= 2;

   590             }

   591             memcpy (&loRoutes[nRoutes].addr,&dest_addr,sizeof(struct in6_addr));

   592             loRoutes[nRoutes].plen = dest_plen;

   593             nRoutes ++;

   594         }

   595     }

   596 

   597     fclose (f);

   598     {

   599         /* now find the scope_id for "lo" */

   600 

   601         char devname[21];

   602         char addr6p[8][5];

   603         int plen, scope, dad_status, if_idx;

   604 

   605         if ((f = fopen("/proc/net/if_inet6", "r")) != NULL) {

   606             while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %08x %02x %02x %02x %20s\n",

   607                       addr6p[0], addr6p[1], addr6p[2], addr6p[3],

   608                       addr6p[4], addr6p[5], addr6p[6], addr6p[7],

   609                   &if_idx, &plen, &scope, &dad_status, devname) == 13) {

   610 

   611                 if (strcmp(devname, "lo") == 0) {

   612                     /*

   613                      * Found - so just return the index

   614                      */

   615                     fclose(f);

   616                     lo_scope_id = if_idx;

   617                     return;

   618                 }

   619             }

   620             fclose(f);

   621         }

   622     }

   623 }

   624 

   625 /*

   626  * Following is used for binding to local addresses. Equivalent

   627  * to code above, for bind().

   628  */

   629 

   630 struct localinterface {

   631     int index;

   632     char localaddr [16];

   633 };

   634 

   635 static struct localinterface *localifs = 0;

   636 static int localifsSize = 0;    /* size of array */

   637 static int nifs = 0;            /* number of entries used in array */

   638 

   639 /* not thread safe: make sure called once from one thread */

   640 

   641 static void initLocalIfs () {

   642     FILE *f;

   643     unsigned char staddr [16];

   644     char ifname [33];

   645     struct localinterface *lif=0;

   646     int index, x1, x2, x3;

   647     unsigned int u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,ua,ub,uc,ud,ue,uf;

   648 

   649     if ((f = fopen("/proc/net/if_inet6", "r")) == NULL) {

   650         return ;

   651     }

   652     while (fscanf (f, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x "

   653                 "%d %x %x %x %32s",&u0,&u1,&u2,&u3,&u4,&u5,&u6,&u7,

   654                 &u8,&u9,&ua,&ub,&uc,&ud,&ue,&uf,

   655                 &index, &x1, &x2, &x3, ifname) == 21) {

   656         staddr[0] = (unsigned char)u0;

   657         staddr[1] = (unsigned char)u1;

   658         staddr[2] = (unsigned char)u2;

   659         staddr[3] = (unsigned char)u3;

   660         staddr[4] = (unsigned char)u4;

   661         staddr[5] = (unsigned char)u5;

   662         staddr[6] = (unsigned char)u6;

   663         staddr[7] = (unsigned char)u7;

   664         staddr[8] = (unsigned char)u8;

   665         staddr[9] = (unsigned char)u9;

   666         staddr[10] = (unsigned char)ua;

   667         staddr[11] = (unsigned char)ub;

   668         staddr[12] = (unsigned char)uc;

   669         staddr[13] = (unsigned char)ud;

   670         staddr[14] = (unsigned char)ue;

   671         staddr[15] = (unsigned char)uf;

   672         nifs ++;

   673         if (nifs > localifsSize) {

   674             localifs = (struct localinterface *) realloc (

   675                         localifs, sizeof (struct localinterface)* (localifsSize+5));

   676             if (localifs == 0) {

   677                 nifs = 0;

   678                 fclose (f);

   679                 return;

   680             }

   681             lif = localifs + localifsSize;

   682             localifsSize += 5;

   683         } else {

   684             lif ++;

   685         }

   686         memcpy (lif->localaddr, staddr, 16);

   687         lif->index = index;

   688     }

   689     fclose (f);

   690 }

   691 

   692 /* return the scope_id (interface index) of the

   693  * interface corresponding to the given address

   694  * returns 0 if no match found

   695  */

   696 

   697 static int getLocalScopeID (char *addr) {

   698     struct localinterface *lif;

   699     int i;

   700     if (localifs == 0) {

   701         initLocalIfs();

   702     }

   703     for (i=0, lif=localifs; i<nifs; i++, lif++) {

   704         if (memcmp (addr, lif->localaddr, 16) == 0) {

   705             return lif->index;

   706         }

   707     }

   708     return 0;

   709 }

   710 

   711 void platformInit () {

   712     initLoopbackRoutes();

   713     initLocalIfs();

   714 }

   715 

   716 #elif defined(_AIX)

   717 

   718 /* Initialize stubs for blocking I/O workarounds (see src/solaris/native/java/net/linux_close.c) */

   719 extern void aix_close_init();

   720 

   721 void platformInit () {

   722     aix_close_init();

   723 }

   724 

   725 #else

   726 

   727 void platformInit () {}

   728 

   729 #endif

   730 

   731 void parseExclusiveBindProperty(JNIEnv *env) {

   732 #ifdef __solaris__

   733     jstring s, flagSet;

   734     jclass iCls;

   735     jmethodID mid;

   736 

   737     s = (*env)->NewStringUTF(env, "sun.net.useExclusiveBind");

   738     CHECK_NULL(s);

   739     iCls = (*env)->FindClass(env, "java/lang/System");

   740     CHECK_NULL(iCls);

   741     mid = (*env)->GetStaticMethodID(env, iCls, "getProperty",

   742                 "(Ljava/lang/String;)Ljava/lang/String;");

   743     CHECK_NULL(mid);

   744     flagSet = (*env)->CallStaticObjectMethod(env, iCls, mid, s);

   745     if (flagSet != NULL) {

   746         useExclBind = 1;

   747     }

   748 #endif

   749 }

   750 

   751 JNIEXPORT jint JNICALL

   752 NET_EnableFastTcpLoopback(int fd) {

   753     return 0;

   754 }

   755 

   756 /**

   757  * See net_util.h for documentation

   758  */

   759 JNIEXPORT int JNICALL

   760 NET_InetAddressToSockaddr(JNIEnv *env, jobject iaObj, int port,

   761                           SOCKETADDRESS *sa, int *len,

   762                           jboolean v4MappedAddress)

   763 {

   764     jint family = getInetAddress_family(env, iaObj);

   765     memset((char *)sa, 0, sizeof(SOCKETADDRESS));

   766 

   767     if (ipv6_available() &&

   768         !(family == java_net_InetAddress_IPv4 &&

   769           v4MappedAddress == JNI_FALSE))

   770     {

   771         jbyte caddr[16];

   772         jint address;

   773 

   774         if (family == java_net_InetAddress_IPv4) {

   775             // convert to IPv4-mapped address

   776             memset((char *)caddr, 0, 16);

   777             address = getInetAddress_addr(env, iaObj);

   778             if (address == INADDR_ANY) {

   779                 /* we would always prefer IPv6 wildcard address

   780                  * caddr[10] = 0xff;

   781                  * caddr[11] = 0xff; */

   782             } else {

   783                 caddr[10] = 0xff;

   784                 caddr[11] = 0xff;

   785                 caddr[12] = ((address >> 24) & 0xff);

   786                 caddr[13] = ((address >> 16) & 0xff);

   787                 caddr[14] = ((address >> 8) & 0xff);

   788                 caddr[15] = (address & 0xff);

   789             }

   790         } else {

   791             getInet6Address_ipaddress(env, iaObj, (char *)caddr);

   792         }

   793         sa->sa6.sin6_port = htons(port);

   794         memcpy((void *)&sa->sa6.sin6_addr, caddr, sizeof(struct in6_addr));

   795         sa->sa6.sin6_family = AF_INET6;

   796         if (len != NULL) {

   797             *len = sizeof(struct sockaddr_in6);

   798         }

   799 

   800 #ifdef __linux__

   801         /*

   802          * On Linux if we are connecting to a link-local address

   803          * we need to specify the interface in the scope_id (2.4 kernel only)

   804          *

   805          * If the scope was cached then we use the cached value. If not cached but

   806          * specified in the Inet6Address we use that, but we first check if the

   807          * address needs to be routed via the loopback interface. In this case,

   808          * we override the specified value with that of the loopback interface.

   809          * If no cached value exists and no value was specified by user, then

   810          * we try to determine a value from the routing table. In all these

   811          * cases the used value is cached for further use.

   812          */

   813         if (IN6_IS_ADDR_LINKLOCAL(&sa->sa6.sin6_addr)) {

   814             unsigned int cached_scope_id = 0, scope_id = 0;

   815 

   816             if (ia6_cachedscopeidID) {

   817                 cached_scope_id = (int)(*env)->GetIntField(env, iaObj, ia6_cachedscopeidID);

   818                 /* if cached value exists then use it. Otherwise, check

   819                  * if scope is set in the address.

   820                  */

   821                 if (!cached_scope_id) {

   822                     if (ia6_scopeidID) {

   823                         scope_id = getInet6Address_scopeid(env, iaObj);

   824                     }

   825                     if (scope_id != 0) {

   826                         /* check user-specified value for loopback case

   827                          * that needs to be overridden

   828                          */

   829                         if (kernelIsV24() && needsLoopbackRoute(&sa->sa6.sin6_addr)) {

   830                             cached_scope_id = lo_scope_id;

   831                             (*env)->SetIntField(env, iaObj, ia6_cachedscopeidID, cached_scope_id);

   832                         }

   833                     } else {

   834                         /*

   835                          * Otherwise consult the IPv6 routing tables to

   836                          * try determine the appropriate interface.

   837                          */

   838                         if (kernelIsV24()) {

   839                             cached_scope_id = getDefaultIPv6Interface(&sa->sa6.sin6_addr);

   840                         } else {

   841                             cached_scope_id = getLocalScopeID((char *)&(sa->sa6.sin6_addr));

   842                             if (cached_scope_id == 0) {

   843                                 cached_scope_id = getDefaultIPv6Interface(&sa->sa6.sin6_addr);

   844                             }

   845                         }

   846                         (*env)->SetIntField(env, iaObj, ia6_cachedscopeidID, cached_scope_id);

   847                     }

   848                 }

   849             }

   850 

   851             /*

   852              * If we have a scope_id use the extended form

   853              * of sockaddr_in6.

   854              */

   855             sa->sa6.sin6_scope_id = cached_scope_id == 0 ? scope_id : cached_scope_id;

   856         }

   857 #else

   858         /* handle scope_id */

   859         if (family != java_net_InetAddress_IPv4) {

   860             if (ia6_scopeidID) {

   861                 sa->sa6.sin6_scope_id = getInet6Address_scopeid(env, iaObj);

   862             }

   863         }

   864 #endif

   865     } else {

   866         jint address;

   867         if (family != java_net_InetAddress_IPv4) {

   868             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Protocol family unavailable");

   869             return -1;

   870         }

   871         address = getInetAddress_addr(env, iaObj);

   872         sa->sa4.sin_port = htons(port);

   873         sa->sa4.sin_addr.s_addr = htonl(address);

   874         sa->sa4.sin_family = AF_INET;

   875         if (len != NULL) {

   876             *len = sizeof(struct sockaddr_in);

   877         }

   878     }

   879     return 0;

   880 }

   881 

   882 void

   883 NET_SetTrafficClass(SOCKETADDRESS *sa, int trafficClass) {

   884     if (sa->sa.sa_family == AF_INET6) {

   885         sa->sa6.sin6_flowinfo = htonl((trafficClass & 0xff) << 20);

   886     }

   887 }

   888 

   889 int

   890 NET_IsIPv4Mapped(jbyte* caddr) {

   891     int i;

   892     for (i = 0; i < 10; i++) {

   893         if (caddr[i] != 0x00) {

   894             return 0; /* false */

   895         }

   896     }

   897 

   898     if (((caddr[10] & 0xff) == 0xff) && ((caddr[11] & 0xff) == 0xff)) {

   899         return 1; /* true */

   900     }

   901     return 0; /* false */

   902 }

   903 

   904 int

   905 NET_IPv4MappedToIPv4(jbyte* caddr) {

   906     return ((caddr[12] & 0xff) << 24) | ((caddr[13] & 0xff) << 16) | ((caddr[14] & 0xff) << 8)

   907         | (caddr[15] & 0xff);

   908 }

   909 

   910 int

   911 NET_IsEqual(jbyte* caddr1, jbyte* caddr2) {

   912     int i;

   913     for (i = 0; i < 16; i++) {

   914         if (caddr1[i] != caddr2[i]) {

   915             return 0; /* false */

   916         }

   917     }

   918     return 1;

   919 }

   920 

   921 int NET_IsZeroAddr(jbyte* caddr) {

   922     int i;

   923     for (i = 0; i < 16; i++) {

   924         if (caddr[i] != 0) {

   925             return 0;

   926         }

   927     }

   928     return 1;

   929 }

   930 

   931 /*

   932  * Map the Java level socket option to the platform specific

   933  * level and option name.

   934  */

   935 int

   936 NET_MapSocketOption(jint cmd, int *level, int *optname) {

   937     static struct {

   938         jint cmd;

   939         int level;

   940         int optname;

   941     } const opts[] = {

   942         { java_net_SocketOptions_TCP_NODELAY,           IPPROTO_TCP,    TCP_NODELAY },

   943         { java_net_SocketOptions_SO_OOBINLINE,          SOL_SOCKET,     SO_OOBINLINE },

   944         { java_net_SocketOptions_SO_LINGER,             SOL_SOCKET,     SO_LINGER },

   945         { java_net_SocketOptions_SO_SNDBUF,             SOL_SOCKET,     SO_SNDBUF },

   946         { java_net_SocketOptions_SO_RCVBUF,             SOL_SOCKET,     SO_RCVBUF },

   947         { java_net_SocketOptions_SO_KEEPALIVE,          SOL_SOCKET,     SO_KEEPALIVE },

   948         { java_net_SocketOptions_SO_REUSEADDR,          SOL_SOCKET,     SO_REUSEADDR },

   949         { java_net_SocketOptions_SO_REUSEPORT,          SOL_SOCKET,     SO_REUSEPORT },

   950         { java_net_SocketOptions_SO_BROADCAST,          SOL_SOCKET,     SO_BROADCAST },

   951         { java_net_SocketOptions_IP_TOS,                IPPROTO_IP,     IP_TOS },

   952         { java_net_SocketOptions_IP_MULTICAST_IF,       IPPROTO_IP,     IP_MULTICAST_IF },

   953         { java_net_SocketOptions_IP_MULTICAST_IF2,      IPPROTO_IP,     IP_MULTICAST_IF },

   954         { java_net_SocketOptions_IP_MULTICAST_LOOP,     IPPROTO_IP,     IP_MULTICAST_LOOP },

   955     };

   956 

   957     int i;

   958 

   959     if (ipv6_available()) {

   960         switch (cmd) {

   961             // Different multicast options if IPv6 is enabled

   962             case java_net_SocketOptions_IP_MULTICAST_IF:

   963             case java_net_SocketOptions_IP_MULTICAST_IF2:

   964                 *level = IPPROTO_IPV6;

   965                 *optname = IPV6_MULTICAST_IF;

   966                 return 0;

   967 

   968             case java_net_SocketOptions_IP_MULTICAST_LOOP:

   969                 *level = IPPROTO_IPV6;

   970                 *optname = IPV6_MULTICAST_LOOP;

   971                 return 0;

   972 #if (defined(__solaris__) || defined(MACOSX))

   973             // Map IP_TOS request to IPV6_TCLASS

   974             case java_net_SocketOptions_IP_TOS:

   975                 *level = IPPROTO_IPV6;

   976                 *optname = IPV6_TCLASS;

   977                 return 0;

   978 #endif

   979         }

   980     }

   981 

   982     /*

   983      * Map the Java level option to the native level

   984      */

   985     for (i=0; i<(int)(sizeof(opts) / sizeof(opts[0])); i++) {

   986         if (cmd == opts[i].cmd) {

   987             *level = opts[i].level;

   988             *optname = opts[i].optname;

   989             return 0;

   990         }

   991     }

   992 

   993     /* not found */

   994     return -1;

   995 }

   996 

   997 /*

   998  * Determine the default interface for an IPv6 address.

   999  *

  1000  * 1. Scans /proc/net/ipv6_route for a matching route

  1001  *    (eg: fe80::/10 or a route for the specific address).

  1002  *    This will tell us the interface to use (eg: "eth0").

  1003  *

  1004  * 2. Lookup /proc/net/if_inet6 to map the interface

  1005  *    name to an interface index.

  1006  *

  1007  * Returns :-

  1008  *      -1 if error

  1009  *       0 if no matching interface

  1010  *      >1 interface index to use for the link-local address.

  1011  */

  1012 #if defined(__linux__)

  1013 int getDefaultIPv6Interface(struct in6_addr *target_addr) {

  1014     FILE *f;

  1015     char srcp[8][5];

  1016     char hopp[8][5];

  1017     int dest_plen, src_plen, use, refcnt, metric;

  1018     unsigned long flags;

  1019     char dest_str[40];

  1020     struct in6_addr dest_addr;

  1021     char device[16];

  1022     jboolean match = JNI_FALSE;

  1023 

  1024     /*

  1025      * Scan /proc/net/ipv6_route looking for a matching

  1026      * route.

  1027      */

  1028     if ((f = fopen("/proc/net/ipv6_route", "r")) == NULL) {

  1029         return -1;

  1030     }

  1031     while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

  1032                      "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

  1033                      "%4s%4s%4s%4s%4s%4s%4s%4s "

  1034                      "%08x %08x %08x %08lx %8s",

  1035                      dest_str, &dest_str[5], &dest_str[10], &dest_str[15],

  1036                      &dest_str[20], &dest_str[25], &dest_str[30], &dest_str[35],

  1037                      &dest_plen,

  1038                      srcp[0], srcp[1], srcp[2], srcp[3],

  1039                      srcp[4], srcp[5], srcp[6], srcp[7],

  1040                      &src_plen,

  1041                      hopp[0], hopp[1], hopp[2], hopp[3],

  1042                      hopp[4], hopp[5], hopp[6], hopp[7],

  1043                      &metric, &use, &refcnt, &flags, device) == 31) {

  1044 

  1045         /*

  1046          * Some routes should be ignored

  1047          */

  1048         if ( (dest_plen < 0 || dest_plen > 128)  ||

  1049              (src_plen != 0) ||

  1050              (flags & (RTF_POLICY | RTF_FLOW)) ||

  1051              ((flags & RTF_REJECT) && dest_plen == 0) ) {

  1052             continue;

  1053         }

  1054 

  1055         /*

  1056          * Convert the destination address

  1057          */

  1058         dest_str[4] = ':';

  1059         dest_str[9] = ':';

  1060         dest_str[14] = ':';

  1061         dest_str[19] = ':';

  1062         dest_str[24] = ':';

  1063         dest_str[29] = ':';

  1064         dest_str[34] = ':';

  1065         dest_str[39] = '\0';

  1066 

  1067         if (inet_pton(AF_INET6, dest_str, &dest_addr) < 0) {

  1068             /* not an Ipv6 address */

  1069             continue;

  1070         } else {

  1071             /*

  1072              * The prefix len (dest_plen) indicates the number of bits we

  1073              * need to match on.

  1074              *

  1075              * dest_plen / 8    => number of bytes to match

  1076              * dest_plen % 8    => number of additional bits to match

  1077              *

  1078              * eg: fe80::/10 => match 1 byte + 2 additional bits in the

  1079              *                  the next byte.

  1080              */

  1081             int byte_count = dest_plen >> 3;

  1082             int extra_bits = dest_plen & 0x3;

  1083 

  1084             if (byte_count > 0) {

  1085                 if (memcmp(target_addr, &dest_addr, byte_count)) {

  1086                     continue;  /* no match */

  1087                 }

  1088             }

  1089 

  1090             if (extra_bits > 0) {

  1091                 unsigned char c1 = ((unsigned char *)target_addr)[byte_count];

  1092                 unsigned char c2 = ((unsigned char *)&dest_addr)[byte_count];

  1093                 unsigned char mask = 0xff << (8 - extra_bits);

  1094                 if ((c1 & mask) != (c2 & mask)) {

  1095                     continue;

  1096                 }

  1097             }

  1098 

  1099             /*

  1100              * We have a match

  1101              */

  1102             match = JNI_TRUE;

  1103             break;

  1104         }

  1105     }

  1106     fclose(f);

  1107 

  1108     /*

  1109      * If there's a match then we lookup the interface

  1110      * index.

  1111      */

  1112     if (match) {

  1113         char devname[21];

  1114         char addr6p[8][5];

  1115         int plen, scope, dad_status, if_idx;

  1116 

  1117         if ((f = fopen("/proc/net/if_inet6", "r")) != NULL) {

  1118             while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %08x %02x %02x %02x %20s\n",

  1119                       addr6p[0], addr6p[1], addr6p[2], addr6p[3],

  1120                       addr6p[4], addr6p[5], addr6p[6], addr6p[7],

  1121                   &if_idx, &plen, &scope, &dad_status, devname) == 13) {

  1122 

  1123                 if (strcmp(devname, device) == 0) {

  1124                     /*

  1125                      * Found - so just return the index

  1126                      */

  1127                     fclose(f);

  1128                     return if_idx;

  1129                 }

  1130             }

  1131             fclose(f);

  1132         } else {

  1133             /*

  1134              * Couldn't open /proc/net/if_inet6