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