1 /*
   2  * Copyright (c) 1997, 2016, 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 <winsock2.h>
  27 #include <ws2tcpip.h>
  28 
  29 #include "net_util.h"
  30 #include "jni.h"
  31 
  32 // Taken from mstcpip.h in Windows SDK 8.0 or newer.
  33 #define SIO_LOOPBACK_FAST_PATH              _WSAIOW(IOC_VENDOR,16)
  34 
  35 #ifndef IPTOS_TOS_MASK
  36 #define IPTOS_TOS_MASK 0x1e
  37 #endif
  38 #ifndef IPTOS_PREC_MASK
  39 #define IPTOS_PREC_MASK 0xe0
  40 #endif
  41 
  42 /* true if SO_RCVTIMEO is supported */
  43 jboolean isRcvTimeoutSupported = JNI_TRUE;
  44 
  45 /*
  46  * Table of Windows Sockets errors, the specific exception we
  47  * throw for the error, and the error text.
  48  *
  49  * Note that this table excludes OS dependent errors.
  50  *
  51  * Latest list of Windows Sockets errors can be found at :-
  52  * http://msdn.microsoft.com/library/psdk/winsock/errors_3wc2.htm
  53  */
  54 static struct {
  55     int errCode;
  56     const char *exc;
  57     const char *errString;
  58 } const winsock_errors[] = {
  59     { WSAEACCES,                0,      "Permission denied" },
  60     { WSAEADDRINUSE,            "BindException",        "Address already in use" },
  61     { WSAEADDRNOTAVAIL,         "BindException",        "Cannot assign requested address" },
  62     { WSAEAFNOSUPPORT,          0,      "Address family not supported by protocol family" },
  63     { WSAEALREADY,              0,      "Operation already in progress" },
  64     { WSAECONNABORTED,          0,      "Software caused connection abort" },
  65     { WSAECONNREFUSED,          "ConnectException",     "Connection refused" },
  66     { WSAECONNRESET,            0,      "Connection reset by peer" },
  67     { WSAEDESTADDRREQ,          0,      "Destination address required" },
  68     { WSAEFAULT,                0,      "Bad address" },
  69     { WSAEHOSTDOWN,             0,      "Host is down" },
  70     { WSAEHOSTUNREACH,          "NoRouteToHostException",       "No route to host" },
  71     { WSAEINPROGRESS,           0,      "Operation now in progress" },
  72     { WSAEINTR,                 0,      "Interrupted function call" },
  73     { WSAEINVAL,                0,      "Invalid argument" },
  74     { WSAEISCONN,               0,      "Socket is already connected" },
  75     { WSAEMFILE,                0,      "Too many open files" },
  76     { WSAEMSGSIZE,              0,      "The message is larger than the maximum supported by the underlying transport" },
  77     { WSAENETDOWN,              0,      "Network is down" },
  78     { WSAENETRESET,             0,      "Network dropped connection on reset" },
  79     { WSAENETUNREACH,           0,      "Network is unreachable" },
  80     { WSAENOBUFS,               0,      "No buffer space available (maximum connections reached?)" },
  81     { WSAENOPROTOOPT,           0,      "Bad protocol option" },
  82     { WSAENOTCONN,              0,      "Socket is not connected" },
  83     { WSAENOTSOCK,              0,      "Socket operation on nonsocket" },
  84     { WSAEOPNOTSUPP,            0,      "Operation not supported" },
  85     { WSAEPFNOSUPPORT,          0,      "Protocol family not supported" },
  86     { WSAEPROCLIM,              0,      "Too many processes" },
  87     { WSAEPROTONOSUPPORT,       0,      "Protocol not supported" },
  88     { WSAEPROTOTYPE,            0,      "Protocol wrong type for socket" },
  89     { WSAESHUTDOWN,             0,      "Cannot send after socket shutdown" },
  90     { WSAESOCKTNOSUPPORT,       0,      "Socket type not supported" },
  91     { WSAETIMEDOUT,             "ConnectException",     "Connection timed out" },
  92     { WSATYPE_NOT_FOUND,        0,      "Class type not found" },
  93     { WSAEWOULDBLOCK,           0,      "Resource temporarily unavailable" },
  94     { WSAHOST_NOT_FOUND,        0,      "Host not found" },
  95     { WSA_NOT_ENOUGH_MEMORY,    0,      "Insufficient memory available" },
  96     { WSANOTINITIALISED,        0,      "Successful WSAStartup not yet performed" },
  97     { WSANO_DATA,               0,      "Valid name, no data record of requested type" },
  98     { WSANO_RECOVERY,           0,      "This is a nonrecoverable error" },
  99     { WSASYSNOTREADY,           0,      "Network subsystem is unavailable" },
 100     { WSATRY_AGAIN,             0,      "Nonauthoritative host not found" },
 101     { WSAVERNOTSUPPORTED,       0,      "Winsock.dll version out of range" },
 102     { WSAEDISCON,               0,      "Graceful shutdown in progress" },
 103     { WSA_OPERATION_ABORTED,    0,      "Overlapped operation aborted" },
 104 };
 105 
 106 /*
 107  * Initialize Windows Sockets API support
 108  */
 109 BOOL WINAPI
 110 DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved)
 111 {
 112     WSADATA wsadata;
 113 
 114     switch (reason) {
 115         case DLL_PROCESS_ATTACH:
 116             if (WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
 117                 return FALSE;
 118             }
 119             break;
 120 
 121         case DLL_PROCESS_DETACH:
 122             WSACleanup();
 123             break;
 124 
 125         default:
 126             break;
 127     }
 128     return TRUE;
 129 }
 130 
 131 void platformInit() {}
 132 void parseExclusiveBindProperty(JNIEnv *env) {}
 133 
 134 /*
 135  * Since winsock doesn't have the equivalent of strerror(errno)
 136  * use table to lookup error text for the error.
 137  */
 138 JNIEXPORT void JNICALL
 139 NET_ThrowNew(JNIEnv *env, int errorNum, char *msg)
 140 {
 141     int i;
 142     int table_size = sizeof(winsock_errors) /
 143                      sizeof(winsock_errors[0]);
 144     char exc[256];
 145     char fullMsg[256];
 146     char *excP = NULL;
 147 
 148     /*
 149      * If exception already throw then don't overwrite it.
 150      */
 151     if ((*env)->ExceptionOccurred(env)) {
 152         return;
 153     }
 154 
 155     /*
 156      * Default message text if not provided
 157      */
 158     if (!msg) {
 159         msg = "no further information";
 160     }
 161 
 162     /*
 163      * Check table for known winsock errors
 164      */
 165     i=0;
 166     while (i < table_size) {
 167         if (errorNum == winsock_errors[i].errCode) {
 168             break;
 169         }
 170         i++;
 171     }
 172 
 173     /*
 174      * If found get pick the specific exception and error
 175      * message corresponding to this error.
 176      */
 177     if (i < table_size) {
 178         excP = (char *)winsock_errors[i].exc;
 179         jio_snprintf(fullMsg, sizeof(fullMsg), "%s: %s",
 180                      (char *)winsock_errors[i].errString, msg);
 181     } else {
 182         jio_snprintf(fullMsg, sizeof(fullMsg),
 183                      "Unrecognized Windows Sockets error: %d: %s",
 184                      errorNum, msg);
 185 
 186     }
 187 
 188     /*
 189      * Throw SocketException if no specific exception for this
 190      * error.
 191      */
 192     if (excP == NULL) {
 193         excP = "SocketException";
 194     }
 195     sprintf(exc, "%s%s", JNU_JAVANETPKG, excP);
 196     JNU_ThrowByName(env, exc, fullMsg);
 197 }
 198 
 199 void
 200 NET_ThrowCurrent(JNIEnv *env, char *msg)
 201 {
 202     NET_ThrowNew(env, WSAGetLastError(), msg);
 203 }
 204 
 205 void
 206 NET_ThrowSocketException(JNIEnv *env, char* msg)
 207 {
 208     static jclass cls = NULL;
 209     if (cls == NULL) {
 210         cls = (*env)->FindClass(env, "java/net/SocketException");
 211         CHECK_NULL(cls);
 212         cls = (*env)->NewGlobalRef(env, cls);
 213         CHECK_NULL(cls);
 214     }
 215     (*env)->ThrowNew(env, cls, msg);
 216 }
 217 
 218 jfieldID
 219 NET_GetFileDescriptorID(JNIEnv *env)
 220 {
 221     jclass cls = (*env)->FindClass(env, "java/io/FileDescriptor");
 222     CHECK_NULL_RETURN(cls, NULL);
 223     return (*env)->GetFieldID(env, cls, "fd", "I");
 224 }
 225 
 226 jint  IPv6_supported()
 227 {
 228     SOCKET s = socket(AF_INET6, SOCK_STREAM, 0) ;
 229     if (s == INVALID_SOCKET) {
 230         return JNI_FALSE;
 231     }
 232     closesocket(s);
 233 
 234     return JNI_TRUE;
 235 }
 236 
 237 jint reuseport_supported()
 238 {
 239     /* SO_REUSEPORT is not supported onn Windows */
 240     return JNI_FALSE;
 241 }
 242 /*
 243  * Return the default TOS value
 244  */
 245 int NET_GetDefaultTOS() {
 246     static int default_tos = -1;
 247     OSVERSIONINFO ver;
 248     HKEY hKey;
 249     LONG ret;
 250 
 251     /*
 252      * If default ToS already determined then return it
 253      */
 254     if (default_tos >= 0) {
 255         return default_tos;
 256     }
 257 
 258     /*
 259      * Assume default is "normal service"
 260      */
 261     default_tos = 0;
 262 
 263     /*
 264      * Which OS is this?
 265      */
 266     ver.dwOSVersionInfoSize = sizeof(ver);
 267     GetVersionEx(&ver);
 268 
 269     /*
 270      * If 2000 or greater then no default ToS in registry
 271      */
 272     if (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
 273         if (ver.dwMajorVersion >= 5) {
 274             return default_tos;
 275         }
 276     }
 277 
 278     /*
 279      * Query the registry to see if a Default ToS has been set.
 280      * Different registry entry for NT vs 95/98/ME.
 281      */
 282     if (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
 283         ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
 284                            "SYSTEM\\CurrentControlSet\\Services\\Tcp\\Parameters",
 285                            0, KEY_READ, (PHKEY)&hKey);
 286     } else {
 287         ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
 288                            "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP\\Parameters",
 289                            0, KEY_READ, (PHKEY)&hKey);
 290     }
 291     if (ret == ERROR_SUCCESS) {
 292         DWORD dwLen;
 293         DWORD dwDefaultTOS;
 294         ULONG ulType;
 295         dwLen = sizeof(dwDefaultTOS);
 296 
 297         ret = RegQueryValueEx(hKey, "DefaultTOS",  NULL, &ulType,
 298                              (LPBYTE)&dwDefaultTOS, &dwLen);
 299         RegCloseKey(hKey);
 300         if (ret == ERROR_SUCCESS) {
 301             default_tos = (int)dwDefaultTOS;
 302         }
 303     }
 304     return default_tos;
 305 }
 306 
 307 /* call NET_MapSocketOptionV6 for the IPv6 fd only
 308  * and NET_MapSocketOption for the IPv4 fd
 309  */
 310 JNIEXPORT int JNICALL
 311 NET_MapSocketOptionV6(jint cmd, int *level, int *optname) {
 312 
 313     switch (cmd) {
 314         case java_net_SocketOptions_IP_MULTICAST_IF:
 315         case java_net_SocketOptions_IP_MULTICAST_IF2:
 316             *level = IPPROTO_IPV6;
 317             *optname = IPV6_MULTICAST_IF;
 318             return 0;
 319 
 320         case java_net_SocketOptions_IP_MULTICAST_LOOP:
 321             *level = IPPROTO_IPV6;
 322             *optname = IPV6_MULTICAST_LOOP;
 323             return 0;
 324     }
 325     return NET_MapSocketOption (cmd, level, optname);
 326 }
 327 
 328 /*
 329  * Map the Java level socket option to the platform specific
 330  * level and option name.
 331  */
 332 
 333 JNIEXPORT int JNICALL
 334 NET_MapSocketOption(jint cmd, int *level, int *optname) {
 335 
 336     typedef struct {
 337         jint cmd;
 338         int level;
 339         int optname;
 340     } sockopts;
 341 
 342     static sockopts opts[] = {
 343         { java_net_SocketOptions_TCP_NODELAY,   IPPROTO_TCP,    TCP_NODELAY },
 344         { java_net_SocketOptions_SO_OOBINLINE,  SOL_SOCKET,     SO_OOBINLINE },
 345         { java_net_SocketOptions_SO_LINGER,     SOL_SOCKET,     SO_LINGER },
 346         { java_net_SocketOptions_SO_SNDBUF,     SOL_SOCKET,     SO_SNDBUF },
 347         { java_net_SocketOptions_SO_RCVBUF,     SOL_SOCKET,     SO_RCVBUF },
 348         { java_net_SocketOptions_SO_KEEPALIVE,  SOL_SOCKET,     SO_KEEPALIVE },
 349         { java_net_SocketOptions_SO_REUSEADDR,  SOL_SOCKET,     SO_REUSEADDR },
 350         { java_net_SocketOptions_SO_BROADCAST,  SOL_SOCKET,     SO_BROADCAST },
 351         { java_net_SocketOptions_IP_MULTICAST_IF,   IPPROTO_IP, IP_MULTICAST_IF },
 352         { java_net_SocketOptions_IP_MULTICAST_LOOP, IPPROTO_IP, IP_MULTICAST_LOOP },
 353         { java_net_SocketOptions_IP_TOS,            IPPROTO_IP, IP_TOS },
 354 
 355     };
 356 
 357 
 358     int i;
 359 
 360     /*
 361      * Map the Java level option to the native level
 362      */
 363     for (i=0; i<(int)(sizeof(opts) / sizeof(opts[0])); i++) {
 364         if (cmd == opts[i].cmd) {
 365             *level = opts[i].level;
 366             *optname = opts[i].optname;
 367             return 0;
 368         }
 369     }
 370 
 371     /* not found */
 372     return -1;
 373 }
 374 
 375 
 376 /*
 377  * Wrapper for setsockopt dealing with Windows specific issues :-
 378  *
 379  * IP_TOS and IP_MULTICAST_LOOP can't be set on some Windows
 380  * editions.
 381  *
 382  * The value for the type-of-service (TOS) needs to be masked
 383  * to get consistent behaviour with other operating systems.
 384  */
 385 JNIEXPORT int JNICALL
 386 NET_SetSockOpt(int s, int level, int optname, const void *optval,
 387                int optlen)
 388 {
 389     int rv = 0;
 390     int parg = 0;
 391     int plen = sizeof(parg);
 392 
 393     if (level == IPPROTO_IP && optname == IP_TOS) {
 394         int *tos = (int *)optval;
 395         *tos &= (IPTOS_TOS_MASK | IPTOS_PREC_MASK);
 396     }
 397 
 398     if (optname == SO_REUSEADDR) {
 399         /*
 400          * Do not set SO_REUSEADDE if SO_EXCLUSIVEADDUSE is already set
 401          */
 402         rv = NET_GetSockOpt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *)&parg, &plen);
 403         if (rv == 0 && parg == 1) {
 404             return rv;
 405         }
 406     }
 407 
 408     rv = setsockopt(s, level, optname, optval, optlen);
 409 
 410     if (rv == SOCKET_ERROR) {
 411         /*
 412          * IP_TOS & IP_MULTICAST_LOOP can't be set on some versions
 413          * of Windows.
 414          */
 415         if ((WSAGetLastError() == WSAENOPROTOOPT) &&
 416             (level == IPPROTO_IP) &&
 417             (optname == IP_TOS || optname == IP_MULTICAST_LOOP)) {
 418             rv = 0;
 419         }
 420 
 421         /*
 422          * IP_TOS can't be set on unbound UDP sockets.
 423          */
 424         if ((WSAGetLastError() == WSAEINVAL) &&
 425             (level == IPPROTO_IP) &&
 426             (optname == IP_TOS)) {
 427             rv = 0;
 428         }
 429     }
 430 
 431     return rv;
 432 }
 433 
 434 /*
 435  * Wrapper for setsockopt dealing with Windows specific issues :-
 436  *
 437  * IP_TOS is not supported on some versions of Windows so
 438  * instead return the default value for the OS.
 439  */
 440 JNIEXPORT int JNICALL
 441 NET_GetSockOpt(int s, int level, int optname, void *optval,
 442                int *optlen)
 443 {
 444     int rv;
 445 
 446     if (level == IPPROTO_IPV6 && optname == IPV6_TCLASS) {
 447         int *intopt = (int *)optval;
 448         *intopt = 0;
 449         *optlen = sizeof(*intopt);
 450         return 0;
 451     }
 452 
 453     rv = getsockopt(s, level, optname, optval, optlen);
 454 
 455 
 456     /*
 457      * IPPROTO_IP/IP_TOS is not supported on some Windows
 458      * editions so return the default type-of-service
 459      * value.
 460      */
 461     if (rv == SOCKET_ERROR) {
 462 
 463         if (WSAGetLastError() == WSAENOPROTOOPT &&
 464             level == IPPROTO_IP && optname == IP_TOS) {
 465 
 466             int *tos;
 467             tos = (int *)optval;
 468             *tos = NET_GetDefaultTOS();
 469 
 470             rv = 0;
 471         }
 472     }
 473 
 474     return rv;
 475 }
 476 
 477 /*
 478  * Sets SO_ECLUSIVEADDRUSE if SO_REUSEADDR is not already set.
 479  */
 480 void setExclusiveBind(int fd) {
 481     int parg = 0;
 482     int plen = sizeof(parg);
 483     int rv = 0;
 484     rv = NET_GetSockOpt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&parg, &plen);
 485     if (rv == 0 && parg == 0) {
 486         parg = 1;
 487         rv = NET_SetSockOpt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&parg, plen);
 488     }
 489 }
 490 
 491 /*
 492  * Wrapper for bind winsock call - transparent converts an
 493  * error related to binding to a port that has exclusive access
 494  * into an error indicating the port is in use (facilitates
 495  * better error reporting).
 496  *
 497  * Should be only called by the wrapper method NET_WinBind
 498  */
 499 JNIEXPORT int JNICALL
 500 NET_Bind(int s, struct sockaddr *him, int len)
 501 {
 502     int rv = 0;
 503     rv = bind(s, him, len);
 504 
 505     if (rv == SOCKET_ERROR) {
 506         /*
 507          * If bind fails with WSAEACCES it means that a privileged
 508          * process has done an exclusive bind (NT SP4/2000/XP only).
 509          */
 510         if (WSAGetLastError() == WSAEACCES) {
 511             WSASetLastError(WSAEADDRINUSE);
 512         }
 513     }
 514 
 515     return rv;
 516 }
 517 
 518 /*
 519  * Wrapper for NET_Bind call. Sets SO_EXCLUSIVEADDRUSE
 520  * if required, and then calls NET_BIND
 521  */
 522 JNIEXPORT int JNICALL
 523 NET_WinBind(int s, struct sockaddr *him, int len, jboolean exclBind)
 524 {
 525     if (exclBind == JNI_TRUE)
 526         setExclusiveBind(s);
 527     return NET_Bind(s, him, len);
 528 }
 529 
 530 JNIEXPORT int JNICALL
 531 NET_SocketClose(int fd) {
 532     struct linger l = {0, 0};
 533     int ret = 0;
 534     int len = sizeof (l);
 535     if (getsockopt(fd, SOL_SOCKET, SO_LINGER, (char *)&l, &len) == 0) {
 536         if (l.l_onoff == 0) {
 537             WSASendDisconnect(fd, NULL);
 538         }
 539     }
 540     ret = closesocket (fd);
 541     return ret;
 542 }
 543 
 544 JNIEXPORT int JNICALL
 545 NET_Timeout(int fd, long timeout) {
 546     int ret;
 547     fd_set tbl;
 548     struct timeval t;
 549     t.tv_sec = timeout / 1000;
 550     t.tv_usec = (timeout % 1000) * 1000;
 551     FD_ZERO(&tbl);
 552     FD_SET(fd, &tbl);
 553     ret = select (fd + 1, &tbl, 0, 0, &t);
 554     return ret;
 555 }
 556 
 557 
 558 /*
 559  * differs from NET_Timeout() as follows:
 560  *
 561  * If timeout = -1, it blocks forever.
 562  *
 563  * returns 1 or 2 depending if only one or both sockets
 564  * fire at same time.
 565  *
 566  * *fdret is (one of) the active fds. If both sockets
 567  * fire at same time, *fdret = fd always.
 568  */
 569 JNIEXPORT int JNICALL
 570 NET_Timeout2(int fd, int fd1, long timeout, int *fdret) {
 571     int ret;
 572     fd_set tbl;
 573     struct timeval t, *tP = &t;
 574     if (timeout == -1) {
 575         tP = 0;
 576     } else {
 577         t.tv_sec = timeout / 1000;
 578         t.tv_usec = (timeout % 1000) * 1000;
 579     }
 580     FD_ZERO(&tbl);
 581     FD_SET(fd, &tbl);
 582     FD_SET(fd1, &tbl);
 583     ret = select (0, &tbl, 0, 0, tP);
 584     switch (ret) {
 585     case 0:
 586         return 0; /* timeout */
 587     case 1:
 588         if (FD_ISSET (fd, &tbl)) {
 589             *fdret= fd;
 590         } else {
 591             *fdret= fd1;
 592         }
 593         return 1;
 594     case 2:
 595         *fdret= fd;
 596         return 2;
 597     }
 598     return -1;
 599 }
 600 
 601 
 602 void dumpAddr (char *str, void *addr) {
 603     struct SOCKADDR_IN6 *a = (struct SOCKADDR_IN6 *)addr;
 604     int family = a->sin6_family;
 605     printf ("%s\n", str);
 606     if (family == AF_INET) {
 607         struct sockaddr_in *him = (struct sockaddr_in *)addr;
 608         printf ("AF_INET: port %d: %x\n", ntohs(him->sin_port),
 609                                           ntohl(him->sin_addr.s_addr));
 610     } else {
 611         int i;
 612         struct in6_addr *in = &a->sin6_addr;
 613         printf ("AF_INET6 ");
 614         printf ("port %d ", ntohs (a->sin6_port));
 615         printf ("flow %d ", a->sin6_flowinfo);
 616         printf ("addr ");
 617         for (i=0; i<7; i++) {
 618             printf ("%04x:", ntohs(in->s6_words[i]));
 619         }
 620         printf ("%04x", ntohs(in->s6_words[7]));
 621         printf (" scope %d\n", a->sin6_scope_id);
 622     }
 623 }
 624 
 625 /* Macro, which cleans-up the iv6bind structure,
 626  * closes the two sockets (if open),
 627  * and returns SOCKET_ERROR. Used in NET_BindV6 only.
 628  */
 629 
 630 #define CLOSE_SOCKETS_AND_RETURN do {   \
 631     if (fd != -1) {                     \
 632         closesocket (fd);               \
 633         fd = -1;                        \
 634     }                                   \
 635     if (ofd != -1) {                    \
 636         closesocket (ofd);              \
 637         ofd = -1;                       \
 638     }                                   \
 639     if (close_fd != -1) {               \
 640         closesocket (close_fd);         \
 641         close_fd = -1;                  \
 642     }                                   \
 643     if (close_ofd != -1) {              \
 644         closesocket (close_ofd);        \
 645         close_ofd = -1;                 \
 646     }                                   \
 647     b->ipv4_fd = b->ipv6_fd = -1;       \
 648     return SOCKET_ERROR;                \
 649 } while(0)
 650 
 651 /*
 652  * if ipv6 is available, call NET_BindV6 to bind to the required address/port.
 653  * Because the same port number may need to be reserved in both v4 and v6 space,
 654  * this may require socket(s) to be re-opened. Therefore, all of this information
 655  * is passed in and returned through the ipv6bind structure.
 656  *
 657  * If the request is to bind to a specific address, then this (by definition) means
 658  * only bind in either v4 or v6, and this is just the same as normal. ie. a single
 659  * call to bind() will suffice. The other socket is closed in this case.
 660  *
 661  * The more complicated case is when the requested address is ::0 or 0.0.0.0.
 662  *
 663  * Two further cases:
 664  * 2. If the reqeusted port is 0 (ie. any port) then we try to bind in v4 space
 665  *    first with a wild-card port argument. We then try to bind in v6 space
 666  *    using the returned port number. If this fails, we repeat the process
 667  *    until a free port common to both spaces becomes available.
 668  *
 669  * 3. If the requested port is a specific port, then we just try to get that
 670  *    port in both spaces, and if it is not free in both, then the bind fails.
 671  *
 672  * On failure, sockets are closed and an error returned with CLOSE_SOCKETS_AND_RETURN
 673  */
 674 
 675 JNIEXPORT int JNICALL
 676 NET_BindV6(struct ipv6bind* b, jboolean exclBind) {
 677     int fd=-1, ofd=-1, rv, len;
 678     /* need to defer close until new sockets created */
 679     int close_fd=-1, close_ofd=-1;
 680     SOCKETADDRESS oaddr; /* other address to bind */
 681     int family = b->addr->him.sa_family;
 682     int ofamily;
 683     u_short port; /* requested port parameter */
 684     u_short bound_port;
 685 
 686     if (family == AF_INET && (b->addr->him4.sin_addr.s_addr != INADDR_ANY)) {
 687         /* bind to v4 only */
 688         int ret;
 689         ret = NET_WinBind ((int)b->ipv4_fd, (struct sockaddr *)b->addr,
 690                                 sizeof (struct sockaddr_in), exclBind);
 691         if (ret == SOCKET_ERROR) {
 692             CLOSE_SOCKETS_AND_RETURN;
 693         }
 694         closesocket (b->ipv6_fd);
 695         b->ipv6_fd = -1;
 696         return 0;
 697     }
 698     if (family == AF_INET6 && (!IN6_IS_ADDR_ANY(&b->addr->him6.sin6_addr))) {
 699         /* bind to v6 only */
 700         int ret;
 701         ret = NET_WinBind ((int)b->ipv6_fd, (struct sockaddr *)b->addr,
 702                                 sizeof (struct SOCKADDR_IN6), exclBind);
 703         if (ret == SOCKET_ERROR) {
 704             CLOSE_SOCKETS_AND_RETURN;
 705         }
 706         closesocket (b->ipv4_fd);
 707         b->ipv4_fd = -1;
 708         return 0;
 709     }
 710 
 711     /* We need to bind on both stacks, with the same port number */
 712 
 713     memset (&oaddr, 0, sizeof(oaddr));
 714     if (family == AF_INET) {
 715         ofamily = AF_INET6;
 716         fd = (int)b->ipv4_fd;
 717         ofd = (int)b->ipv6_fd;
 718         port = (u_short)GET_PORT (b->addr);
 719         IN6ADDR_SETANY (&oaddr.him6);
 720         oaddr.him6.sin6_port = port;
 721     } else {
 722         ofamily = AF_INET;
 723         ofd = (int)b->ipv4_fd;
 724         fd = (int)b->ipv6_fd;
 725         port = (u_short)GET_PORT (b->addr);
 726         oaddr.him4.sin_family = AF_INET;
 727         oaddr.him4.sin_port = port;
 728         oaddr.him4.sin_addr.s_addr = INADDR_ANY;
 729     }
 730 
 731     rv = NET_WinBind(fd, (struct sockaddr *)b->addr, SOCKETADDRESS_LEN(b->addr), exclBind);
 732     if (rv == SOCKET_ERROR) {
 733         CLOSE_SOCKETS_AND_RETURN;
 734     }
 735 
 736     /* get the port and set it in the other address */
 737     len = SOCKETADDRESS_LEN(b->addr);
 738     if (getsockname(fd, (struct sockaddr *)b->addr, &len) == -1) {
 739         CLOSE_SOCKETS_AND_RETURN;
 740     }
 741     bound_port = GET_PORT (b->addr);
 742     SET_PORT (&oaddr, bound_port);
 743     if ((rv=NET_WinBind (ofd, (struct sockaddr *) &oaddr,
 744                          SOCKETADDRESS_LEN (&oaddr), exclBind)) == SOCKET_ERROR) {
 745         int retries;
 746         int sotype, arglen=sizeof(sotype);
 747 
 748         /* no retries unless, the request was for any free port */
 749 
 750         if (port != 0) {
 751             CLOSE_SOCKETS_AND_RETURN;
 752         }
 753 
 754         getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *)&sotype, &arglen);
 755 
 756 #define SOCK_RETRIES 50
 757         /* 50 is an arbitrary limit, just to ensure that this
 758          * cannot be an endless loop. Would expect socket creation to
 759          * succeed sooner.
 760          */
 761         for (retries = 0; retries < SOCK_RETRIES; retries ++) {
 762             int len;
 763             close_fd = fd; fd = -1;
 764             close_ofd = ofd; ofd = -1;
 765             b->ipv4_fd = SOCKET_ERROR;
 766             b->ipv6_fd = SOCKET_ERROR;
 767 
 768             /* create two new sockets */
 769             fd = (int)socket (family, sotype, 0);
 770             if (fd == SOCKET_ERROR) {
 771                 CLOSE_SOCKETS_AND_RETURN;
 772             }
 773             ofd = (int)socket (ofamily, sotype, 0);
 774             if (ofd == SOCKET_ERROR) {
 775                 CLOSE_SOCKETS_AND_RETURN;
 776             }
 777 
 778             /* bind random port on first socket */
 779             SET_PORT (&oaddr, 0);
 780             rv = NET_WinBind (ofd, (struct sockaddr *)&oaddr, SOCKETADDRESS_LEN(&oaddr),
 781                               exclBind);
 782             if (rv == SOCKET_ERROR) {
 783                 CLOSE_SOCKETS_AND_RETURN;
 784             }
 785             /* close the original pair of sockets before continuing */
 786             closesocket (close_fd);
 787             closesocket (close_ofd);
 788             close_fd = close_ofd = -1;
 789 
 790             /* bind new port on second socket */
 791             len = SOCKETADDRESS_LEN(&oaddr);
 792             if (getsockname(ofd, (struct sockaddr *)&oaddr, &len) == -1) {
 793                 CLOSE_SOCKETS_AND_RETURN;
 794             }
 795             bound_port = GET_PORT (&oaddr);
 796             SET_PORT (b->addr, bound_port);
 797             rv = NET_WinBind (fd, (struct sockaddr *)b->addr, SOCKETADDRESS_LEN(b->addr),
 798                               exclBind);
 799 
 800             if (rv != SOCKET_ERROR) {
 801                 if (family == AF_INET) {
 802                     b->ipv4_fd = fd;
 803                     b->ipv6_fd = ofd;
 804                 } else {
 805                     b->ipv4_fd = ofd;
 806                     b->ipv6_fd = fd;
 807                 }
 808                 return 0;
 809             }
 810         }
 811         CLOSE_SOCKETS_AND_RETURN;
 812     }
 813     return 0;
 814 }
 815 
 816 /*
 817  * Determine the default interface for an IPv6 address.
 818  *
 819  * Returns :-
 820  *      0 if error
 821  *      > 0 interface index to use
 822  */
 823 jint getDefaultIPv6Interface(JNIEnv *env, struct SOCKADDR_IN6 *target_addr)
 824 {
 825     int ret;
 826     DWORD b;
 827     struct sockaddr_in6 route;
 828     SOCKET fd = socket(AF_INET6, SOCK_STREAM, 0);
 829     if (fd == INVALID_SOCKET) {
 830         return 0;
 831     }
 832 
 833     ret = WSAIoctl(fd, SIO_ROUTING_INTERFACE_QUERY,
 834                     (void *)target_addr, sizeof(struct sockaddr_in6),
 835                     (void *)&route, sizeof(struct sockaddr_in6),
 836                     &b, 0, 0);
 837     if (ret == SOCKET_ERROR) {
 838         // error
 839         closesocket(fd);
 840         return 0;
 841     } else {
 842         closesocket(fd);
 843         return route.sin6_scope_id;
 844     }
 845 }
 846 
 847 /**
 848  * Enables SIO_LOOPBACK_FAST_PATH
 849  */
 850 JNIEXPORT jint JNICALL
 851 NET_EnableFastTcpLoopback(int fd) {
 852     int enabled = 1;
 853     DWORD result_byte_count = -1;
 854     int result = WSAIoctl(fd,
 855                           SIO_LOOPBACK_FAST_PATH,
 856                           &enabled,
 857                           sizeof(enabled),
 858                           NULL,
 859                           0,
 860                           &result_byte_count,
 861                           NULL,
 862                           NULL);
 863     return result == SOCKET_ERROR ? WSAGetLastError() : 0;
 864 }
 865 
 866 /* If address types is IPv6, then IPv6 must be available. Otherwise
 867  * no address can be generated. In the case of an IPv4 Inetaddress this
 868  * method will return an IPv4 mapped address where IPv6 is available and
 869  * v4MappedAddress is TRUE. Otherwise it will return a sockaddr_in
 870  * structure for an IPv4 InetAddress.
 871 */
 872 JNIEXPORT int JNICALL
 873 NET_InetAddressToSockaddr(JNIEnv *env, jobject iaObj, int port, struct sockaddr *him,
 874                           int *len, jboolean v4MappedAddress) {
 875     jint family, iafam;
 876     iafam = getInetAddress_family(env, iaObj);
 877     family = (iafam == IPv4)? AF_INET : AF_INET6;
 878     if (ipv6_available() && !(family == AF_INET && v4MappedAddress == JNI_FALSE)) {
 879         struct SOCKADDR_IN6 *him6 = (struct SOCKADDR_IN6 *)him;
 880         jbyte caddr[16];
 881         jint address, scopeid = 0;
 882         jint cached_scope_id = 0;
 883 
 884         if (family == AF_INET) { /* will convert to IPv4-mapped address */
 885             memset((char *) caddr, 0, 16);
 886             address = getInetAddress_addr(env, iaObj);
 887             if (address == INADDR_ANY) {
 888                 /* we would always prefer IPv6 wildcard address
 889                 caddr[10] = 0xff;
 890                 caddr[11] = 0xff; */
 891             } else {
 892                 caddr[10] = 0xff;
 893                 caddr[11] = 0xff;
 894                 caddr[12] = ((address >> 24) & 0xff);
 895                 caddr[13] = ((address >> 16) & 0xff);
 896                 caddr[14] = ((address >> 8) & 0xff);
 897                 caddr[15] = (address & 0xff);
 898             }
 899         } else {
 900             getInet6Address_ipaddress(env, iaObj, (char *)caddr);
 901             scopeid = getInet6Address_scopeid(env, iaObj);
 902             cached_scope_id = (jint)(*env)->GetIntField(env, iaObj, ia6_cachedscopeidID);
 903         }
 904 
 905         memset((char *)him6, 0, sizeof(struct SOCKADDR_IN6));
 906         him6->sin6_port = (u_short) htons((u_short)port);
 907         memcpy((void *)&(him6->sin6_addr), caddr, sizeof(struct in6_addr) );
 908         him6->sin6_family = AF_INET6;
 909         if ((family == AF_INET6) && IN6_IS_ADDR_LINKLOCAL( &(him6->sin6_addr) )
 910             && (!scopeid && !cached_scope_id)) {
 911             cached_scope_id = getDefaultIPv6Interface(env, him6);
 912             (*env)->SetIntField(env, iaObj, ia6_cachedscopeidID, cached_scope_id);
 913         }
 914         him6->sin6_scope_id = scopeid != 0 ? scopeid : cached_scope_id;
 915         *len = sizeof(struct SOCKADDR_IN6) ;
 916     } else {
 917         struct sockaddr_in *him4 = (struct sockaddr_in*)him;
 918         jint address;
 919         if (family != AF_INET) {
 920           JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Protocol family unavailable");
 921           return -1;
 922         }
 923         memset((char *) him4, 0, sizeof(struct sockaddr_in));
 924         address = getInetAddress_addr(env, iaObj);
 925         him4->sin_port = htons((short) port);
 926         him4->sin_addr.s_addr = (u_long) htonl(address);
 927         him4->sin_family = AF_INET;
 928         *len = sizeof(struct sockaddr_in);
 929     }
 930     return 0;
 931 }
 932 
 933 JNIEXPORT jint JNICALL
 934 NET_GetPortFromSockaddr(struct sockaddr *him) {
 935     if (him->sa_family == AF_INET6) {
 936         return ntohs(((struct sockaddr_in6*)him)->sin6_port);
 937     } else {
 938         return ntohs(((struct sockaddr_in*)him)->sin_port);
 939     }
 940 }
 941 
 942 int
 943 NET_IsIPv4Mapped(jbyte* caddr) {
 944     int i;
 945     for (i = 0; i < 10; i++) {
 946         if (caddr[i] != 0x00) {
 947             return 0; /* false */
 948         }
 949     }
 950 
 951     if (((caddr[10] & 0xff) == 0xff) && ((caddr[11] & 0xff) == 0xff)) {
 952         return 1; /* true */
 953     }
 954     return 0; /* false */
 955 }
 956 
 957 int
 958 NET_IPv4MappedToIPv4(jbyte* caddr) {
 959     return ((caddr[12] & 0xff) << 24) | ((caddr[13] & 0xff) << 16) | ((caddr[14] & 0xff) << 8)
 960         | (caddr[15] & 0xff);
 961 }
 962 
 963 int
 964 NET_IsEqual(jbyte* caddr1, jbyte* caddr2) {
 965     int i;
 966     for (i = 0; i < 16; i++) {
 967         if (caddr1[i] != caddr2[i]) {
 968             return 0; /* false */
 969         }
 970     }
 971     return 1;
 972 }
 973 
 974 int getScopeID (struct sockaddr *him) {
 975     struct SOCKADDR_IN6 *him6 = (struct SOCKADDR_IN6 *)him;
 976     return him6->sin6_scope_id;
 977 }
 978 
 979 int cmpScopeID (unsigned int scope, struct sockaddr *him) {
 980     struct SOCKADDR_IN6 *him6 = (struct SOCKADDR_IN6 *)him;
 981     return him6->sin6_scope_id == scope;
 982 }
 983 
 984 /**
 985  * Wrapper for select/poll with timeout on a single file descriptor.
 986  *
 987  * flags (defined in net_util_md.h can be any combination of
 988  * NET_WAIT_READ, NET_WAIT_WRITE & NET_WAIT_CONNECT.
 989  *
 990  * The function will return when either the socket is ready for one
 991  * of the specified operation or the timeout expired.
 992  *
 993  * It returns the time left from the timeout, or -1 if it expired.
 994  */
 995 
 996 jint
 997 NET_Wait(JNIEnv *env, jint fd, jint flags, jint timeout)
 998 {
 999     jlong prevTime = JVM_CurrentTimeMillis(env, 0);
1000     jint read_rv;
1001 
1002     while (1) {
1003         jlong newTime;
1004         fd_set rd, wr, ex;
1005         struct timeval t;
1006 
1007         t.tv_sec = timeout / 1000;
1008         t.tv_usec = (timeout % 1000) * 1000;
1009 
1010         FD_ZERO(&rd);
1011         FD_ZERO(&wr);
1012         FD_ZERO(&ex);
1013         if (flags & NET_WAIT_READ) {
1014           FD_SET(fd, &rd);
1015         }
1016         if (flags & NET_WAIT_WRITE) {
1017           FD_SET(fd, &wr);
1018         }
1019         if (flags & NET_WAIT_CONNECT) {
1020           FD_SET(fd, &wr);
1021           FD_SET(fd, &ex);
1022         }
1023 
1024         errno = 0;
1025         read_rv = select(fd+1, &rd, &wr, &ex, &t);
1026 
1027         newTime = JVM_CurrentTimeMillis(env, 0);
1028         timeout -= (jint)(newTime - prevTime);
1029         if (timeout <= 0) {
1030           return read_rv > 0 ? 0 : -1;
1031         }
1032         newTime = prevTime;
1033 
1034         if (read_rv > 0) {
1035           break;
1036         }
1037 
1038 
1039       } /* while */
1040 
1041     return timeout;
1042 }
1043 
1044 int NET_Socket (int domain, int type, int protocol) {
1045     SOCKET sock;
1046     sock = socket (domain, type, protocol);
1047     if (sock != INVALID_SOCKET) {
1048         SetHandleInformation((HANDLE)(uintptr_t)sock, HANDLE_FLAG_INHERIT, FALSE);
1049     }
1050     return (int)sock;
1051 }