1 /* 2 * Copyright (c) 2001, 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 26 #include <windows.h> 27 #include <winsock2.h> 28 #include "jni.h" 29 #include "jni_util.h" 30 #include "jvm.h" 31 #include "jlong.h" 32 33 #include "nio.h" 34 #include "nio_util.h" 35 #include "net_util.h" 36 37 #include "sun_nio_ch_Net.h" 38 #include "sun_nio_ch_PollArrayWrapper.h" 39 40 /** 41 * Definitions to allow for building with older SDK include files. 42 */ 43 44 #ifndef MCAST_BLOCK_SOURCE 45 46 #define MCAST_BLOCK_SOURCE 43 47 #define MCAST_UNBLOCK_SOURCE 44 48 #define MCAST_JOIN_SOURCE_GROUP 45 49 #define MCAST_LEAVE_SOURCE_GROUP 46 50 51 #endif /* MCAST_BLOCK_SOURCE */ 52 53 struct my_ip_mreq_source { 54 IN_ADDR imr_multiaddr; 55 IN_ADDR imr_sourceaddr; 56 IN_ADDR imr_interface; 57 }; 58 59 struct my_group_source_req { 60 ULONG gsr_interface; 61 SOCKADDR_STORAGE gsr_group; 62 SOCKADDR_STORAGE gsr_source; 63 }; 64 65 /** 66 * Copy IPv6 address as jbytearray to target 67 */ 68 #define COPY_INET6_ADDRESS(env, source, target) \ 69 (*env)->GetByteArrayRegion(env, source, 0, 16, target) 70 71 /** 72 * Enable or disable receipt of WSAECONNRESET errors. 73 */ 74 static void setConnectionReset(SOCKET s, BOOL enable) { 75 DWORD bytesReturned = 0; 76 WSAIoctl(s, SIO_UDP_CONNRESET, &enable, sizeof(enable), 77 NULL, 0, &bytesReturned, NULL, NULL); 78 } 79 80 81 JNIEXPORT void JNICALL 82 Java_sun_nio_ch_Net_initIDs(JNIEnv *env, jclass clazz) 83 { 84 initInetAddressIDs(env); 85 } 86 87 JNIEXPORT jboolean JNICALL 88 Java_sun_nio_ch_Net_isIPv6Available0(JNIEnv* env, jclass cl) 89 { 90 /* 91 * Return true if IPv6 is configured 92 */ 93 return ipv6_available() ? JNI_TRUE : JNI_FALSE; 94 } 95 96 JNIEXPORT jboolean JNICALL 97 Java_sun_nio_ch_Net_isReusePortAvailable0(JNIEnv* env, jclass c1) 98 { 99 // SO_REUSEPORT is not supported on Windows 100 return JNI_FALSE; 101 } 102 103 JNIEXPORT jint JNICALL 104 Java_sun_nio_ch_Net_isExclusiveBindAvailable(JNIEnv *env, jclass clazz) { 105 return 1; 106 } 107 108 109 JNIEXPORT jboolean JNICALL 110 Java_sun_nio_ch_Net_canIPv6SocketJoinIPv4Group0(JNIEnv* env, jclass cl) 111 { 112 return JNI_FALSE; 113 } 114 115 JNIEXPORT jboolean JNICALL 116 Java_sun_nio_ch_Net_canJoin6WithIPv4Group0(JNIEnv* env, jclass cl) 117 { 118 return JNI_FALSE; 119 } 120 121 JNIEXPORT jint JNICALL 122 Java_sun_nio_ch_Net_socket0(JNIEnv *env, jclass cl, jboolean preferIPv6, 123 jboolean stream, jboolean reuse, jboolean fastLoopback) 124 { 125 SOCKET s; 126 int domain = (preferIPv6) ? AF_INET6 : AF_INET; 127 128 s = socket(domain, (stream ? SOCK_STREAM : SOCK_DGRAM), 0); 129 if (s != INVALID_SOCKET) { 130 SetHandleInformation((HANDLE)s, HANDLE_FLAG_INHERIT, 0); 131 132 /* IPV6_V6ONLY is true by default */ 133 if (domain == AF_INET6) { 134 int opt = 0; 135 setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, 136 (const char *)&opt, sizeof(opt)); 137 } 138 139 /* Disable WSAECONNRESET errors for initially unconnected UDP sockets */ 140 if (!stream) { 141 setConnectionReset(s, FALSE); 142 } 143 144 } else { 145 NET_ThrowNew(env, WSAGetLastError(), "socket"); 146 } 147 148 if (stream && fastLoopback) { 149 static int loopback_available = 1; 150 if (loopback_available) { 151 int rv = NET_EnableFastTcpLoopback((jint)s); 152 if (rv) { 153 if (rv == WSAEOPNOTSUPP) { 154 loopback_available = 0; 155 } else { 156 NET_ThrowNew(env, rv, "fastLoopback"); 157 } 158 } 159 } 160 } 161 162 return (jint)s; 163 } 164 165 JNIEXPORT void JNICALL 166 Java_sun_nio_ch_Net_bind0(JNIEnv *env, jclass clazz, jobject fdo, jboolean preferIPv6, 167 jboolean isExclBind, jobject iao, jint port) 168 { 169 SOCKETADDRESS sa; 170 int rv; 171 int sa_len = 0; 172 173 if (NET_InetAddressToSockaddr(env, iao, port, &sa, &sa_len, preferIPv6) != 0) { 174 return; 175 } 176 177 rv = NET_WinBind(fdval(env, fdo), &sa, sa_len, isExclBind); 178 if (rv == SOCKET_ERROR) 179 NET_ThrowNew(env, WSAGetLastError(), "bind"); 180 } 181 182 JNIEXPORT void JNICALL 183 Java_sun_nio_ch_Net_listen(JNIEnv *env, jclass cl, jobject fdo, jint backlog) 184 { 185 if (listen(fdval(env,fdo), backlog) == SOCKET_ERROR) { 186 NET_ThrowNew(env, WSAGetLastError(), "listen"); 187 } 188 } 189 190 191 JNIEXPORT jint JNICALL 192 Java_sun_nio_ch_Net_connect0(JNIEnv *env, jclass clazz, jboolean preferIPv6, jobject fdo, 193 jobject iao, jint port) 194 { 195 SOCKETADDRESS sa; 196 int rv; 197 int sa_len = 0; 198 SOCKET s = (SOCKET)fdval(env, fdo); 199 200 if (NET_InetAddressToSockaddr(env, iao, port, &sa, &sa_len, preferIPv6) != 0) { 201 return IOS_THROWN; 202 } 203 204 rv = connect(s, &sa.sa, sa_len); 205 if (rv != 0) { 206 int err = WSAGetLastError(); 207 if (err == WSAEINPROGRESS || err == WSAEWOULDBLOCK) { 208 return IOS_UNAVAILABLE; 209 } 210 NET_ThrowNew(env, err, "connect"); 211 return IOS_THROWN; 212 } else { 213 /* Enable WSAECONNRESET errors when a UDP socket is connected */ 214 int type = 0, optlen = sizeof(type); 215 rv = getsockopt(s, SOL_SOCKET, SO_TYPE, (char*)&type, &optlen); 216 if (rv == 0 && type == SOCK_DGRAM) { 217 setConnectionReset(s, TRUE); 218 } 219 } 220 return 1; 221 } 222 223 JNIEXPORT jint JNICALL 224 Java_sun_nio_ch_Net_localPort(JNIEnv *env, jclass clazz, jobject fdo) 225 { 226 SOCKETADDRESS sa; 227 int sa_len = sizeof(sa); 228 229 if (getsockname(fdval(env, fdo), &sa.sa, &sa_len) < 0) { 230 int error = WSAGetLastError(); 231 if (error == WSAEINVAL) { 232 return 0; 233 } 234 NET_ThrowNew(env, error, "getsockname"); 235 return IOS_THROWN; 236 } 237 return NET_GetPortFromSockaddr(&sa); 238 } 239 240 JNIEXPORT jobject JNICALL 241 Java_sun_nio_ch_Net_localInetAddress(JNIEnv *env, jclass clazz, jobject fdo) 242 { 243 SOCKETADDRESS sa; 244 int sa_len = sizeof(sa); 245 int port; 246 247 if (getsockname(fdval(env, fdo), &sa.sa, &sa_len) < 0) { 248 NET_ThrowNew(env, WSAGetLastError(), "getsockname"); 249 return NULL; 250 } 251 return NET_SockaddrToInetAddress(env, &sa, &port); 252 } 253 254 JNIEXPORT jint JNICALL 255 Java_sun_nio_ch_Net_remotePort(JNIEnv *env, jclass clazz, jobject fdo) 256 { 257 SOCKETADDRESS sa; 258 int sa_len = sizeof(sa); 259 260 if (getpeername(fdval(env, fdo), &sa.sa, &sa_len) < 0) { 261 int error = WSAGetLastError(); 262 if (error == WSAEINVAL) { 263 return 0; 264 } 265 NET_ThrowNew(env, error, "getsockname"); 266 return IOS_THROWN; 267 } 268 return NET_GetPortFromSockaddr(&sa); 269 } 270 271 JNIEXPORT jobject JNICALL 272 Java_sun_nio_ch_Net_remoteInetAddress(JNIEnv *env, jclass clazz, jobject fdo) 273 { 274 SOCKETADDRESS sa; 275 int sa_len = sizeof(sa); 276 int port; 277 278 if (getpeername(fdval(env, fdo), &sa.sa, &sa_len) < 0) { 279 NET_ThrowNew(env, WSAGetLastError(), "getsockname"); 280 return NULL; 281 } 282 return NET_SockaddrToInetAddress(env, &sa, &port); 283 } 284 285 JNIEXPORT jint JNICALL 286 Java_sun_nio_ch_Net_getIntOption0(JNIEnv *env, jclass clazz, jobject fdo, 287 jboolean mayNeedConversion, jint level, jint opt) 288 { 289 int result = 0; 290 struct linger linger; 291 char *arg; 292 int arglen, n; 293 294 if (level == SOL_SOCKET && opt == SO_LINGER) { 295 arg = (char *)&linger; 296 arglen = sizeof(linger); 297 } else { 298 arg = (char *)&result; 299 arglen = sizeof(result); 300 } 301 302 /** 303 * HACK: IP_TOS is deprecated on Windows and querying the option 304 * returns a protocol error. NET_GetSockOpt handles this and uses 305 * a fallback mechanism. Same applies to IPV6_TCLASS 306 */ 307 if ((level == IPPROTO_IP && opt == IP_TOS) || (level == IPPROTO_IPV6 && opt == IPV6_TCLASS)) { 308 mayNeedConversion = JNI_TRUE; 309 } 310 311 if (mayNeedConversion) { 312 n = NET_GetSockOpt(fdval(env, fdo), level, opt, arg, &arglen); 313 } else { 314 n = getsockopt(fdval(env, fdo), level, opt, arg, &arglen); 315 } 316 if (n < 0) { 317 handleSocketError(env, WSAGetLastError()); 318 return IOS_THROWN; 319 } 320 321 if (level == SOL_SOCKET && opt == SO_LINGER) 322 return linger.l_onoff ? linger.l_linger : -1; 323 else 324 return result; 325 } 326 327 JNIEXPORT void JNICALL 328 Java_sun_nio_ch_Net_setIntOption0(JNIEnv *env, jclass clazz, jobject fdo, 329 jboolean mayNeedConversion, jint level, jint opt, jint arg, jboolean ipv6) 330 { 331 struct linger linger; 332 char *parg; 333 int arglen, n; 334 335 if (level == SOL_SOCKET && opt == SO_LINGER) { 336 parg = (char *)&linger; 337 arglen = sizeof(linger); 338 if (arg >= 0) { 339 linger.l_onoff = 1; 340 linger.l_linger = (unsigned short)arg; 341 } else { 342 linger.l_onoff = 0; 343 linger.l_linger = 0; 344 } 345 } else { 346 parg = (char *)&arg; 347 arglen = sizeof(arg); 348 } 349 350 if (level == IPPROTO_IPV6 && opt == IPV6_TCLASS) { 351 /* No op */ 352 return; 353 } 354 355 if (mayNeedConversion) { 356 n = NET_SetSockOpt(fdval(env, fdo), level, opt, parg, arglen); 357 } else { 358 n = setsockopt(fdval(env, fdo), level, opt, parg, arglen); 359 } 360 if (n < 0) 361 handleSocketError(env, WSAGetLastError()); 362 } 363 364 JNIEXPORT jint JNICALL 365 Java_sun_nio_ch_Net_joinOrDrop4(JNIEnv *env, jobject this, jboolean join, jobject fdo, 366 jint group, jint interf, jint source) 367 { 368 struct ip_mreq mreq; 369 struct my_ip_mreq_source mreq_source; 370 int opt, n, optlen; 371 void* optval; 372 373 if (source == 0) { 374 mreq.imr_multiaddr.s_addr = htonl(group); 375 mreq.imr_interface.s_addr = htonl(interf); 376 opt = (join) ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP; 377 optval = (void*)&mreq; 378 optlen = sizeof(mreq); 379 } else { 380 mreq_source.imr_multiaddr.s_addr = htonl(group); 381 mreq_source.imr_sourceaddr.s_addr = htonl(source); 382 mreq_source.imr_interface.s_addr = htonl(interf); 383 opt = (join) ? IP_ADD_SOURCE_MEMBERSHIP : IP_DROP_SOURCE_MEMBERSHIP; 384 optval = (void*)&mreq_source; 385 optlen = sizeof(mreq_source); 386 } 387 388 n = setsockopt(fdval(env,fdo), IPPROTO_IP, opt, optval, optlen); 389 if (n < 0) { 390 if (join && (WSAGetLastError() == WSAENOPROTOOPT)) 391 return IOS_UNAVAILABLE; 392 handleSocketError(env, WSAGetLastError()); 393 } 394 return 0; 395 } 396 397 JNIEXPORT jint JNICALL 398 Java_sun_nio_ch_Net_blockOrUnblock4(JNIEnv *env, jobject this, jboolean block, jobject fdo, 399 jint group, jint interf, jint source) 400 { 401 struct my_ip_mreq_source mreq_source; 402 int n; 403 int opt = (block) ? IP_BLOCK_SOURCE : IP_UNBLOCK_SOURCE; 404 405 mreq_source.imr_multiaddr.s_addr = htonl(group); 406 mreq_source.imr_sourceaddr.s_addr = htonl(source); 407 mreq_source.imr_interface.s_addr = htonl(interf); 408 409 n = setsockopt(fdval(env,fdo), IPPROTO_IP, opt, 410 (void*)&mreq_source, sizeof(mreq_source)); 411 if (n < 0) { 412 if (block && (WSAGetLastError() == WSAENOPROTOOPT)) 413 return IOS_UNAVAILABLE; 414 handleSocketError(env, WSAGetLastError()); 415 } 416 return 0; 417 } 418 419 /** 420 * Call setsockopt with a IPPROTO_IPV6 level socket option 421 * and a group_source_req structure as the option value. The 422 * given IPv6 group, interface index, and IPv6 source address 423 * are copied into the structure. 424 */ 425 static int setGroupSourceReqOption(JNIEnv* env, 426 jobject fdo, 427 int opt, 428 jbyteArray group, 429 jint index, 430 jbyteArray source) 431 { 432 struct my_group_source_req req; 433 struct sockaddr_in6* sin6; 434 435 req.gsr_interface = (ULONG)index; 436 437 sin6 = (struct sockaddr_in6*)&(req.gsr_group); 438 sin6->sin6_family = AF_INET6; 439 COPY_INET6_ADDRESS(env, group, (jbyte*)&(sin6->sin6_addr)); 440 441 sin6 = (struct sockaddr_in6*)&(req.gsr_source); 442 sin6->sin6_family = AF_INET6; 443 COPY_INET6_ADDRESS(env, source, (jbyte*)&(sin6->sin6_addr)); 444 445 return setsockopt(fdval(env,fdo), IPPROTO_IPV6, opt, (void*)&req, sizeof(req)); 446 } 447 448 JNIEXPORT jint JNICALL 449 Java_sun_nio_ch_Net_joinOrDrop6(JNIEnv *env, jobject this, jboolean join, jobject fdo, 450 jbyteArray group, jint index, jbyteArray source) 451 { 452 struct ipv6_mreq mreq6; 453 int n; 454 455 if (source == NULL) { 456 int opt = (join) ? IPV6_ADD_MEMBERSHIP : IPV6_DROP_MEMBERSHIP; 457 COPY_INET6_ADDRESS(env, group, (jbyte*)&(mreq6.ipv6mr_multiaddr)); 458 mreq6.ipv6mr_interface = (int)index; 459 n = setsockopt(fdval(env,fdo), IPPROTO_IPV6, opt, 460 (void*)&mreq6, sizeof(mreq6)); 461 } else { 462 int opt = (join) ? MCAST_JOIN_SOURCE_GROUP : MCAST_LEAVE_SOURCE_GROUP; 463 n = setGroupSourceReqOption(env, fdo, opt, group, index, source); 464 } 465 466 if (n < 0) { 467 handleSocketError(env, errno); 468 } 469 return 0; 470 } 471 472 JNIEXPORT jint JNICALL 473 Java_sun_nio_ch_Net_blockOrUnblock6(JNIEnv *env, jobject this, jboolean block, jobject fdo, 474 jbyteArray group, jint index, jbyteArray source) 475 { 476 int opt = (block) ? MCAST_BLOCK_SOURCE : MCAST_UNBLOCK_SOURCE; 477 int n = setGroupSourceReqOption(env, fdo, opt, group, index, source); 478 if (n < 0) { 479 handleSocketError(env, errno); 480 } 481 return 0; 482 } 483 484 JNIEXPORT void JNICALL 485 Java_sun_nio_ch_Net_setInterface4(JNIEnv* env, jobject this, jobject fdo, jint interf) 486 { 487 struct in_addr in; 488 int arglen = sizeof(struct in_addr); 489 int n; 490 491 in.s_addr = htonl(interf); 492 493 n = setsockopt(fdval(env, fdo), IPPROTO_IP, IP_MULTICAST_IF, 494 (void*)&(in.s_addr), arglen); 495 if (n < 0) { 496 handleSocketError(env, WSAGetLastError()); 497 } 498 } 499 500 JNIEXPORT jint JNICALL 501 Java_sun_nio_ch_Net_getInterface4(JNIEnv* env, jobject this, jobject fdo) 502 { 503 struct in_addr in; 504 int arglen = sizeof(struct in_addr); 505 int n; 506 507 n = getsockopt(fdval(env, fdo), IPPROTO_IP, IP_MULTICAST_IF, (void*)&in, &arglen); 508 if (n < 0) { 509 handleSocketError(env, WSAGetLastError()); 510 return IOS_THROWN; 511 } 512 return ntohl(in.s_addr); 513 } 514 515 JNIEXPORT void JNICALL 516 Java_sun_nio_ch_Net_setInterface6(JNIEnv* env, jobject this, jobject fdo, jint index) 517 { 518 int value = (jint)index; 519 int arglen = sizeof(value); 520 int n; 521 522 n = setsockopt(fdval(env, fdo), IPPROTO_IPV6, IPV6_MULTICAST_IF, 523 (void*)&(index), arglen); 524 if (n < 0) { 525 handleSocketError(env, errno); 526 } 527 } 528 529 JNIEXPORT jint JNICALL 530 Java_sun_nio_ch_Net_getInterface6(JNIEnv* env, jobject this, jobject fdo) 531 { 532 int index; 533 int arglen = sizeof(index); 534 int n; 535 536 n = getsockopt(fdval(env, fdo), IPPROTO_IPV6, IPV6_MULTICAST_IF, (void*)&index, &arglen); 537 if (n < 0) { 538 handleSocketError(env, errno); 539 return -1; 540 } 541 return (jint)index; 542 } 543 544 JNIEXPORT void JNICALL 545 Java_sun_nio_ch_Net_shutdown(JNIEnv *env, jclass cl, jobject fdo, jint jhow) { 546 int how = (jhow == sun_nio_ch_Net_SHUT_RD) ? SD_RECEIVE : 547 (jhow == sun_nio_ch_Net_SHUT_WR) ? SD_SEND : SD_BOTH; 548 if (shutdown(fdval(env, fdo), how) == SOCKET_ERROR) { 549 NET_ThrowNew(env, WSAGetLastError(), "shutdown"); 550 } 551 } 552 553 JNIEXPORT jint JNICALL 554 Java_sun_nio_ch_Net_poll(JNIEnv* env, jclass this, jobject fdo, jint events, jlong timeout) 555 { 556 int rv; 557 int revents = 0; 558 struct timeval t; 559 int lastError = 0; 560 fd_set rd, wr, ex; 561 jint fd = fdval(env, fdo); 562 563 t.tv_sec = (long)(timeout / 1000); 564 t.tv_usec = (timeout % 1000) * 1000; 565 566 FD_ZERO(&rd); 567 FD_ZERO(&wr); 568 FD_ZERO(&ex); 569 if (events & POLLIN) { 570 FD_SET(fd, &rd); 571 } 572 if (events & POLLOUT || 573 events & POLLCONN) { 574 FD_SET(fd, &wr); 575 } 576 FD_SET(fd, &ex); 577 578 rv = select(fd+1, &rd, &wr, &ex, &t); 579 580 /* save last winsock error */ 581 if (rv == SOCKET_ERROR) { 582 handleSocketError(env, lastError); 583 return IOS_THROWN; 584 } else if (rv >= 0) { 585 rv = 0; 586 if (FD_ISSET(fd, &rd)) { 587 rv |= POLLIN; 588 } 589 if (FD_ISSET(fd, &wr)) { 590 rv |= POLLOUT; 591 } 592 if (FD_ISSET(fd, &ex)) { 593 rv |= POLLERR; 594 } 595 } 596 return rv; 597 } 598 599 JNIEXPORT jshort JNICALL 600 Java_sun_nio_ch_Net_pollinValue(JNIEnv *env, jclass this) 601 { 602 return (jshort)POLLIN; 603 } 604 605 JNIEXPORT jshort JNICALL 606 Java_sun_nio_ch_Net_polloutValue(JNIEnv *env, jclass this) 607 { 608 return (jshort)POLLOUT; 609 } 610 611 JNIEXPORT jshort JNICALL 612 Java_sun_nio_ch_Net_pollerrValue(JNIEnv *env, jclass this) 613 { 614 return (jshort)POLLERR; 615 } 616 617 JNIEXPORT jshort JNICALL 618 Java_sun_nio_ch_Net_pollhupValue(JNIEnv *env, jclass this) 619 { 620 return (jshort)POLLHUP; 621 } 622 623 JNIEXPORT jshort JNICALL 624 Java_sun_nio_ch_Net_pollnvalValue(JNIEnv *env, jclass this) 625 { 626 return (jshort)POLLNVAL; 627 } 628 629 JNIEXPORT jshort JNICALL 630 Java_sun_nio_ch_Net_pollconnValue(JNIEnv *env, jclass this) 631 { 632 return (jshort)POLLCONN; 633 }