1 /*
   2  * Copyright (c) 1997, 2010, 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 #include <errno.h>
  27 #include <string.h>
  28 #include <sys/types.h>
  29 #include <sys/socket.h>
  30 #include <netinet/tcp.h>        /* Defines TCP_NODELAY, needed for 2.6 */
  31 #include <netinet/in.h>
  32 #include <net/if.h>
  33 #include <netdb.h>
  34 #include <stdlib.h>
  35 #include <dlfcn.h>
  36 #include <values.h>
  37 
  38 #ifdef __solaris__
  39 #include <sys/sockio.h>
  40 #include <stropts.h>
  41 #include <inet/nd.h>
  42 #endif
  43 
  44 #ifdef __linux__
  45 #include <arpa/inet.h>
  46 #include <net/route.h>
  47 #include <sys/utsname.h>
  48 
  49 #ifndef IPV6_FLOWINFO_SEND
  50 #define IPV6_FLOWINFO_SEND      33
  51 #endif
  52 
  53 #endif
  54 
  55 #include "jni_util.h"
  56 #include "jvm.h"
  57 #include "net_util.h"
  58 
  59 #include "java_net_SocketOptions.h"
  60 
  61 /* needed from libsocket on Solaris 8 */
  62 
  63 getaddrinfo_f getaddrinfo_ptr = NULL;
  64 freeaddrinfo_f freeaddrinfo_ptr = NULL;
  65 gai_strerror_f gai_strerror_ptr = NULL;
  66 getnameinfo_f getnameinfo_ptr = NULL;
  67 
  68 /*
  69  * EXCLBIND socket options only on Solaris 8 & 9.
  70  */
  71 #if defined(__solaris__) && !defined(TCP_EXCLBIND)
  72 #define TCP_EXCLBIND            0x21
  73 #endif
  74 #if defined(__solaris__) && !defined(UDP_EXCLBIND)
  75 #define UDP_EXCLBIND            0x0101
  76 #endif
  77 
  78 #ifdef __solaris__
  79 static int init_tcp_max_buf, init_udp_max_buf;
  80 static int tcp_max_buf;
  81 static int udp_max_buf;
  82 
  83 /*
  84  * Get the specified parameter from the specified driver. The value
  85  * of the parameter is assumed to be an 'int'. If the parameter
  86  * cannot be obtained return -1
  87  */
  88 static int
  89 getParam(char *driver, char *param)
  90 {
  91     struct strioctl stri;
  92     char buf [64];
  93     int s;
  94     int value;
  95 
  96     s = open (driver, O_RDWR);
  97     if (s < 0) {
  98         return -1;
  99     }
 100     strncpy (buf, param, sizeof(buf));
 101     stri.ic_cmd = ND_GET;
 102     stri.ic_timout = 0;
 103     stri.ic_dp = buf;
 104     stri.ic_len = sizeof(buf);
 105     if (ioctl (s, I_STR, &stri) < 0) {
 106         value = -1;
 107     } else {
 108         value = atoi(buf);
 109     }
 110     close (s);
 111     return value;
 112 }
 113 
 114 /*
 115  * Iterative way to find the max value that SO_SNDBUF or SO_RCVBUF
 116  * for Solaris versions that do not support the ioctl() in getParam().
 117  * Ugly, but only called once (for each sotype).
 118  *
 119  * As an optimisation, we make a guess using the default values for Solaris
 120  * assuming they haven't been modified with ndd.
 121  */
 122 
 123 #define MAX_TCP_GUESS 1024 * 1024
 124 #define MAX_UDP_GUESS 2 * 1024 * 1024
 125 
 126 #define FAIL_IF_NOT_ENOBUFS if (errno != ENOBUFS) return -1
 127 
 128 static int findMaxBuf(int fd, int opt, int sotype) {
 129     int a = 0;
 130     int b = MAXINT;
 131     int initial_guess;
 132     int limit = -1;
 133 
 134     if (sotype == SOCK_DGRAM) {
 135         initial_guess = MAX_UDP_GUESS;
 136     } else {
 137         initial_guess = MAX_TCP_GUESS;
 138     }
 139 
 140     if (setsockopt(fd, SOL_SOCKET, opt, &initial_guess, sizeof(int)) == 0) {
 141         initial_guess++;
 142         if (setsockopt(fd, SOL_SOCKET, opt, &initial_guess,sizeof(int)) < 0) {
 143             FAIL_IF_NOT_ENOBUFS;
 144             return initial_guess - 1;
 145         }
 146         a = initial_guess;
 147     } else {
 148         FAIL_IF_NOT_ENOBUFS;
 149         b = initial_guess - 1;
 150     }
 151     do {
 152         int mid = a + (b-a)/2;
 153         if (setsockopt(fd, SOL_SOCKET, opt, &mid, sizeof(int)) == 0) {
 154             limit = mid;
 155             a = mid + 1;
 156         } else {
 157             FAIL_IF_NOT_ENOBUFS;
 158             b = mid - 1;
 159         }
 160     } while (b >= a);
 161 
 162     return limit;
 163 }
 164 #endif
 165 
 166 #ifdef __linux__
 167 static int kernelV22 = 0;
 168 static int vinit = 0;
 169 
 170 int kernelIsV22 () {
 171     if (!vinit) {
 172         struct utsname sysinfo;
 173         if (uname(&sysinfo) == 0) {
 174             sysinfo.release[3] = '\0';
 175             if (strcmp(sysinfo.release, "2.2") == 0) {
 176                 kernelV22 = JNI_TRUE;
 177             }
 178         }
 179         vinit = 1;
 180     }
 181     return kernelV22;
 182 }
 183 
 184 static int kernelV24 = 0;
 185 static int vinit24 = 0;
 186 
 187 int kernelIsV24 () {
 188     if (!vinit24) {
 189         struct utsname sysinfo;
 190         if (uname(&sysinfo) == 0) {
 191             sysinfo.release[3] = '\0';
 192             if (strcmp(sysinfo.release, "2.4") == 0) {
 193                 kernelV24 = JNI_TRUE;
 194             }
 195         }
 196         vinit24 = 1;
 197     }
 198     return kernelV24;
 199 }
 200 
 201 int getScopeID (struct sockaddr *him) {
 202     struct sockaddr_in6 *hext = (struct sockaddr_in6 *)him;
 203     if (kernelIsV22()) {
 204         return 0;
 205     }
 206     return hext->sin6_scope_id;
 207 }
 208 
 209 int cmpScopeID (unsigned int scope, struct sockaddr *him) {
 210     struct sockaddr_in6 *hext = (struct sockaddr_in6 *)him;
 211     if (kernelIsV22()) {
 212         return 1;       /* scope is ignored for comparison in 2.2 kernel */
 213     }
 214     return hext->sin6_scope_id == scope;
 215 }
 216 
 217 #else
 218 
 219 int getScopeID (struct sockaddr *him) {
 220     struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)him;
 221     return him6->sin6_scope_id;
 222 }
 223 
 224 int cmpScopeID (unsigned int scope, struct sockaddr *him) {
 225     struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)him;
 226     return him6->sin6_scope_id == scope;
 227 }
 228 
 229 #endif
 230 
 231 
 232 void
 233 NET_ThrowByNameWithLastError(JNIEnv *env, const char *name,
 234                    const char *defaultDetail) {
 235     char errmsg[255];
 236     sprintf(errmsg, "errno: %d, error: %s\n", errno, defaultDetail);
 237     JNU_ThrowByNameWithLastError(env, name, errmsg);
 238 }
 239 
 240 void
 241 NET_ThrowCurrent(JNIEnv *env, char *msg) {
 242     NET_ThrowNew(env, errno, msg);
 243 }
 244 
 245 void
 246 NET_ThrowNew(JNIEnv *env, int errorNumber, char *msg) {
 247     char fullMsg[512];
 248     if (!msg) {
 249         msg = "no further information";
 250     }
 251     switch(errorNumber) {
 252     case EBADF:
 253         jio_snprintf(fullMsg, sizeof(fullMsg), "socket closed: %s", msg);
 254         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", fullMsg);
 255         break;
 256     case EINTR:
 257         JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException", msg);
 258         break;
 259     default:
 260         errno = errorNumber;
 261         JNU_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", msg);
 262         break;
 263     }
 264 }
 265 
 266 
 267 jfieldID
 268 NET_GetFileDescriptorID(JNIEnv *env)
 269 {
 270     jclass cls = (*env)->FindClass(env, "java/io/FileDescriptor");
 271     CHECK_NULL_RETURN(cls, NULL);
 272     return (*env)->GetFieldID(env, cls, "fd", "I");
 273 }
 274 
 275 jint  IPv6_supported()
 276 {
 277 #ifndef AF_INET6
 278     return JNI_FALSE;
 279 #endif
 280 
 281 #ifdef AF_INET6
 282     int fd;
 283     void *ipv6_fn;
 284     SOCKADDR sa;
 285     socklen_t sa_len = sizeof(sa);
 286 
 287     fd = JVM_Socket(AF_INET6, SOCK_STREAM, 0) ;
 288     if (fd < 0) {
 289         /*
 290          *  TODO: We really cant tell since it may be an unrelated error
 291          *  for now we will assume that AF_INET6 is not available
 292          */
 293         return JNI_FALSE;
 294     }
 295 
 296     /*
 297      * If fd 0 is a socket it means we've been launched from inetd or
 298      * xinetd. If it's a socket then check the family - if it's an
 299      * IPv4 socket then we need to disable IPv6.
 300      */
 301     if (getsockname(0, (struct sockaddr *)&sa, &sa_len) == 0) {
 302         struct sockaddr *saP = (struct sockaddr *)&sa;
 303         if (saP->sa_family != AF_INET6) {
 304             return JNI_FALSE;
 305         }
 306     }
 307 
 308     /**
 309      * Linux - check if any interface has an IPv6 address.
 310      * Don't need to parse the line - we just need an indication.
 311      */
 312 #ifdef __linux__
 313     {
 314         FILE *fP = fopen("/proc/net/if_inet6", "r");
 315         char buf[255];
 316         char *bufP;
 317 
 318         if (fP == NULL) {
 319             close(fd);
 320             return JNI_FALSE;
 321         }
 322         bufP = fgets(buf, sizeof(buf), fP);
 323         fclose(fP);
 324         if (bufP == NULL) {
 325             close(fd);
 326             return JNI_FALSE;
 327         }
 328     }
 329 #endif
 330 
 331     /**
 332      * On Solaris 8 it's possible to create INET6 sockets even
 333      * though IPv6 is not enabled on all interfaces. Thus we
 334      * query the number of IPv6 addresses to verify that IPv6
 335      * has been configured on at least one interface.
 336      *
 337      * On Linux it doesn't matter - if IPv6 is built-in the
 338      * kernel then IPv6 addresses will be bound automatically
 339      * to all interfaces.
 340      */
 341 #ifdef __solaris__
 342 
 343 #ifdef SIOCGLIFNUM
 344     {
 345         struct lifnum numifs;
 346 
 347         numifs.lifn_family = AF_INET6;
 348         numifs.lifn_flags = 0;
 349         if (ioctl(fd, SIOCGLIFNUM, (char *)&numifs) < 0) {
 350             /**
 351              * SIOCGLIFNUM failed - assume IPv6 not configured
 352              */
 353             close(fd);
 354             return JNI_FALSE;
 355         }
 356         /**
 357          * If no IPv6 addresses then return false. If count > 0
 358          * it's possible that all IPv6 addresses are "down" but
 359          * that's okay as they may be brought "up" while the
 360          * VM is running.
 361          */
 362         if (numifs.lifn_count == 0) {
 363             close(fd);
 364             return JNI_FALSE;
 365         }
 366     }
 367 #else
 368     /* SIOCGLIFNUM not defined in build environment ??? */
 369     close(fd);
 370     return JNI_FALSE;
 371 #endif
 372 
 373 #endif /* __solaris */
 374 
 375     /*
 376      *  OK we may have the stack available in the kernel,
 377      *  we should also check if the APIs are available.
 378      */
 379     ipv6_fn = JVM_FindLibraryEntry(RTLD_DEFAULT, "inet_pton");
 380     if (ipv6_fn == NULL ) {
 381         close(fd);
 382         return JNI_FALSE;
 383     }
 384 
 385     /*
 386      * We've got the library, let's get the pointers to some
 387      * IPV6 specific functions. We have to do that because, at least
 388      * on Solaris we may build on a system without IPV6 networking
 389      * libraries, therefore we can't have a hard link to these
 390      * functions.
 391      */
 392     getaddrinfo_ptr = (getaddrinfo_f)
 393         JVM_FindLibraryEntry(RTLD_DEFAULT, "getaddrinfo");
 394 
 395     freeaddrinfo_ptr = (freeaddrinfo_f)
 396         JVM_FindLibraryEntry(RTLD_DEFAULT, "freeaddrinfo");
 397 
 398     gai_strerror_ptr = (gai_strerror_f)
 399         JVM_FindLibraryEntry(RTLD_DEFAULT, "gai_strerror");
 400 
 401     getnameinfo_ptr = (getnameinfo_f)
 402         JVM_FindLibraryEntry(RTLD_DEFAULT, "getnameinfo");
 403 
 404     if (freeaddrinfo_ptr == NULL || getnameinfo_ptr == NULL) {
 405         /* We need all 3 of them */
 406         getaddrinfo_ptr = NULL;
 407     }
 408 
 409     close(fd);
 410     return JNI_TRUE;
 411 #endif /* AF_INET6 */
 412 }
 413 
 414 void ThrowUnknownHostExceptionWithGaiError(JNIEnv *env,
 415                                            const char* hostname,
 416                                            int gai_error)
 417 {
 418     int size;
 419     char *buf;
 420     const char *format = "%s: %s";
 421     const char *error_string =
 422         (gai_strerror_ptr == NULL) ? NULL : (*gai_strerror_ptr)(gai_error);
 423     if (error_string == NULL)
 424         error_string = "unknown error";
 425 
 426     size = strlen(format) + strlen(hostname) + strlen(error_string) + 2;
 427     buf = (char *) malloc(size);
 428     if (buf) {
 429         jstring s;
 430         sprintf(buf, format, hostname, error_string);
 431         s = JNU_NewStringPlatform(env, buf);
 432         if (s != NULL) {
 433             jobject x = JNU_NewObjectByName(env,
 434                                             "java/net/UnknownHostException",
 435                                             "(Ljava/lang/String;)V", s);
 436             if (x != NULL)
 437                 (*env)->Throw(env, x);
 438         }
 439         free(buf);
 440     }
 441 }
 442 
 443 void
 444 NET_AllocSockaddr(struct sockaddr **him, int *len) {
 445 #ifdef AF_INET6
 446     if (ipv6_available()) {
 447         struct sockaddr_in6 *him6 = (struct sockaddr_in6*)malloc(sizeof(struct sockaddr_in6));
 448         *him = (struct sockaddr*)him6;
 449         *len = sizeof(struct sockaddr_in6);
 450     } else
 451 #endif /* AF_INET6 */
 452         {
 453             struct sockaddr_in *him4 = (struct sockaddr_in*)malloc(sizeof(struct sockaddr_in));
 454             *him = (struct sockaddr*)him4;
 455             *len = sizeof(struct sockaddr_in);
 456         }
 457 }
 458 
 459 #if defined(__linux__) && defined(AF_INET6)
 460 
 461 
 462 /* following code creates a list of addresses from the kernel
 463  * routing table that are routed via the loopback address.
 464  * We check all destination addresses against this table
 465  * and override the scope_id field to use the relevant value for "lo"
 466  * in order to work-around the Linux bug that prevents packets destined
 467  * for certain local addresses from being sent via a physical interface.
 468  */
 469 
 470 struct loopback_route {
 471     struct in6_addr addr; /* destination address */
 472     int plen; /* prefix length */
 473 };
 474 
 475 static struct loopback_route *loRoutes = 0;
 476 static int nRoutes = 0; /* number of routes */
 477 static int loRoutes_size = 16; /* initial size */
 478 static int lo_scope_id = 0;
 479 
 480 static void initLoopbackRoutes();
 481 
 482 void printAddr (struct in6_addr *addr) {
 483     int i;
 484     for (i=0; i<16; i++) {
 485         printf ("%02x", addr->s6_addr[i]);
 486     }
 487     printf ("\n");
 488 }
 489 
 490 static jboolean needsLoopbackRoute (struct in6_addr* dest_addr) {
 491     int byte_count;
 492     int extra_bits, i;
 493     struct loopback_route *ptr;
 494 
 495     if (loRoutes == 0) {
 496         initLoopbackRoutes();
 497     }
 498 
 499     for (ptr = loRoutes, i=0; i<nRoutes; i++, ptr++) {
 500         struct in6_addr *target_addr=&ptr->addr;
 501         int dest_plen = ptr->plen;
 502         byte_count = dest_plen >> 3;
 503         extra_bits = dest_plen & 0x3;
 504 
 505         if (byte_count > 0) {
 506             if (memcmp(target_addr, dest_addr, byte_count)) {
 507                 continue;  /* no match */
 508             }
 509         }
 510 
 511         if (extra_bits > 0) {
 512             unsigned char c1 = ((unsigned char *)target_addr)[byte_count];
 513             unsigned char c2 = ((unsigned char *)&dest_addr)[byte_count];
 514             unsigned char mask = 0xff << (8 - extra_bits);
 515             if ((c1 & mask) != (c2 & mask)) {
 516                 continue;
 517             }
 518         }
 519         return JNI_TRUE;
 520     }
 521     return JNI_FALSE;
 522 }
 523 
 524 
 525 static void initLoopbackRoutes() {
 526     FILE *f;
 527     char srcp[8][5];
 528     char hopp[8][5];
 529     int dest_plen, src_plen, use, refcnt, metric;
 530     unsigned long flags;
 531     char dest_str[40];
 532     struct in6_addr dest_addr;
 533     char device[16];
 534 
 535     if (loRoutes != 0) {
 536         free (loRoutes);
 537     }
 538     loRoutes = calloc (loRoutes_size, sizeof(struct loopback_route));
 539     if (loRoutes == 0) {
 540         return;
 541     }
 542     /*
 543      * Scan /proc/net/ipv6_route looking for a matching
 544      * route.
 545      */
 546     if ((f = fopen("/proc/net/ipv6_route", "r")) == NULL) {
 547         return ;
 548     }
 549     while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x "
 550                      "%4s%4s%4s%4s%4s%4s%4s%4s %02x "
 551                      "%4s%4s%4s%4s%4s%4s%4s%4s "
 552                      "%08x %08x %08x %08lx %8s",
 553                      dest_str, &dest_str[5], &dest_str[10], &dest_str[15],
 554                      &dest_str[20], &dest_str[25], &dest_str[30], &dest_str[35],
 555                      &dest_plen,
 556                      srcp[0], srcp[1], srcp[2], srcp[3],
 557                      srcp[4], srcp[5], srcp[6], srcp[7],
 558                      &src_plen,
 559                      hopp[0], hopp[1], hopp[2], hopp[3],
 560                      hopp[4], hopp[5], hopp[6], hopp[7],
 561                      &metric, &use, &refcnt, &flags, device) == 31) {
 562 
 563         /*
 564          * Some routes should be ignored
 565          */
 566         if ( (dest_plen < 0 || dest_plen > 128)  ||
 567              (src_plen != 0) ||
 568              (flags & (RTF_POLICY | RTF_FLOW)) ||
 569              ((flags & RTF_REJECT) && dest_plen == 0) ) {
 570             continue;
 571         }
 572 
 573         /*
 574          * Convert the destination address
 575          */
 576         dest_str[4] = ':';
 577         dest_str[9] = ':';
 578         dest_str[14] = ':';
 579         dest_str[19] = ':';
 580         dest_str[24] = ':';
 581         dest_str[29] = ':';
 582         dest_str[34] = ':';
 583         dest_str[39] = '\0';
 584 
 585         if (inet_pton(AF_INET6, dest_str, &dest_addr) < 0) {
 586             /* not an Ipv6 address */
 587             continue;
 588         }
 589         if (strcmp(device, "lo") != 0) {
 590             /* Not a loopback route */
 591             continue;
 592         } else {
 593             if (nRoutes == loRoutes_size) {
 594                 loRoutes = realloc (loRoutes, loRoutes_size *
 595                                 sizeof (struct loopback_route) * 2);
 596                 if (loRoutes == 0) {
 597                     return ;
 598                 }
 599                 loRoutes_size *= 2;
 600             }
 601             memcpy (&loRoutes[nRoutes].addr,&dest_addr,sizeof(struct in6_addr));
 602             loRoutes[nRoutes].plen = dest_plen;
 603             nRoutes ++;
 604         }
 605     }
 606 
 607     fclose (f);
 608     {
 609         /* now find the scope_id for "lo" */
 610 
 611         char devname[20];
 612         char addr6p[8][5];
 613         int plen, scope, dad_status, if_idx;
 614 
 615         if ((f = fopen("/proc/net/if_inet6", "r")) != NULL) {
 616             while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
 617                       addr6p[0], addr6p[1], addr6p[2], addr6p[3],
 618                       addr6p[4], addr6p[5], addr6p[6], addr6p[7],
 619                   &if_idx, &plen, &scope, &dad_status, devname) == 13) {
 620 
 621                 if (strcmp(devname, "lo") == 0) {
 622                     /*
 623                      * Found - so just return the index
 624                      */
 625                     fclose(f);
 626                     lo_scope_id = if_idx;
 627                     return;
 628                 }
 629             }
 630             fclose(f);
 631         }
 632     }
 633 }
 634 
 635 /*
 636  * Following is used for binding to local addresses. Equivalent
 637  * to code above, for bind().
 638  */
 639 
 640 struct localinterface {
 641     int index;
 642     char localaddr [16];
 643 };
 644 
 645 static struct localinterface *localifs = 0;
 646 static int localifsSize = 0;    /* size of array */
 647 static int nifs = 0;            /* number of entries used in array */
 648 
 649 /* not thread safe: make sure called once from one thread */
 650 
 651 static void initLocalIfs () {
 652     FILE *f;
 653     unsigned char staddr [16];
 654     char ifname [32];
 655     struct localinterface *lif=0;
 656     int index, x1, x2, x3;
 657     unsigned int u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,ua,ub,uc,ud,ue,uf;
 658 
 659     if ((f = fopen("/proc/net/if_inet6", "r")) == NULL) {
 660         return ;
 661     }
 662     while (fscanf (f, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x "
 663                 "%d %x %x %x %s",&u0,&u1,&u2,&u3,&u4,&u5,&u6,&u7,
 664                 &u8,&u9,&ua,&ub,&uc,&ud,&ue,&uf,
 665                 &index, &x1, &x2, &x3, ifname) == 21) {
 666         staddr[0] = (unsigned char)u0;
 667         staddr[1] = (unsigned char)u1;
 668         staddr[2] = (unsigned char)u2;
 669         staddr[3] = (unsigned char)u3;
 670         staddr[4] = (unsigned char)u4;
 671         staddr[5] = (unsigned char)u5;
 672         staddr[6] = (unsigned char)u6;
 673         staddr[7] = (unsigned char)u7;
 674         staddr[8] = (unsigned char)u8;
 675         staddr[9] = (unsigned char)u9;
 676         staddr[10] = (unsigned char)ua;
 677         staddr[11] = (unsigned char)ub;
 678         staddr[12] = (unsigned char)uc;
 679         staddr[13] = (unsigned char)ud;
 680         staddr[14] = (unsigned char)ue;
 681         staddr[15] = (unsigned char)uf;
 682         nifs ++;
 683         if (nifs > localifsSize) {
 684             localifs = (struct localinterface *) realloc (
 685                         localifs, sizeof (struct localinterface)* (localifsSize+5));
 686             if (localifs == 0) {
 687                 nifs = 0;
 688                 fclose (f);
 689                 return;
 690             }
 691             lif = localifs + localifsSize;
 692             localifsSize += 5;
 693         } else {
 694             lif ++;
 695         }
 696         memcpy (lif->localaddr, staddr, 16);
 697         lif->index = index;
 698     }
 699     fclose (f);
 700 }
 701 
 702 /* return the scope_id (interface index) of the
 703  * interface corresponding to the given address
 704  * returns 0 if no match found
 705  */
 706 
 707 static int getLocalScopeID (char *addr) {
 708     struct localinterface *lif;
 709     int i;
 710     if (localifs == 0) {
 711         initLocalIfs();
 712     }
 713     for (i=0, lif=localifs; i<nifs; i++, lif++) {
 714         if (memcmp (addr, lif->localaddr, 16) == 0) {
 715             return lif->index;
 716         }
 717     }
 718     return 0;
 719 }
 720 
 721 void initLocalAddrTable () {
 722     initLoopbackRoutes();
 723     initLocalIfs();
 724 }
 725 
 726 #else
 727 
 728 void initLocalAddrTable () {}
 729 
 730 #endif
 731 
 732 /* In the case of an IPv4 Inetaddress this method will return an
 733  * IPv4 mapped address where IPv6 is available and v4MappedAddress is TRUE.
 734  * Otherwise it will return a sockaddr_in structure for an IPv4 InetAddress.
 735 */
 736 JNIEXPORT int JNICALL
 737 NET_InetAddressToSockaddr(JNIEnv *env, jobject iaObj, int port, struct sockaddr *him,
 738                           int *len, jboolean v4MappedAddress) {
 739     jint family;
 740     family = (*env)->GetIntField(env, iaObj, ia_familyID);
 741 #ifdef AF_INET6
 742     /* needs work. 1. family 2. clean up him6 etc deallocate memory */
 743     if (ipv6_available() && !(family == IPv4 && v4MappedAddress == JNI_FALSE)) {
 744         struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)him;
 745         jbyteArray ipaddress;
 746         jbyte caddr[16];
 747         jint address;
 748 
 749 
 750         if (family == IPv4) { /* will convert to IPv4-mapped address */
 751             memset((char *) caddr, 0, 16);
 752             address = (*env)->GetIntField(env, iaObj, ia_addressID);
 753             if (address == INADDR_ANY) {
 754                 /* we would always prefer IPv6 wildcard address
 755                    caddr[10] = 0xff;
 756                    caddr[11] = 0xff; */
 757             } else {
 758                 caddr[10] = 0xff;
 759                 caddr[11] = 0xff;
 760                 caddr[12] = ((address >> 24) & 0xff);
 761                 caddr[13] = ((address >> 16) & 0xff);
 762                 caddr[14] = ((address >> 8) & 0xff);
 763                 caddr[15] = (address & 0xff);
 764             }
 765         } else {
 766             ipaddress = (*env)->GetObjectField(env, iaObj, ia6_ipaddressID);
 767             (*env)->GetByteArrayRegion(env, ipaddress, 0, 16, caddr);
 768         }
 769         memset((char *)him6, 0, sizeof(struct sockaddr_in6));
 770         him6->sin6_port = htons(port);
 771         memcpy((void *)&(him6->sin6_addr), caddr, sizeof(struct in6_addr) );
 772         him6->sin6_family = AF_INET6;
 773         *len = sizeof(struct sockaddr_in6) ;
 774 
 775         /*
 776          * On Linux if we are connecting to a link-local address
 777          * we need to specify the interface in the scope_id (2.4 kernel only)
 778          *
 779          * If the scope was cached the we use the cached value. If not cached but
 780          * specified in the Inet6Address we use that, but we first check if the
 781          * address needs to be routed via the loopback interface. In this case,
 782          * we override the specified value with that of the loopback interface.
 783          * If no cached value exists and no value was specified by user, then
 784          * we try to determine a value ffrom the routing table. In all these
 785          * cases the used value is cached for further use.
 786          */
 787 #ifdef __linux__
 788         if (IN6_IS_ADDR_LINKLOCAL(&(him6->sin6_addr))) {
 789             int cached_scope_id = 0, scope_id = 0;
 790             int old_kernel = kernelIsV22();
 791 
 792             if (ia6_cachedscopeidID && !old_kernel) {
 793                 cached_scope_id = (int)(*env)->GetIntField(env, iaObj, ia6_cachedscopeidID);
 794                 /* if cached value exists then use it. Otherwise, check
 795                  * if scope is set in the address.
 796                  */
 797                 if (!cached_scope_id) {
 798                     if (ia6_scopeidID) {
 799                         scope_id = (int)(*env)->GetIntField(env,iaObj,ia6_scopeidID);
 800                     }
 801                     if (scope_id != 0) {
 802                         /* check user-specified value for loopback case
 803                          * that needs to be overridden
 804                          */
 805                         if (kernelIsV24() && needsLoopbackRoute (&him6->sin6_addr)) {
 806                             cached_scope_id = lo_scope_id;
 807                             (*env)->SetIntField(env, iaObj, ia6_cachedscopeidID, cached_scope_id);
 808                         }
 809                     } else {
 810                         /*
 811                          * Otherwise consult the IPv6 routing tables to
 812                          * try determine the appropriate interface.
 813                          */
 814                         if (kernelIsV24()) {
 815                             cached_scope_id = getDefaultIPv6Interface( &(him6->sin6_addr) );
 816                         } else {
 817                             cached_scope_id = getLocalScopeID( (char *)&(him6->sin6_addr) );
 818                             if (cached_scope_id == 0) {
 819                                 cached_scope_id = getDefaultIPv6Interface( &(him6->sin6_addr) );
 820                             }
 821                         }
 822                         (*env)->SetIntField(env, iaObj, ia6_cachedscopeidID, cached_scope_id);
 823                     }
 824                 }
 825             }
 826 
 827             /*
 828              * If we have a scope_id use the extended form
 829              * of sockaddr_in6.
 830              */
 831 
 832             if (!old_kernel) {
 833                 struct sockaddr_in6 *him6 =
 834                         (struct sockaddr_in6 *)him;
 835                 him6->sin6_scope_id = cached_scope_id != 0 ?
 836                                             cached_scope_id    : scope_id;
 837                 *len = sizeof(struct sockaddr_in6);
 838             }
 839         }
 840 #else
 841         /* handle scope_id for solaris */
 842 
 843         if (family != IPv4) {
 844             if (ia6_scopeidID) {
 845                 him6->sin6_scope_id = (int)(*env)->GetIntField(env, iaObj, ia6_scopeidID);
 846             }
 847         }
 848 #endif
 849     } else
 850 #endif /* AF_INET6 */
 851         {
 852             struct sockaddr_in *him4 = (struct sockaddr_in*)him;
 853             jint address;
 854             if (family == IPv6) {
 855               JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Protocol family unavailable");
 856               return -1;
 857             }
 858             memset((char *) him4, 0, sizeof(struct sockaddr_in));
 859             address = (*env)->GetIntField(env, iaObj, ia_addressID);
 860             him4->sin_port = htons((short) port);
 861             him4->sin_addr.s_addr = (uint32_t) htonl(address);
 862             him4->sin_family = AF_INET;
 863             *len = sizeof(struct sockaddr_in);
 864         }
 865     return 0;
 866 }
 867 
 868 void
 869 NET_SetTrafficClass(struct sockaddr *him, int trafficClass) {
 870 #ifdef AF_INET6
 871     if (him->sa_family == AF_INET6) {
 872         struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)him;
 873         him6->sin6_flowinfo = htonl((trafficClass & 0xff) << 20);
 874     }
 875 #endif /* AF_INET6 */
 876 }
 877 
 878 JNIEXPORT jint JNICALL
 879 NET_GetPortFromSockaddr(struct sockaddr *him) {
 880 #ifdef AF_INET6
 881     if (him->sa_family == AF_INET6) {
 882         return ntohs(((struct sockaddr_in6*)him)->sin6_port);
 883 
 884         } else
 885 #endif /* AF_INET6 */
 886             {
 887                 return ntohs(((struct sockaddr_in*)him)->sin_port);
 888             }
 889 }
 890 
 891 int
 892 NET_IsIPv4Mapped(jbyte* caddr) {
 893     int i;
 894     for (i = 0; i < 10; i++) {
 895         if (caddr[i] != 0x00) {
 896             return 0; /* false */
 897         }
 898     }
 899 
 900     if (((caddr[10] & 0xff) == 0xff) && ((caddr[11] & 0xff) == 0xff)) {
 901         return 1; /* true */
 902     }
 903     return 0; /* false */
 904 }
 905 
 906 int
 907 NET_IPv4MappedToIPv4(jbyte* caddr) {
 908     return ((caddr[12] & 0xff) << 24) | ((caddr[13] & 0xff) << 16) | ((caddr[14] & 0xff) << 8)
 909         | (caddr[15] & 0xff);
 910 }
 911 
 912 int
 913 NET_IsEqual(jbyte* caddr1, jbyte* caddr2) {
 914     int i;
 915     for (i = 0; i < 16; i++) {
 916         if (caddr1[i] != caddr2[i]) {
 917             return 0; /* false */
 918         }
 919     }
 920     return 1;
 921 }
 922 
 923 jboolean NET_addrtransAvailable() {
 924     return (jboolean)(getaddrinfo_ptr != NULL);
 925 }
 926 
 927 /*
 928  * Map the Java level socket option to the platform specific
 929  * level and option name.
 930  */
 931 int
 932 NET_MapSocketOption(jint cmd, int *level, int *optname) {
 933     static struct {
 934         jint cmd;
 935         int level;
 936         int optname;
 937     } const opts[] = {
 938         { java_net_SocketOptions_TCP_NODELAY,           IPPROTO_TCP,    TCP_NODELAY },
 939         { java_net_SocketOptions_SO_OOBINLINE,          SOL_SOCKET,     SO_OOBINLINE },
 940         { java_net_SocketOptions_SO_LINGER,             SOL_SOCKET,     SO_LINGER },
 941         { java_net_SocketOptions_SO_SNDBUF,             SOL_SOCKET,     SO_SNDBUF },
 942         { java_net_SocketOptions_SO_RCVBUF,             SOL_SOCKET,     SO_RCVBUF },
 943         { java_net_SocketOptions_SO_KEEPALIVE,          SOL_SOCKET,     SO_KEEPALIVE },
 944         { java_net_SocketOptions_SO_REUSEADDR,          SOL_SOCKET,     SO_REUSEADDR },
 945         { java_net_SocketOptions_SO_BROADCAST,          SOL_SOCKET,     SO_BROADCAST },
 946         { java_net_SocketOptions_IP_TOS,                IPPROTO_IP,     IP_TOS },
 947         { java_net_SocketOptions_IP_MULTICAST_IF,       IPPROTO_IP,     IP_MULTICAST_IF },
 948         { java_net_SocketOptions_IP_MULTICAST_IF2,      IPPROTO_IP,     IP_MULTICAST_IF },
 949         { java_net_SocketOptions_IP_MULTICAST_LOOP,     IPPROTO_IP,     IP_MULTICAST_LOOP },
 950     };
 951 
 952     int i;
 953 
 954     /*
 955      * Different multicast options if IPv6 is enabled
 956      */
 957 #ifdef AF_INET6
 958     if (ipv6_available()) {
 959         switch (cmd) {
 960             case java_net_SocketOptions_IP_MULTICAST_IF:
 961             case java_net_SocketOptions_IP_MULTICAST_IF2:
 962                 *level = IPPROTO_IPV6;
 963                 *optname = IPV6_MULTICAST_IF;
 964                 return 0;
 965 
 966             case java_net_SocketOptions_IP_MULTICAST_LOOP:
 967                 *level = IPPROTO_IPV6;
 968                 *optname = IPV6_MULTICAST_LOOP;
 969                 return 0;
 970         }
 971     }
 972 #endif
 973 
 974     /*
 975      * Map the Java level option to the native level
 976      */
 977     for (i=0; i<(int)(sizeof(opts) / sizeof(opts[0])); i++) {
 978         if (cmd == opts[i].cmd) {
 979             *level = opts[i].level;
 980             *optname = opts[i].optname;
 981             return 0;
 982         }
 983     }
 984 
 985     /* not found */
 986     return -1;
 987 }
 988 
 989 /*
 990  * Determine the default interface for an IPv6 address.
 991  *
 992  * 1. Scans /proc/net/ipv6_route for a matching route
 993  *    (eg: fe80::/10 or a route for the specific address).
 994  *    This will tell us the interface to use (eg: "eth0").
 995  *
 996  * 2. Lookup /proc/net/if_inet6 to map the interface
 997  *    name to an interface index.
 998  *
 999  * Returns :-
1000  *      -1 if error
1001  *       0 if no matching interface
1002  *      >1 interface index to use for the link-local address.
1003  */
1004 #if defined(__linux__) && defined(AF_INET6)
1005 int getDefaultIPv6Interface(struct in6_addr *target_addr) {
1006     FILE *f;
1007     char srcp[8][5];
1008     char hopp[8][5];
1009     int dest_plen, src_plen, use, refcnt, metric;
1010     unsigned long flags;
1011     char dest_str[40];
1012     struct in6_addr dest_addr;
1013     char device[16];
1014     jboolean match = JNI_FALSE;
1015 
1016     /*
1017      * Scan /proc/net/ipv6_route looking for a matching
1018      * route.
1019      */
1020     if ((f = fopen("/proc/net/ipv6_route", "r")) == NULL) {
1021         return -1;
1022     }
1023     while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x "
1024                      "%4s%4s%4s%4s%4s%4s%4s%4s %02x "
1025                      "%4s%4s%4s%4s%4s%4s%4s%4s "
1026                      "%08x %08x %08x %08lx %8s",
1027                      dest_str, &dest_str[5], &dest_str[10], &dest_str[15],
1028                      &dest_str[20], &dest_str[25], &dest_str[30], &dest_str[35],
1029                      &dest_plen,
1030                      srcp[0], srcp[1], srcp[2], srcp[3],
1031                      srcp[4], srcp[5], srcp[6], srcp[7],
1032                      &src_plen,
1033                      hopp[0], hopp[1], hopp[2], hopp[3],
1034                      hopp[4], hopp[5], hopp[6], hopp[7],
1035                      &metric, &use, &refcnt, &flags, device) == 31) {
1036 
1037         /*
1038          * Some routes should be ignored
1039          */
1040         if ( (dest_plen < 0 || dest_plen > 128)  ||
1041              (src_plen != 0) ||
1042              (flags & (RTF_POLICY | RTF_FLOW)) ||
1043              ((flags & RTF_REJECT) && dest_plen == 0) ) {
1044             continue;
1045         }
1046 
1047         /*
1048          * Convert the destination address
1049          */
1050         dest_str[4] = ':';
1051         dest_str[9] = ':';
1052         dest_str[14] = ':';
1053         dest_str[19] = ':';
1054         dest_str[24] = ':';
1055         dest_str[29] = ':';
1056         dest_str[34] = ':';
1057         dest_str[39] = '\0';
1058 
1059         if (inet_pton(AF_INET6, dest_str, &dest_addr) < 0) {
1060             /* not an Ipv6 address */
1061             continue;
1062         } else {
1063             /*
1064              * The prefix len (dest_plen) indicates the number of bits we
1065              * need to match on.
1066              *
1067              * dest_plen / 8    => number of bytes to match
1068              * dest_plen % 8    => number of additional bits to match
1069              *
1070              * eg: fe80::/10 => match 1 byte + 2 additional bits in the
1071              *                  the next byte.
1072              */
1073             int byte_count = dest_plen >> 3;
1074             int extra_bits = dest_plen & 0x3;
1075 
1076             if (byte_count > 0) {
1077                 if (memcmp(target_addr, &dest_addr, byte_count)) {
1078                     continue;  /* no match */
1079                 }
1080             }
1081 
1082             if (extra_bits > 0) {
1083                 unsigned char c1 = ((unsigned char *)target_addr)[byte_count];
1084                 unsigned char c2 = ((unsigned char *)&dest_addr)[byte_count];
1085                 unsigned char mask = 0xff << (8 - extra_bits);
1086                 if ((c1 & mask) != (c2 & mask)) {
1087                     continue;
1088                 }
1089             }
1090 
1091             /*
1092              * We have a match
1093              */
1094             match = JNI_TRUE;
1095             break;
1096         }
1097     }
1098     fclose(f);
1099 
1100     /*
1101      * If there's a match then we lookup the interface
1102      * index.
1103      */
1104     if (match) {
1105         char devname[20];
1106         char addr6p[8][5];
1107         int plen, scope, dad_status, if_idx;
1108 
1109         if ((f = fopen("/proc/net/if_inet6", "r")) != NULL) {
1110             while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
1111                       addr6p[0], addr6p[1], addr6p[2], addr6p[3],
1112                       addr6p[4], addr6p[5], addr6p[6], addr6p[7],
1113                   &if_idx, &plen, &scope, &dad_status, devname) == 13) {
1114 
1115                 if (strcmp(devname, device) == 0) {
1116                     /*
1117                      * Found - so just return the index
1118                      */
1119                     fclose(f);
1120                     return if_idx;
1121                 }
1122             }
1123             fclose(f);
1124         } else {
1125             /*
1126              * Couldn't open /proc/net/if_inet6
1127              */
1128             return -1;
1129         }
1130     }
1131 
1132     /*
1133      * If we get here it means we didn't there wasn't any
1134      * route or we couldn't get the index of the interface.
1135      */
1136     return 0;
1137 }
1138 #endif
1139 
1140 
1141 /*
1142  * Wrapper for getsockopt system routine - does any necessary
1143  * pre/post processing to deal with OS specific oddies :-
1144  *
1145  * IP_TOS is a no-op with IPv6 sockets as it's setup when
1146  * the connection is established.
1147  *
1148  * On Linux the SO_SNDBUF/SO_RCVBUF values must be post-processed
1149  * to compensate for an incorrect value returned by the kernel.
1150  */
1151 int
1152 NET_GetSockOpt(int fd, int level, int opt, void *result,
1153                int *len)
1154 {
1155     int rv;
1156 
1157 #ifdef AF_INET6
1158     if ((level == IPPROTO_IP) && (opt == IP_TOS)) {
1159         if (ipv6_available()) {
1160 
1161             /*
1162              * For IPv6 socket option implemented at Java-level
1163              * so return -1.
1164              */
1165             int *tc = (int *)result;
1166             *tc = -1;
1167             return 0;
1168         }
1169     }
1170 #endif
1171 
1172 #ifdef __solaris__
1173     rv = getsockopt(fd, level, opt, result, len);
1174 #else
1175     {
1176         socklen_t socklen = *len;
1177         rv = getsockopt(fd, level, opt, result, &socklen);
1178         *len = socklen;
1179     }
1180 #endif
1181 
1182     if (rv < 0) {
1183         return rv;
1184     }
1185 
1186 #ifdef __linux__
1187     /*
1188      * On Linux SO_SNDBUF/SO_RCVBUF aren't symmetric. This
1189      * stems from additional socket structures in the send
1190      * and receive buffers.
1191      */
1192     if ((level == SOL_SOCKET) && ((opt == SO_SNDBUF)
1193                                   || (opt == SO_RCVBUF))) {
1194         int n = *((int *)result);
1195         n /= 2;
1196         *((int *)result) = n;
1197     }
1198 #endif
1199 
1200     return rv;
1201 }
1202 
1203 /*
1204  * Wrapper for setsockopt system routine - performs any
1205  * necessary pre/post processing to deal with OS specific
1206  * issue :-
1207  *
1208  * On Solaris need to limit the suggested value for SO_SNDBUF
1209  * and SO_RCVBUF to the kernel configured limit
1210  *
1211  * For IP_TOS socket option need to mask off bits as this
1212  * aren't automatically masked by the kernel and results in
1213  * an error. In addition IP_TOS is a noop with IPv6 as it
1214  * should be setup as connection time.
1215  */
1216 int
1217 NET_SetSockOpt(int fd, int level, int  opt, const void *arg,
1218                int len)
1219 {
1220 #ifndef IPTOS_TOS_MASK
1221 #define IPTOS_TOS_MASK 0x1e
1222 #endif
1223 #ifndef IPTOS_PREC_MASK
1224 #define IPTOS_PREC_MASK 0xe0
1225 #endif
1226 
1227     /*
1228      * IPPROTO/IP_TOS :-
1229      * 1. IPv6 on Solaris: no-op and will be set in flowinfo
1230      *    field when connecting TCP socket, or sending
1231      *    UDP packet.
1232      * 2. IPv6 on Linux: By default Linux ignores flowinfo
1233      *    field so enable IPV6_FLOWINFO_SEND so that flowinfo
1234      *    will be examined.
1235      * 3. IPv4: set socket option based on ToS and Precedence
1236      *    fields (otherwise get invalid argument)
1237      */
1238     if (level == IPPROTO_IP && opt == IP_TOS) {
1239         int *iptos;
1240 
1241 #if defined(AF_INET6) && defined(__solaris__)
1242         if (ipv6_available()) {
1243             return 0;
1244         }
1245 #endif
1246 
1247 #if defined(AF_INET6) && defined(__linux__)
1248         if (ipv6_available()) {
1249             int optval = 1;
1250             return setsockopt(fd, IPPROTO_IPV6, IPV6_FLOWINFO_SEND,
1251                               (void *)&optval, sizeof(optval));
1252         }
1253 #endif
1254 
1255         iptos = (int *)arg;
1256         *iptos &= (IPTOS_TOS_MASK | IPTOS_PREC_MASK);
1257     }
1258 
1259     /*
1260      * SOL_SOCKET/{SO_SNDBUF,SO_RCVBUF} - On Solaris we may need to clamp
1261      * the value when it exceeds the system limit.
1262      */
1263 #ifdef __solaris__
1264     if (level == SOL_SOCKET) {
1265         if (opt == SO_SNDBUF || opt == SO_RCVBUF) {
1266             int sotype=0, arglen;
1267             int *bufsize, maxbuf;
1268             int ret;
1269 
1270             /* Attempt with the original size */
1271             ret = setsockopt(fd, level, opt, arg, len);
1272             if ((ret == 0) || (ret == -1 && errno != ENOBUFS))
1273                 return ret;
1274 
1275             /* Exceeded system limit so clamp and retry */
1276 
1277             arglen = sizeof(sotype);
1278             if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *)&sotype,
1279                            &arglen) < 0) {
1280                 return -1;
1281             }
1282 
1283             /*
1284              * We try to get tcp_maxbuf (and udp_max_buf) using
1285              * an ioctl() that isn't available on all versions of Solaris.
1286              * If that fails, we use the search algorithm in findMaxBuf()
1287              */
1288             if (!init_tcp_max_buf && sotype == SOCK_STREAM) {
1289                 tcp_max_buf = getParam("/dev/tcp", "tcp_max_buf");
1290                 if (tcp_max_buf == -1) {
1291                     tcp_max_buf = findMaxBuf(fd, opt, SOCK_STREAM);
1292                     if (tcp_max_buf == -1) {
1293                         return -1;
1294                     }
1295                 }
1296                 init_tcp_max_buf = 1;
1297             } else if (!init_udp_max_buf && sotype == SOCK_DGRAM) {
1298                 udp_max_buf = getParam("/dev/udp", "udp_max_buf");
1299                 if (udp_max_buf == -1) {
1300                     udp_max_buf = findMaxBuf(fd, opt, SOCK_DGRAM);
1301                     if (udp_max_buf == -1) {
1302                         return -1;
1303                     }
1304                 }
1305                 init_udp_max_buf = 1;
1306             }
1307 
1308             maxbuf = (sotype == SOCK_STREAM) ? tcp_max_buf : udp_max_buf;
1309             bufsize = (int *)arg;
1310             if (*bufsize > maxbuf) {
1311                 *bufsize = maxbuf;
1312             }
1313         }
1314     }
1315 #endif
1316 
1317     /*
1318      * On Linux the receive buffer is used for both socket
1319      * structures and the the packet payload. The implication
1320      * is that if SO_RCVBUF is too small then small packets
1321      * must be discard.
1322      */
1323 #ifdef __linux__
1324     if (level == SOL_SOCKET && opt == SO_RCVBUF) {
1325         int *bufsize = (int *)arg;
1326         if (*bufsize < 1024) {
1327             *bufsize = 1024;
1328         }
1329     }
1330 #endif
1331 
1332     return setsockopt(fd, level, opt, arg, len);
1333 }
1334 
1335 /*
1336  * Wrapper for bind system call - performs any necessary pre/post
1337  * processing to deal with OS specific issues :-
1338  *
1339  * Linux allows a socket to bind to 127.0.0.255 which must be
1340  * caught.
1341  *
1342  * On Solaris 8/9 with IPv6 enabled we must use an exclusive
1343  * bind to guaranteed a unique port number across the IPv4 and
1344  * IPv6 port spaces.
1345  *
1346  */
1347 int
1348 NET_Bind(int fd, struct sockaddr *him, int len)
1349 {
1350 #if defined(__solaris__) && defined(AF_INET6)
1351     int level = -1;
1352     int exclbind = -1;
1353 #endif
1354     int rv;
1355 
1356 #ifdef __linux__
1357     /*
1358      * ## get bugId for this issue - goes back to 1.2.2 port ##
1359      * ## When IPv6 is enabled this will be an IPv4-mapped
1360      * ## with family set to AF_INET6
1361      */
1362     if (him->sa_family == AF_INET) {
1363         struct sockaddr_in *sa = (struct sockaddr_in *)him;
1364         if ((ntohl(sa->sin_addr.s_addr) & 0x7f0000ff) == 0x7f0000ff) {
1365             errno = EADDRNOTAVAIL;
1366             return -1;
1367         }
1368     }
1369 #endif
1370 
1371 #if defined(__solaris__) && defined(AF_INET6)
1372     /*
1373      * Solaris 8/9 have seperate IPv4 and IPv6 port spaces so we
1374      * use an exclusive bind when SO_REUSEADDR is not used to
1375      * give the illusion of a unified port space.
1376      * This also avoid problems with IPv6 sockets connecting
1377      * to IPv4 mapped addresses whereby the socket conversion
1378      * results in a late bind that fails because the
1379      * corresponding IPv4 port is in use.
1380      */
1381     if (ipv6_available()) {
1382         int arg, len;
1383 
1384         len = sizeof(arg);
1385         if (getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&arg,
1386                        &len) == 0) {
1387             if (arg == 0) {
1388                 /*
1389                  * SO_REUSEADDR is disabled so enable TCP_EXCLBIND or
1390                  * UDP_EXCLBIND
1391                  */
1392                 len = sizeof(arg);
1393                 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&arg,
1394                                &len) == 0) {
1395                     if (arg == SOCK_STREAM) {
1396                         level = IPPROTO_TCP;
1397                         exclbind = TCP_EXCLBIND;
1398                     } else {
1399                         level = IPPROTO_UDP;
1400                         exclbind = UDP_EXCLBIND;
1401                     }
1402                 }
1403 
1404                 arg = 1;
1405                 setsockopt(fd, level, exclbind, (char *)&arg,
1406                            sizeof(arg));
1407             }
1408         }
1409     }
1410 
1411 #endif
1412 
1413     rv = bind(fd, him, len);
1414 
1415 #if defined(__solaris__) && defined(AF_INET6)
1416     if (rv < 0) {
1417         int en = errno;
1418         /* Restore *_EXCLBIND if the bind fails */
1419         if (exclbind != -1) {
1420             int arg = 0;
1421             setsockopt(fd, level, exclbind, (char *)&arg,
1422                        sizeof(arg));
1423         }
1424         errno = en;
1425     }
1426 #endif
1427 
1428     return rv;
1429 }
1430 
1431 /**
1432  * Wrapper for select/poll with timeout on a single file descriptor.
1433  *
1434  * flags (defined in net_util_md.h can be any combination of
1435  * NET_WAIT_READ, NET_WAIT_WRITE & NET_WAIT_CONNECT.
1436  *
1437  * The function will return when either the socket is ready for one
1438  * of the specified operation or the timeout expired.
1439  *
1440  * It returns the time left from the timeout (possibly 0), or -1 if it expired.
1441  */
1442 
1443 jint
1444 NET_Wait(JNIEnv *env, jint fd, jint flags, jint timeout)
1445 {
1446     jlong prevTime = JVM_CurrentTimeMillis(env, 0);
1447     jint read_rv;
1448 
1449     while (1) {
1450         jlong newTime;
1451 #ifndef USE_SELECT
1452         {
1453           struct pollfd pfd;
1454           pfd.fd = fd;
1455           pfd.events = 0;
1456           if (flags & NET_WAIT_READ)
1457             pfd.events |= POLLIN;
1458           if (flags & NET_WAIT_WRITE)
1459             pfd.events |= POLLOUT;
1460           if (flags & NET_WAIT_CONNECT)
1461             pfd.events |= POLLOUT;
1462 
1463           errno = 0;
1464           read_rv = NET_Poll(&pfd, 1, timeout);
1465         }
1466 #else
1467         {
1468           fd_set rd, wr, ex;
1469           struct timeval t;
1470 
1471           t.tv_sec = timeout / 1000;
1472           t.tv_usec = (timeout % 1000) * 1000;
1473 
1474           FD_ZERO(&rd);
1475           FD_ZERO(&wr);
1476           FD_ZERO(&ex);
1477           if (flags & NET_WAIT_READ) {
1478             FD_SET(fd, &rd);
1479           }
1480           if (flags & NET_WAIT_WRITE) {
1481             FD_SET(fd, &wr);
1482           }
1483           if (flags & NET_WAIT_CONNECT) {
1484             FD_SET(fd, &wr);
1485             FD_SET(fd, &ex);
1486           }
1487 
1488           errno = 0;
1489           read_rv = NET_Select(fd+1, &rd, &wr, &ex, &t);
1490         }
1491 #endif
1492 
1493         newTime = JVM_CurrentTimeMillis(env, 0);
1494         timeout -= (newTime - prevTime);
1495         if (timeout <= 0) {
1496           return read_rv > 0 ? 0 : -1;
1497         }
1498         newTime = prevTime;
1499 
1500         if (read_rv > 0) {
1501           break;
1502         }
1503 
1504 
1505       } /* while */
1506 
1507     return timeout;
1508 }