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