1 /*
2 * Copyright (c) 1997, 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 <errno.h>
27 #include <netinet/in.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <sys/types.h>
31 #include <sys/socket.h>
32
33 #ifdef __solaris__
34 #include <fcntl.h>
35 #include <unistd.h>
36 #include <stropts.h>
37
38 #ifndef BSD_COMP
39 #define BSD_COMP
40 #endif
41 #endif
42 #ifdef __linux__
43 #include <unistd.h>
44 #include <sys/sysctl.h>
45 #include <sys/utsname.h>
46 #include <netinet/ip.h>
47
48 #define IPV6_MULTICAST_IF 17
49 #ifndef SO_BSDCOMPAT
50 #define SO_BSDCOMPAT 14
51 #endif
52 /**
53 * IP_MULTICAST_ALL has been supported since kernel version 2.6.31
54 * but we may be building on a machine that is older than that.
55 */
56 #ifndef IP_MULTICAST_ALL
57 #define IP_MULTICAST_ALL 49
58 #endif
59 #endif // __linux__
60
61 #include <sys/ioctl.h>
62
63 #ifndef IPTOS_TOS_MASK
64 #define IPTOS_TOS_MASK 0x1e
65 #endif
66 #ifndef IPTOS_PREC_MASK
67 #define IPTOS_PREC_MASK 0xe0
68 #endif
69
70 #include "jvm.h"
71 #include "jni_util.h"
72 #include "net_util.h"
73 #include "java_net_SocketOptions.h"
74 #include "java_net_PlainDatagramSocketImpl.h"
75 #include "java_net_NetworkInterface.h"
76 /************************************************************************
77 * PlainDatagramSocketImpl
78 */
79
80 static jfieldID IO_fd_fdID;
81
82 static jfieldID pdsi_fdID;
83 static jfieldID pdsi_timeoutID;
84 static jfieldID pdsi_trafficClassID;
85 static jfieldID pdsi_localPortID;
86 static jfieldID pdsi_connected;
87 static jfieldID pdsi_connectedAddress;
88 static jfieldID pdsi_connectedPort;
89
90 extern void setDefaultScopeID(JNIEnv *env, struct sockaddr *him);
91 extern int getDefaultScopeID(JNIEnv *env);
92
93
94 /*
95 * Returns a java.lang.Integer based on 'i'
96 */
97 static jobject createInteger(JNIEnv *env, int i) {
98 static jclass i_class;
99 static jmethodID i_ctrID;
100
101 if (i_class == NULL) {
102 jclass c = (*env)->FindClass(env, "java/lang/Integer");
103 CHECK_NULL_RETURN(c, NULL);
104 i_ctrID = (*env)->GetMethodID(env, c, "<init>", "(I)V");
105 CHECK_NULL_RETURN(i_ctrID, NULL);
106 i_class = (*env)->NewGlobalRef(env, c);
107 CHECK_NULL_RETURN(i_class, NULL);
108 }
109
110 return ( (*env)->NewObject(env, i_class, i_ctrID, i) );
111 }
112
113 /*
114 * Returns a java.lang.Boolean based on 'b'
115 */
116 static jobject createBoolean(JNIEnv *env, int b) {
117 static jclass b_class;
118 static jmethodID b_ctrID;
119
120 if (b_class == NULL) {
121 jclass c = (*env)->FindClass(env, "java/lang/Boolean");
122 CHECK_NULL_RETURN(c, NULL);
123 b_ctrID = (*env)->GetMethodID(env, c, "<init>", "(Z)V");
124 CHECK_NULL_RETURN(b_ctrID, NULL);
125 b_class = (*env)->NewGlobalRef(env, c);
126 CHECK_NULL_RETURN(b_class, NULL);
127 }
128
129 return( (*env)->NewObject(env, b_class, b_ctrID, (jboolean)(b!=0)) );
130 }
131
132
133 /*
134 * Returns the fd for a PlainDatagramSocketImpl or -1
135 * if closed.
136 */
137 static int getFD(JNIEnv *env, jobject this) {
138 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
139 if (fdObj == NULL) {
140 return -1;
141 }
142 return (*env)->GetIntField(env, fdObj, IO_fd_fdID);
143 }
144
145
146 /*
147 * Class: java_net_PlainDatagramSocketImpl
148 * Method: init
149 * Signature: ()V
150 */
151 JNIEXPORT void JNICALL
152 Java_java_net_PlainDatagramSocketImpl_init(JNIEnv *env, jclass cls) {
153
154 #ifdef __linux__
155 struct utsname sysinfo;
156 #endif
157 pdsi_fdID = (*env)->GetFieldID(env, cls, "fd",
158 "Ljava/io/FileDescriptor;");
159 CHECK_NULL(pdsi_fdID);
160 pdsi_timeoutID = (*env)->GetFieldID(env, cls, "timeout", "I");
161 CHECK_NULL(pdsi_timeoutID);
162 pdsi_trafficClassID = (*env)->GetFieldID(env, cls, "trafficClass", "I");
163 CHECK_NULL(pdsi_trafficClassID);
164 pdsi_localPortID = (*env)->GetFieldID(env, cls, "localPort", "I");
165 CHECK_NULL(pdsi_localPortID);
166 pdsi_connected = (*env)->GetFieldID(env, cls, "connected", "Z");
167 CHECK_NULL(pdsi_connected);
168 pdsi_connectedAddress = (*env)->GetFieldID(env, cls, "connectedAddress",
169 "Ljava/net/InetAddress;");
170 CHECK_NULL(pdsi_connectedAddress);
171 pdsi_connectedPort = (*env)->GetFieldID(env, cls, "connectedPort", "I");
172 CHECK_NULL(pdsi_connectedPort);
173
174 IO_fd_fdID = NET_GetFileDescriptorID(env);
175 CHECK_NULL(IO_fd_fdID);
176
177 initInetAddressIDs(env);
178 JNU_CHECK_EXCEPTION(env);
179 Java_java_net_NetworkInterface_init(env, 0);
180
181 }
182
183 /*
184 * Class: java_net_PlainDatagramSocketImpl
185 * Method: bind
186 * Signature: (ILjava/net/InetAddress;)V
187 */
188 JNIEXPORT void JNICALL
189 Java_java_net_PlainDatagramSocketImpl_bind0(JNIEnv *env, jobject this,
190 jint localport, jobject iaObj) {
191 /* fdObj is the FileDescriptor field on this */
192 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
193 /* fd is an int field on fdObj */
194 int fd;
195 int len = 0;
196 SOCKADDR him;
197 socklen_t slen = sizeof(him);
198
199 if (IS_NULL(fdObj)) {
200 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
201 "Socket closed");
202 return;
203 } else {
204 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
205 }
206
207 if (IS_NULL(iaObj)) {
208 JNU_ThrowNullPointerException(env, "iaObj is null.");
209 return;
210 }
211
212 /* bind */
213 if (NET_InetAddressToSockaddr(env, iaObj, localport, (struct sockaddr *)&him, &len, JNI_TRUE) != 0) {
214 return;
215 }
216 setDefaultScopeID(env, (struct sockaddr *)&him);
217
218 if (NET_Bind(fd, (struct sockaddr *)&him, len) < 0) {
219 if (errno == EADDRINUSE || errno == EADDRNOTAVAIL ||
220 errno == EPERM || errno == EACCES) {
221 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "BindException",
222 "Bind failed");
223 } else {
224 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
225 "Bind failed");
226 }
227 return;
228 }
229
230 /* initialize the local port */
231 if (localport == 0) {
232 /* Now that we're a connected socket, let's extract the port number
233 * that the system chose for us and store it in the Socket object.
234 */
235 if (getsockname(fd, (struct sockaddr *)&him, &slen) == -1) {
236 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
237 "Error getting socket name");
238 return;
239 }
240
241 localport = NET_GetPortFromSockaddr((struct sockaddr *)&him);
242
243 (*env)->SetIntField(env, this, pdsi_localPortID, localport);
244 } else {
245 (*env)->SetIntField(env, this, pdsi_localPortID, localport);
246 }
247 }
248
249 /*
250 * Class: java_net_PlainDatagramSocketImpl
251 * Method: connect0
252 * Signature: (Ljava/net/InetAddress;I)V
253 */
254 JNIEXPORT void JNICALL
255 Java_java_net_PlainDatagramSocketImpl_connect0(JNIEnv *env, jobject this,
256 jobject address, jint port) {
257 /* The object's field */
258 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
259 /* The fdObj'fd */
260 jint fd;
261 /* The packetAddress address, family and port */
262 SOCKADDR rmtaddr;
263 int len = 0;
264
265 if (IS_NULL(fdObj)) {
266 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
267 "Socket closed");
268 return;
269 }
270 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
271
272 if (IS_NULL(address)) {
273 JNU_ThrowNullPointerException(env, "address");
274 return;
275 }
276
277 if (NET_InetAddressToSockaddr(env, address, port, (struct sockaddr *)&rmtaddr, &len, JNI_TRUE) != 0) {
278 return;
279 }
280
281 setDefaultScopeID(env, (struct sockaddr *)&rmtaddr);
282
283 if (NET_Connect(fd, (struct sockaddr *)&rmtaddr, len) == -1) {
284 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "ConnectException",
285 "Connect failed");
286 return;
287 }
288
289 }
290
291 /*
292 * Class: java_net_PlainDatagramSocketImpl
293 * Method: disconnect0
294 * Signature: ()V
295 */
296 JNIEXPORT void JNICALL
297 Java_java_net_PlainDatagramSocketImpl_disconnect0(JNIEnv *env, jobject this, jint family) {
298 /* The object's field */
299 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
300 /* The fdObj'fd */
301 jint fd;
302
303 #if defined(__linux__) || defined(_ALLBSD_SOURCE)
304 SOCKADDR addr;
305 socklen_t len;
306 #endif
307
308 if (IS_NULL(fdObj)) {
309 return;
310 }
311 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
312
313 #if defined(__linux__) || defined(_ALLBSD_SOURCE)
314 memset(&addr, 0, sizeof(addr));
315 #ifdef AF_INET6
316 if (ipv6_available()) {
317 struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)&addr;
318 him6->sin6_family = AF_UNSPEC;
319 len = sizeof(struct sockaddr_in6);
320 } else
321 #endif
322 {
323 struct sockaddr_in *him4 = (struct sockaddr_in*)&addr;
324 him4->sin_family = AF_UNSPEC;
325 len = sizeof(struct sockaddr_in);
326 }
327 NET_Connect(fd, (struct sockaddr *)&addr, len);
328
329 #ifdef __linux__
330 int localPort = 0;
331 if (getsockname(fd, (struct sockaddr *)&addr, &len) == -1)
332 return;
333
334 localPort = NET_GetPortFromSockaddr((struct sockaddr *)&addr);
335 if (localPort == 0) {
336 localPort = (*env)->GetIntField(env, this, pdsi_localPortID);
337 #ifdef AF_INET6
338 if (((struct sockaddr*)&addr)->sa_family == AF_INET6) {
339 ((struct sockaddr_in6*)&addr)->sin6_port = htons(localPort);
340 } else
341 #endif /* AF_INET6 */
342 {
343 ((struct sockaddr_in*)&addr)->sin_port = htons(localPort);
344 }
345
346 NET_Bind(fd, (struct sockaddr *)&addr, len);
347 }
348
349 #endif
350 #else
351 NET_Connect(fd, 0, 0);
352 #endif
353 }
354
355 /*
356 * Class: java_net_PlainDatagramSocketImpl
357 * Method: send
358 * Signature: (Ljava/net/DatagramPacket;)V
359 */
360 JNIEXPORT void JNICALL
361 Java_java_net_PlainDatagramSocketImpl_send(JNIEnv *env, jobject this,
362 jobject packet) {
363
364 char BUF[MAX_BUFFER_LEN];
365 char *fullPacket = NULL;
366 int ret, mallocedPacket = JNI_FALSE;
367 /* The object's field */
368 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
369 jint trafficClass = (*env)->GetIntField(env, this, pdsi_trafficClassID);
370
371 jbyteArray packetBuffer;
372 jobject packetAddress;
373 jint packetBufferOffset, packetBufferLen, packetPort;
374 jboolean connected;
375
376 /* The fdObj'fd */
377 jint fd;
378
379 SOCKADDR rmtaddr, *rmtaddrP=&rmtaddr;
380 int len;
381
382 if (IS_NULL(fdObj)) {
383 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
384 "Socket closed");
385 return;
386 }
387 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
388
389 if (IS_NULL(packet)) {
390 JNU_ThrowNullPointerException(env, "packet");
391 return;
392 }
393
394 connected = (*env)->GetBooleanField(env, this, pdsi_connected);
395
396 packetBuffer = (*env)->GetObjectField(env, packet, dp_bufID);
397 packetAddress = (*env)->GetObjectField(env, packet, dp_addressID);
398 if (IS_NULL(packetBuffer) || IS_NULL(packetAddress)) {
399 JNU_ThrowNullPointerException(env, "null buffer || null address");
400 return;
401 }
402
403 packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
404 packetBufferLen = (*env)->GetIntField(env, packet, dp_lengthID);
405
406 if (connected) {
407 /* arg to NET_Sendto () null in this case */
408 len = 0;
409 rmtaddrP = 0;
410 } else {
411 packetPort = (*env)->GetIntField(env, packet, dp_portID);
412 if (NET_InetAddressToSockaddr(env, packetAddress, packetPort, (struct sockaddr *)&rmtaddr, &len, JNI_TRUE) != 0) {
413 return;
414 }
415 }
416 setDefaultScopeID(env, (struct sockaddr *)&rmtaddr);
417
418 if (packetBufferLen > MAX_BUFFER_LEN) {
419 /* When JNI-ifying the JDK's IO routines, we turned
420 * reads and writes of byte arrays of size greater
421 * than 2048 bytes into several operations of size 2048.
422 * This saves a malloc()/memcpy()/free() for big
423 * buffers. This is OK for file IO and TCP, but that
424 * strategy violates the semantics of a datagram protocol.
425 * (one big send) != (several smaller sends). So here
426 * we *must* allocate the buffer. Note it needn't be bigger
427 * than 65,536 (0xFFFF), the max size of an IP packet.
428 * Anything bigger should be truncated anyway.
429 *
430 * We may want to use a smarter allocation scheme at some
431 * point.
432 */
433 if (packetBufferLen > MAX_PACKET_LEN) {
434 packetBufferLen = MAX_PACKET_LEN;
435 }
436 fullPacket = (char *)malloc(packetBufferLen);
437
438 if (!fullPacket) {
439 JNU_ThrowOutOfMemoryError(env, "Send buffer native heap allocation failed");
440 return;
441 } else {
442 mallocedPacket = JNI_TRUE;
443 }
444 } else {
445 fullPacket = &(BUF[0]);
446 }
447
448 (*env)->GetByteArrayRegion(env, packetBuffer, packetBufferOffset, packetBufferLen,
449 (jbyte *)fullPacket);
450 #ifdef AF_INET6
451 if (trafficClass != 0 && ipv6_available()) {
452 NET_SetTrafficClass((struct sockaddr *)&rmtaddr, trafficClass);
453 }
454 #endif /* AF_INET6 */
455
456
457 /*
458 * Send the datagram.
459 *
460 * If we are connected it's possible that sendto will return
461 * ECONNREFUSED indicating that an ICMP port unreachable has
462 * received.
463 */
464 ret = NET_SendTo(fd, fullPacket, packetBufferLen, 0,
465 (struct sockaddr *)rmtaddrP, len);
466
467 if (ret < 0) {
468 if (errno == ECONNREFUSED) {
469 JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",
470 "ICMP Port Unreachable");
471 } else {
472 NET_ThrowByNameWithLastError(env, "java/io/IOException", "sendto failed");
473 }
474 }
475
476 if (mallocedPacket) {
477 free(fullPacket);
478 }
479 return;
480 }
481
482 /*
483 * Class: java_net_PlainDatagramSocketImpl
484 * Method: peek
485 * Signature: (Ljava/net/InetAddress;)I
486 */
487 JNIEXPORT jint JNICALL
488 Java_java_net_PlainDatagramSocketImpl_peek(JNIEnv *env, jobject this,
489 jobject addressObj) {
490
491 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
492 jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
493 jint fd;
494 ssize_t n;
495 SOCKADDR remote_addr;
496 socklen_t slen = SOCKADDR_LEN;
497 char buf[1];
498 jint family;
499 jobject iaObj;
500 int port;
501 if (IS_NULL(fdObj)) {
502 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
503 return -1;
504 } else {
505 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
506 }
507 if (IS_NULL(addressObj)) {
508 JNU_ThrowNullPointerException(env, "Null address in peek()");
509 return -1;
510 }
511 if (timeout) {
512 int ret = NET_Timeout(fd, timeout);
513 if (ret == 0) {
514 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
515 "Peek timed out");
516 return ret;
517 } else if (ret == -1) {
518 if (errno == EBADF) {
519 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
520 } else if (errno == ENOMEM) {
521 JNU_ThrowOutOfMemoryError(env, "NET_Timeout native heap allocation failed");
522 } else {
523 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Peek failed");
524 }
525 return ret;
526 }
527 }
528
529 n = NET_RecvFrom(fd, buf, 1, MSG_PEEK, (struct sockaddr *)&remote_addr, &slen);
530
531 if (n == -1) {
532
533 #ifdef __solaris__
534 if (errno == ECONNREFUSED) {
535 int orig_errno = errno;
536 (void) recv(fd, buf, 1, 0);
537 errno = orig_errno;
538 }
539 #endif
540 if (errno == ECONNREFUSED) {
541 JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",
542 "ICMP Port Unreachable");
543 } else {
544 if (errno == EBADF) {
545 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
546 } else {
547 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Peek failed");
548 }
549 }
550 return 0;
551 }
552
553 iaObj = NET_SockaddrToInetAddress(env, (struct sockaddr *)&remote_addr, &port);
554 #ifdef AF_INET6
555 family = getInetAddress_family(env, iaObj) == IPv4? AF_INET : AF_INET6;
556 #else
557 family = AF_INET;
558 #endif
559 if (family == AF_INET) { /* this API can't handle IPV6 addresses */
560 int address = getInetAddress_addr(env, iaObj);
561 setInetAddress_addr(env, addressObj, address);
562 }
563 return port;
564 }
565
566 JNIEXPORT jint JNICALL
567 Java_java_net_PlainDatagramSocketImpl_peekData(JNIEnv *env, jobject this,
568 jobject packet) {
569
570 char BUF[MAX_BUFFER_LEN];
571 char *fullPacket = NULL;
572 int mallocedPacket = JNI_FALSE;
573 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
574 jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
575
576 jbyteArray packetBuffer;
577 jint packetBufferOffset, packetBufferLen;
578
579 int fd;
580
581 int n;
582 SOCKADDR remote_addr;
583 socklen_t slen = SOCKADDR_LEN;
584 int port;
585
586 if (IS_NULL(fdObj)) {
587 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
588 "Socket closed");
589 return -1;
590 }
591
592 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
593
594 if (IS_NULL(packet)) {
595 JNU_ThrowNullPointerException(env, "packet");
596 return -1;
597 }
598
599 packetBuffer = (*env)->GetObjectField(env, packet, dp_bufID);
600 if (IS_NULL(packetBuffer)) {
601 JNU_ThrowNullPointerException(env, "packet buffer");
602 return -1;
603 }
604 packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
605 packetBufferLen = (*env)->GetIntField(env, packet, dp_bufLengthID);
606 if (timeout) {
607 int ret = NET_Timeout(fd, timeout);
608 if (ret == 0) {
609 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
610 "Receive timed out");
611 return -1;
612 } else if (ret == -1) {
613 if (errno == ENOMEM) {
614 JNU_ThrowOutOfMemoryError(env, "NET_Timeout native heap allocation failed");
615 #ifdef __linux__
616 } else if (errno == EBADF) {
617 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
618 } else {
619 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
620 #else
621 } else {
622 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
623 #endif
624 }
625 return -1;
626 }
627 }
628
629 if (packetBufferLen > MAX_BUFFER_LEN) {
630
631 /* When JNI-ifying the JDK's IO routines, we turned
632 * reads and writes of byte arrays of size greater
633 * than 2048 bytes into several operations of size 2048.
634 * This saves a malloc()/memcpy()/free() for big
635 * buffers. This is OK for file IO and TCP, but that
636 * strategy violates the semantics of a datagram protocol.
637 * (one big send) != (several smaller sends). So here
638 * we *must* allocate the buffer. Note it needn't be bigger
639 * than 65,536 (0xFFFF), the max size of an IP packet.
640 * anything bigger is truncated anyway.
641 *
642 * We may want to use a smarter allocation scheme at some
643 * point.
644 */
645 if (packetBufferLen > MAX_PACKET_LEN) {
646 packetBufferLen = MAX_PACKET_LEN;
647 }
648 fullPacket = (char *)malloc(packetBufferLen);
649
650 if (!fullPacket) {
651 JNU_ThrowOutOfMemoryError(env, "Peek buffer native heap allocation failed");
652 return -1;
653 } else {
654 mallocedPacket = JNI_TRUE;
655 }
656 } else {
657 fullPacket = &(BUF[0]);
658 }
659
660 n = NET_RecvFrom(fd, fullPacket, packetBufferLen, MSG_PEEK,
661 (struct sockaddr *)&remote_addr, &slen);
662 /* truncate the data if the packet's length is too small */
663 if (n > packetBufferLen) {
664 n = packetBufferLen;
665 }
666 if (n == -1) {
667
668 #ifdef __solaris__
669 if (errno == ECONNREFUSED) {
670 int orig_errno = errno;
671 (void) recv(fd, fullPacket, 1, 0);
672 errno = orig_errno;
673 }
674 #endif
675 (*env)->SetIntField(env, packet, dp_offsetID, 0);
676 (*env)->SetIntField(env, packet, dp_lengthID, 0);
677 if (errno == ECONNREFUSED) {
678 JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",
679 "ICMP Port Unreachable");
680 } else {
681 if (errno == EBADF) {
682 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
683 } else {
684 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
685 }
686 }
687 } else {
688 /*
689 * success - fill in received address...
690 *
691 * REMIND: Fill in an int on the packet, and create inetadd
692 * object in Java, as a performance improvement. Also
693 * construct the inetadd object lazily.
694 */
695
696 jobject packetAddress;
697
698 /*
699 * Check if there is an InetAddress already associated with this
700 * packet. If so we check if it is the same source address. We
701 * can't update any existing InetAddress because it is immutable
702 */
703 packetAddress = (*env)->GetObjectField(env, packet, dp_addressID);
704 if (packetAddress != NULL) {
705 if (!NET_SockaddrEqualsInetAddress(env, (struct sockaddr *)&remote_addr, packetAddress)) {
706 /* force a new InetAddress to be created */
707 packetAddress = NULL;
708 }
709 }
710 if (packetAddress == NULL) {
711 packetAddress = NET_SockaddrToInetAddress(env, (struct sockaddr *)&remote_addr, &port);
712 /* stuff the new Inetaddress in the packet */
713 (*env)->SetObjectField(env, packet, dp_addressID, packetAddress);
714 } else {
715 /* only get the new port number */
716 port = NET_GetPortFromSockaddr((struct sockaddr *)&remote_addr);
717 }
718 /* and fill in the data, remote address/port and such */
719 (*env)->SetByteArrayRegion(env, packetBuffer, packetBufferOffset, n,
720 (jbyte *)fullPacket);
721 (*env)->SetIntField(env, packet, dp_portID, port);
722 (*env)->SetIntField(env, packet, dp_lengthID, n);
723 }
724
725 if (mallocedPacket) {
726 free(fullPacket);
727 }
728 return port;
729 }
730
731 /*
732 * Class: java_net_PlainDatagramSocketImpl
733 * Method: receive
734 * Signature: (Ljava/net/DatagramPacket;)V
735 */
736 JNIEXPORT void JNICALL
737 Java_java_net_PlainDatagramSocketImpl_receive0(JNIEnv *env, jobject this,
738 jobject packet) {
739
740 char BUF[MAX_BUFFER_LEN];
741 char *fullPacket = NULL;
742 int mallocedPacket = JNI_FALSE;
743 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
744 jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
745
746 jbyteArray packetBuffer;
747 jint packetBufferOffset, packetBufferLen;
748
749 int fd;
750
751 int n;
752 SOCKADDR remote_addr;
753 socklen_t slen = SOCKADDR_LEN;
754 jboolean retry;
755 #ifdef __linux__
756 jboolean connected = JNI_FALSE;
757 jobject connectedAddress = NULL;
758 jint connectedPort = 0;
759 jlong prevTime = 0;
760 #endif
761
762 if (IS_NULL(fdObj)) {
763 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
764 "Socket closed");
765 return;
766 }
767
768 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
769
770 if (IS_NULL(packet)) {
771 JNU_ThrowNullPointerException(env, "packet");
772 return;
773 }
774
775 packetBuffer = (*env)->GetObjectField(env, packet, dp_bufID);
776 if (IS_NULL(packetBuffer)) {
777 JNU_ThrowNullPointerException(env, "packet buffer");
778 return;
779 }
780 packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
781 packetBufferLen = (*env)->GetIntField(env, packet, dp_bufLengthID);
782
783 if (packetBufferLen > MAX_BUFFER_LEN) {
784
785 /* When JNI-ifying the JDK's IO routines, we turned
786 * reads and writes of byte arrays of size greater
787 * than 2048 bytes into several operations of size 2048.
788 * This saves a malloc()/memcpy()/free() for big
789 * buffers. This is OK for file IO and TCP, but that
790 * strategy violates the semantics of a datagram protocol.
791 * (one big send) != (several smaller sends). So here
792 * we *must* allocate the buffer. Note it needn't be bigger
793 * than 65,536 (0xFFFF) the max size of an IP packet,
794 * anything bigger is truncated anyway.
795 *
796 * We may want to use a smarter allocation scheme at some
797 * point.
798 */
799 if (packetBufferLen > MAX_PACKET_LEN) {
800 packetBufferLen = MAX_PACKET_LEN;
801 }
802 fullPacket = (char *)malloc(packetBufferLen);
803
804 if (!fullPacket) {
805 JNU_ThrowOutOfMemoryError(env, "Receive buffer native heap allocation failed");
806 return;
807 } else {
808 mallocedPacket = JNI_TRUE;
809 }
810 } else {
811 fullPacket = &(BUF[0]);
812 }
813
814 do {
815 retry = JNI_FALSE;
816
817 if (timeout) {
818 int ret = NET_Timeout(fd, timeout);
819 if (ret <= 0) {
820 if (ret == 0) {
821 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
822 "Receive timed out");
823 } else if (ret == -1) {
824 if (errno == ENOMEM) {
825 JNU_ThrowOutOfMemoryError(env, "NET_Timeout native heap allocation failed");
826 #ifdef __linux__
827 } else if (errno == EBADF) {
828 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
829 } else {
830 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
831 #else
832 } else {
833 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
834 #endif
835 }
836 }
837
838 if (mallocedPacket) {
839 free(fullPacket);
840 }
841
842 return;
843 }
844 }
845
846 n = NET_RecvFrom(fd, fullPacket, packetBufferLen, 0,
847 (struct sockaddr *)&remote_addr, &slen);
848 /* truncate the data if the packet's length is too small */
849 if (n > packetBufferLen) {
850 n = packetBufferLen;
851 }
852 if (n == -1) {
853 (*env)->SetIntField(env, packet, dp_offsetID, 0);
854 (*env)->SetIntField(env, packet, dp_lengthID, 0);
855 if (errno == ECONNREFUSED) {
856 JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",
857 "ICMP Port Unreachable");
858 } else {
859 if (errno == EBADF) {
860 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
861 } else {
862 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Receive failed");
863 }
864 }
865 } else {
866 int port;
867 jobject packetAddress;
868
869 /*
870 * success - fill in received address...
871 *
872 * REMIND: Fill in an int on the packet, and create inetadd
873 * object in Java, as a performance improvement. Also
874 * construct the inetadd object lazily.
875 */
876
877 /*
878 * Check if there is an InetAddress already associated with this
879 * packet. If so we check if it is the same source address. We
880 * can't update any existing InetAddress because it is immutable
881 */
882 packetAddress = (*env)->GetObjectField(env, packet, dp_addressID);
883 if (packetAddress != NULL) {
884 if (!NET_SockaddrEqualsInetAddress(env, (struct sockaddr *)&remote_addr, packetAddress)) {
885 /* force a new InetAddress to be created */
886 packetAddress = NULL;
887 }
888 }
889 if (packetAddress == NULL) {
890 packetAddress = NET_SockaddrToInetAddress(env, (struct sockaddr *)&remote_addr, &port);
891 /* stuff the new Inetaddress in the packet */
892 (*env)->SetObjectField(env, packet, dp_addressID, packetAddress);
893 } else {
894 /* only get the new port number */
895 port = NET_GetPortFromSockaddr((struct sockaddr *)&remote_addr);
896 }
897 /* and fill in the data, remote address/port and such */
898 (*env)->SetByteArrayRegion(env, packetBuffer, packetBufferOffset, n,
899 (jbyte *)fullPacket);
900 (*env)->SetIntField(env, packet, dp_portID, port);
901 (*env)->SetIntField(env, packet, dp_lengthID, n);
902 }
903
904 } while (retry);
905
906 if (mallocedPacket) {
907 free(fullPacket);
908 }
909 }
910
911 /*
912 * Class: java_net_PlainDatagramSocketImpl
913 * Method: datagramSocketCreate
914 * Signature: ()V
915 */
916 JNIEXPORT void JNICALL
917 Java_java_net_PlainDatagramSocketImpl_datagramSocketCreate(JNIEnv *env,
918 jobject this) {
919 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
920 int arg, fd, t = 1;
921 #ifdef AF_INET6
922 int domain = ipv6_available() ? AF_INET6 : AF_INET;
923 #else
924 int domain = AF_INET;
925 #endif
926
927 if (IS_NULL(fdObj)) {
928 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
929 "Socket closed");
930 return;
931 }
932
933 if ((fd = socket(domain, SOCK_DGRAM, 0)) == -1) {
934 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
935 "Error creating socket");
936 return;
937 }
938
939 #ifdef AF_INET6
940 /* Disable IPV6_V6ONLY to ensure dual-socket support */
941 if (domain == AF_INET6) {
942 arg = 0;
943 if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&arg,
944 sizeof(int)) < 0) {
945 NET_ThrowNew(env, errno, "cannot set IPPROTO_IPV6");
946 close(fd);
947 return;
948 }
949 }
950 #endif /* AF_INET6 */
951
952 #ifdef __APPLE__
953 arg = 65507;
954 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF,
955 (char *)&arg, sizeof(arg)) < 0) {
956 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
957 strerror(errno));
958 return;
959 }
960 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
961 (char *)&arg, sizeof(arg)) < 0) {
962 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
963 strerror(errno));
964 return;
965 }
966 #endif /* __APPLE__ */
967
968 setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (char*) &t, sizeof(int));
969
970 #if defined(__linux__)
971 arg = 0;
972 int level = (domain == AF_INET6) ? IPPROTO_IPV6 : IPPROTO_IP;
973 if ((setsockopt(fd, level, IP_MULTICAST_ALL, (char*)&arg, sizeof(arg)) < 0) &&
974 (errno != ENOPROTOOPT)) {
975 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
976 strerror(errno));
977 close(fd);
978 return;
979 }
980 #endif
981
982 #if defined (__linux__) && defined (AF_INET6)
983 /*
984 * On Linux for IPv6 sockets we must set the hop limit
985 * to 1 to be compatible with default TTL of 1 for IPv4 sockets.
986 */
987 if (domain == AF_INET6) {
988 int ttl = 1;
989 setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&ttl,
990 sizeof(ttl));
991 }
992 #endif /* __linux__ */
993
994 (*env)->SetIntField(env, fdObj, IO_fd_fdID, fd);
995 }
996
997 /*
998 * Class: java_net_PlainDatagramSocketImpl
999 * Method: datagramSocketClose
1000 * Signature: ()V
1001 */
1002 JNIEXPORT void JNICALL
1003 Java_java_net_PlainDatagramSocketImpl_datagramSocketClose(JNIEnv *env,
1004 jobject this) {
1005 /*
1006 * REMIND: PUT A LOCK AROUND THIS CODE
1007 */
1008 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
1009 int fd;
1010
1011 if (IS_NULL(fdObj)) {
1012 return;
1013 }
1014 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1015 if (fd == -1) {
1016 return;
1017 }
1018 (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
1019 NET_SocketClose(fd);
1020 }
1021
1022
1023 /*
1024 * Set outgoing multicast interface designated by a NetworkInterface.
1025 * Throw exception if failed.
1026 */
1027 static void mcast_set_if_by_if_v4(JNIEnv *env, jobject this, int fd, jobject value) {
1028 static jfieldID ni_addrsID;
1029 struct in_addr in;
1030 jobjectArray addrArray;
1031 jsize len;
1032 jobject addr;
1033 int i;
1034
1035 if (ni_addrsID == NULL ) {
1036 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1037 CHECK_NULL(c);
1038 ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1039 "[Ljava/net/InetAddress;");
1040 CHECK_NULL(ni_addrsID);
1041 }
1042
1043 addrArray = (*env)->GetObjectField(env, value, ni_addrsID);
1044 len = (*env)->GetArrayLength(env, addrArray);
1045
1046 /*
1047 * Check that there is at least one address bound to this
1048 * interface.
1049 */
1050 if (len < 1) {
1051 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1052 "bad argument for IP_MULTICAST_IF2: No IP addresses bound to interface");
1053 return;
1054 }
1055
1056 /*
1057 * We need an ipv4 address here
1058 */
1059 for (i = 0; i < len; i++) {
1060 addr = (*env)->GetObjectArrayElement(env, addrArray, i);
1061 if (getInetAddress_family(env, addr) == IPv4) {
1062 in.s_addr = htonl(getInetAddress_addr(env, addr));
1063 break;
1064 }
1065 }
1066
1067 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1068 (const char*)&in, sizeof(in)) < 0) {
1069 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1070 "Error setting socket option");
1071 }
1072 }
1073
1074 /*
1075 * Set outgoing multicast interface designated by a NetworkInterface.
1076 * Throw exception if failed.
1077 */
1078 #ifdef AF_INET6
1079 static void mcast_set_if_by_if_v6(JNIEnv *env, jobject this, int fd, jobject value) {
1080 static jfieldID ni_indexID;
1081 int index;
1082
1083 if (ni_indexID == NULL) {
1084 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1085 CHECK_NULL(c);
1086 ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1087 CHECK_NULL(ni_indexID);
1088 }
1089 index = (*env)->GetIntField(env, value, ni_indexID);
1090
1091 if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
1092 (const char*)&index, sizeof(index)) < 0) {
1093 if (errno == EINVAL && index > 0) {
1094 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1095 "IPV6_MULTICAST_IF failed (interface has IPv4 "
1096 "address only?)");
1097 } else {
1098 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1099 "Error setting socket option");
1100 }
1101 return;
1102 }
1103
1104 }
1105 #endif /* AF_INET6 */
1106
1107 /*
1108 * Set outgoing multicast interface designated by an InetAddress.
1109 * Throw exception if failed.
1110 */
1111 static void mcast_set_if_by_addr_v4(JNIEnv *env, jobject this, int fd, jobject value) {
1112 struct in_addr in;
1113
1114 in.s_addr = htonl( getInetAddress_addr(env, value) );
1115
1116 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1117 (const char*)&in, sizeof(in)) < 0) {
1118 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1119 "Error setting socket option");
1120 }
1121 }
1122
1123 /*
1124 * Set outgoing multicast interface designated by an InetAddress.
1125 * Throw exception if failed.
1126 */
1127 #ifdef AF_INET6
1128 static void mcast_set_if_by_addr_v6(JNIEnv *env, jobject this, int fd, jobject value) {
1129 static jclass ni_class;
1130 if (ni_class == NULL) {
1131 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1132 CHECK_NULL(c);
1133 ni_class = (*env)->NewGlobalRef(env, c);
1134 CHECK_NULL(ni_class);
1135 }
1136
1137 value = Java_java_net_NetworkInterface_getByInetAddress0(env, ni_class, value);
1138 if (value == NULL) {
1139 if (!(*env)->ExceptionOccurred(env)) {
1140 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1141 "bad argument for IP_MULTICAST_IF"
1142 ": address not bound to any interface");
1143 }
1144 return;
1145 }
1146
1147 mcast_set_if_by_if_v6(env, this, fd, value);
1148 }
1149 #endif
1150
1151 /*
1152 * Sets the multicast interface.
1153 *
1154 * SocketOptions.IP_MULTICAST_IF :-
1155 * value is a InetAddress
1156 * IPv4: set outgoing multicast interface using
1157 * IPPROTO_IP/IP_MULTICAST_IF
1158 * IPv6: Get the index of the interface to which the
1159 * InetAddress is bound
1160 * Set outgoing multicast interface using
1161 * IPPROTO_IPV6/IPV6_MULTICAST_IF
1162 *
1163 * SockOptions.IF_MULTICAST_IF2 :-
1164 * value is a NetworkInterface
1165 * IPv4: Obtain IP address bound to network interface
1166 * (NetworkInterface.addres[0])
1167 * set outgoing multicast interface using
1168 * IPPROTO_IP/IP_MULTICAST_IF
1169 * IPv6: Obtain NetworkInterface.index
1170 * Set outgoing multicast interface using
1171 * IPPROTO_IPV6/IPV6_MULTICAST_IF
1172 *
1173 */
1174 static void setMulticastInterface(JNIEnv *env, jobject this, int fd,
1175 jint opt, jobject value)
1176 {
1177 if (opt == java_net_SocketOptions_IP_MULTICAST_IF) {
1178 /*
1179 * value is an InetAddress.
1180 */
1181 #ifdef AF_INET6
1182 #ifdef __linux__
1183 mcast_set_if_by_addr_v4(env, this, fd, value);
1184 if (ipv6_available()) {
1185 if ((*env)->ExceptionCheck(env)){
1186 (*env)->ExceptionClear(env);
1187 }
1188 mcast_set_if_by_addr_v6(env, this, fd, value);
1189 }
1190 #else /* __linux__ not defined */
1191 if (ipv6_available()) {
1192 mcast_set_if_by_addr_v6(env, this, fd, value);
1193 } else {
1194 mcast_set_if_by_addr_v4(env, this, fd, value);
1195 }
1196 #endif /* __linux__ */
1197 #else
1198 mcast_set_if_by_addr_v4(env, this, fd, value);
1199 #endif /* AF_INET6 */
1200 }
1201
1202 if (opt == java_net_SocketOptions_IP_MULTICAST_IF2) {
1203 /*
1204 * value is a NetworkInterface.
1205 */
1206 #ifdef AF_INET6
1207 #ifdef __linux__
1208 mcast_set_if_by_if_v4(env, this, fd, value);
1209 if (ipv6_available()) {
1210 if ((*env)->ExceptionCheck(env)){
1211 (*env)->ExceptionClear(env);
1212 }
1213 mcast_set_if_by_if_v6(env, this, fd, value);
1214 }
1215 #else /* __linux__ not defined */
1216 if (ipv6_available()) {
1217 mcast_set_if_by_if_v6(env, this, fd, value);
1218 } else {
1219 mcast_set_if_by_if_v4(env, this, fd, value);
1220 }
1221 #endif /* __linux__ */
1222 #else
1223 mcast_set_if_by_if_v4(env, this, fd, value);
1224 #endif /* AF_INET6 */
1225 }
1226 }
1227
1228 /*
1229 * Enable/disable local loopback of multicast datagrams.
1230 */
1231 static void mcast_set_loop_v4(JNIEnv *env, jobject this, int fd, jobject value) {
1232 jclass cls;
1233 jfieldID fid;
1234 jboolean on;
1235 char loopback;
1236
1237 cls = (*env)->FindClass(env, "java/lang/Boolean");
1238 CHECK_NULL(cls);
1239 fid = (*env)->GetFieldID(env, cls, "value", "Z");
1240 CHECK_NULL(fid);
1241
1242 on = (*env)->GetBooleanField(env, value, fid);
1243 loopback = (!on ? 1 : 0);
1244
1245 if (NET_SetSockOpt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, (const void *)&loopback, sizeof(char)) < 0) {
1246 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1247 return;
1248 }
1249 }
1250
1251 /*
1252 * Enable/disable local loopback of multicast datagrams.
1253 */
1254 #ifdef AF_INET6
1255 static void mcast_set_loop_v6(JNIEnv *env, jobject this, int fd, jobject value) {
1256 jclass cls;
1257 jfieldID fid;
1258 jboolean on;
1259 int loopback;
1260
1261 cls = (*env)->FindClass(env, "java/lang/Boolean");
1262 CHECK_NULL(cls);
1263 fid = (*env)->GetFieldID(env, cls, "value", "Z");
1264 CHECK_NULL(fid);
1265
1266 on = (*env)->GetBooleanField(env, value, fid);
1267 loopback = (!on ? 1 : 0);
1268
1269 if (NET_SetSockOpt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (const void *)&loopback, sizeof(int)) < 0) {
1270 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1271 return;
1272 }
1273
1274 }
1275 #endif /* AF_INET6 */
1276
1277 /*
1278 * Sets the multicast loopback mode.
1279 */
1280 static void setMulticastLoopbackMode(JNIEnv *env, jobject this, int fd,
1281 jint opt, jobject value) {
1282 #ifdef AF_INET6
1283 #ifdef __linux__
1284 mcast_set_loop_v4(env, this, fd, value);
1285 if (ipv6_available()) {
1286 if ((*env)->ExceptionCheck(env)){
1287 (*env)->ExceptionClear(env);
1288 }
1289 mcast_set_loop_v6(env, this, fd, value);
1290 }
1291 #else /* __linux__ not defined */
1292 if (ipv6_available()) {
1293 mcast_set_loop_v6(env, this, fd, value);
1294 } else {
1295 mcast_set_loop_v4(env, this, fd, value);
1296 }
1297 #endif /* __linux__ */
1298 #else
1299 mcast_set_loop_v4(env, this, fd, value);
1300 #endif /* AF_INET6 */
1301 }
1302
1303 /*
1304 * Class: java_net_PlainDatagramSocketImpl
1305 * Method: socketSetOption0
1306 * Signature: (ILjava/lang/Object;)V
1307 */
1308 JNIEXPORT void JNICALL
1309 Java_java_net_PlainDatagramSocketImpl_socketSetOption0(JNIEnv *env,
1310 jobject this,
1311 jint opt,
1312 jobject value) {
1313 int fd;
1314 int level, optname, optlen;
1315 int optval;
1316 optlen = sizeof(int);
1317
1318 /*
1319 * Check that socket hasn't been closed
1320 */
1321 fd = getFD(env, this);
1322 if (fd < 0) {
1323 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1324 "Socket closed");
1325 return;
1326 }
1327
1328 /*
1329 * Check argument has been provided
1330 */
1331 if (IS_NULL(value)) {
1332 JNU_ThrowNullPointerException(env, "value argument");
1333 return;
1334 }
1335
1336 /*
1337 * Setting the multicast interface handled separately
1338 */
1339 if (opt == java_net_SocketOptions_IP_MULTICAST_IF ||
1340 opt == java_net_SocketOptions_IP_MULTICAST_IF2) {
1341
1342 setMulticastInterface(env, this, fd, opt, value);
1343 return;
1344 }
1345
1346 /*
1347 * Setting the multicast loopback mode handled separately
1348 */
1349 if (opt == java_net_SocketOptions_IP_MULTICAST_LOOP) {
1350 setMulticastLoopbackMode(env, this, fd, opt, value);
1351 return;
1352 }
1353
1354 /*
1355 * Map the Java level socket option to the platform specific
1356 * level and option name.
1357 */
1358 if (NET_MapSocketOption(opt, &level, &optname)) {
1359 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Invalid option");
1360 return;
1361 }
1362
1363 switch (opt) {
1364 case java_net_SocketOptions_SO_SNDBUF :
1365 case java_net_SocketOptions_SO_RCVBUF :
1366 case java_net_SocketOptions_IP_TOS :
1367 {
1368 jclass cls;
1369 jfieldID fid;
1370
1371 cls = (*env)->FindClass(env, "java/lang/Integer");
1372 CHECK_NULL(cls);
1373 fid = (*env)->GetFieldID(env, cls, "value", "I");
1374 CHECK_NULL(fid);
1375
1376 optval = (*env)->GetIntField(env, value, fid);
1377 break;
1378 }
1379
1380 case java_net_SocketOptions_SO_REUSEADDR:
1381 case java_net_SocketOptions_SO_BROADCAST:
1382 {
1383 jclass cls;
1384 jfieldID fid;
1385 jboolean on;
1386
1387 cls = (*env)->FindClass(env, "java/lang/Boolean");
1388 CHECK_NULL(cls);
1389 fid = (*env)->GetFieldID(env, cls, "value", "Z");
1390 CHECK_NULL(fid);
1391
1392 on = (*env)->GetBooleanField(env, value, fid);
1393
1394 /* SO_REUSEADDR or SO_BROADCAST */
1395 optval = (on ? 1 : 0);
1396
1397 break;
1398 }
1399
1400 default :
1401 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1402 "Socket option not supported by PlainDatagramSocketImp");
1403 return;
1404
1405 }
1406
1407 if (NET_SetSockOpt(fd, level, optname, (const void *)&optval, optlen) < 0) {
1408 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1409 return;
1410 }
1411 }
1412
1413
1414 /*
1415 * Return the multicast interface:
1416 *
1417 * SocketOptions.IP_MULTICAST_IF
1418 * IPv4: Query IPPROTO_IP/IP_MULTICAST_IF
1419 * Create InetAddress
1420 * IP_MULTICAST_IF returns struct ip_mreqn on 2.2
1421 * kernel but struct in_addr on 2.4 kernel
1422 * IPv6: Query IPPROTO_IPV6 / IPV6_MULTICAST_IF
1423 * If index == 0 return InetAddress representing
1424 * anyLocalAddress.
1425 * If index > 0 query NetworkInterface by index
1426 * and returns addrs[0]
1427 *
1428 * SocketOptions.IP_MULTICAST_IF2
1429 * IPv4: Query IPPROTO_IP/IP_MULTICAST_IF
1430 * Query NetworkInterface by IP address and
1431 * return the NetworkInterface that the address
1432 * is bound too.
1433 * IPv6: Query IPPROTO_IPV6 / IPV6_MULTICAST_IF
1434 * (except Linux .2 kernel)
1435 * Query NetworkInterface by index and
1436 * return NetworkInterface.
1437 */
1438 jobject getMulticastInterface(JNIEnv *env, jobject this, int fd, jint opt) {
1439 jboolean isIPV4 = JNI_TRUE;
1440
1441 #ifdef AF_INET6
1442 if (ipv6_available()) {
1443 isIPV4 = JNI_FALSE;
1444 }
1445 #endif
1446
1447 /*
1448 * IPv4 implementation
1449 */
1450 if (isIPV4) {
1451 static jclass inet4_class;
1452 static jmethodID inet4_ctrID;
1453
1454 static jclass ni_class;
1455 static jmethodID ni_ctrID;
1456 static jfieldID ni_indexID;
1457 static jfieldID ni_addrsID;
1458 static jfieldID ni_nameID;
1459
1460 jobjectArray addrArray;
1461 jobject addr;
1462 jobject ni;
1463 jobject ni_name;
1464
1465 struct in_addr in;
1466 struct in_addr *inP = ∈
1467 socklen_t len = sizeof(struct in_addr);
1468
1469 if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1470 (char *)inP, &len) < 0) {
1471 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1472 "Error getting socket option");
1473 return NULL;
1474 }
1475
1476 /*
1477 * Construct and populate an Inet4Address
1478 */
1479 if (inet4_class == NULL) {
1480 jclass c = (*env)->FindClass(env, "java/net/Inet4Address");
1481 CHECK_NULL_RETURN(c, NULL);
1482 inet4_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1483 CHECK_NULL_RETURN(inet4_ctrID, NULL);
1484 inet4_class = (*env)->NewGlobalRef(env, c);
1485 CHECK_NULL_RETURN(inet4_class, NULL);
1486 }
1487 addr = (*env)->NewObject(env, inet4_class, inet4_ctrID, 0);
1488 CHECK_NULL_RETURN(addr, NULL);
1489
1490 setInetAddress_addr(env, addr, ntohl(in.s_addr));
1491
1492 /*
1493 * For IP_MULTICAST_IF return InetAddress
1494 */
1495 if (opt == java_net_SocketOptions_IP_MULTICAST_IF) {
1496 return addr;
1497 }
1498
1499 /*
1500 * For IP_MULTICAST_IF2 we get the NetworkInterface for
1501 * this address and return it
1502 */
1503 if (ni_class == NULL) {
1504 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1505 CHECK_NULL_RETURN(c, NULL);
1506 ni_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1507 CHECK_NULL_RETURN(ni_ctrID, NULL);
1508 ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1509 CHECK_NULL_RETURN(ni_indexID, NULL);
1510 ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1511 "[Ljava/net/InetAddress;");
1512 CHECK_NULL_RETURN(ni_addrsID, NULL);
1513 ni_nameID = (*env)->GetFieldID(env, c,"name", "Ljava/lang/String;");
1514 CHECK_NULL_RETURN(ni_nameID, NULL);
1515 ni_class = (*env)->NewGlobalRef(env, c);
1516 CHECK_NULL_RETURN(ni_class, NULL);
1517 }
1518 ni = Java_java_net_NetworkInterface_getByInetAddress0(env, ni_class, addr);
1519 if (ni) {
1520 return ni;
1521 }
1522
1523 /*
1524 * The address doesn't appear to be bound at any known
1525 * NetworkInterface. Therefore we construct a NetworkInterface
1526 * with this address.
1527 */
1528 ni = (*env)->NewObject(env, ni_class, ni_ctrID, 0);
1529 CHECK_NULL_RETURN(ni, NULL);
1530
1531 (*env)->SetIntField(env, ni, ni_indexID, -1);
1532 addrArray = (*env)->NewObjectArray(env, 1, inet4_class, NULL);
1533 CHECK_NULL_RETURN(addrArray, NULL);
1534 (*env)->SetObjectArrayElement(env, addrArray, 0, addr);
1535 (*env)->SetObjectField(env, ni, ni_addrsID, addrArray);
1536 ni_name = (*env)->NewStringUTF(env, "");
1537 if (ni_name != NULL) {
1538 (*env)->SetObjectField(env, ni, ni_nameID, ni_name);
1539 }
1540 return ni;
1541 }
1542
1543
1544 #ifdef AF_INET6
1545 /*
1546 * IPv6 implementation
1547 */
1548 if ((opt == java_net_SocketOptions_IP_MULTICAST_IF) ||
1549 (opt == java_net_SocketOptions_IP_MULTICAST_IF2)) {
1550
1551 static jclass ni_class;
1552 static jmethodID ni_ctrID;
1553 static jfieldID ni_indexID;
1554 static jfieldID ni_addrsID;
1555 static jclass ia_class;
1556 static jfieldID ni_nameID;
1557 static jmethodID ia_anyLocalAddressID;
1558
1559 int index = 0;
1560 socklen_t len = sizeof(index);
1561
1562 jobjectArray addrArray;
1563 jobject addr;
1564 jobject ni;
1565 jobject ni_name;
1566
1567 if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
1568 (char*)&index, &len) < 0) {
1569 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1570 "Error getting socket option");
1571 return NULL;
1572 }
1573
1574 if (ni_class == NULL) {
1575 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1576 CHECK_NULL_RETURN(c, NULL);
1577 ni_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1578 CHECK_NULL_RETURN(ni_ctrID, NULL);
1579 ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1580 CHECK_NULL_RETURN(ni_indexID, NULL);
1581 ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1582 "[Ljava/net/InetAddress;");
1583 CHECK_NULL_RETURN(ni_addrsID, NULL);
1584
1585 ia_class = (*env)->FindClass(env, "java/net/InetAddress");
1586 CHECK_NULL_RETURN(ia_class, NULL);
1587 ia_class = (*env)->NewGlobalRef(env, ia_class);
1588 CHECK_NULL_RETURN(ia_class, NULL);
1589 ia_anyLocalAddressID = (*env)->GetStaticMethodID(env,
1590 ia_class,
1591 "anyLocalAddress",
1592 "()Ljava/net/InetAddress;");
1593 CHECK_NULL_RETURN(ia_anyLocalAddressID, NULL);
1594 ni_nameID = (*env)->GetFieldID(env, c,"name", "Ljava/lang/String;");
1595 CHECK_NULL_RETURN(ni_nameID, NULL);
1596 ni_class = (*env)->NewGlobalRef(env, c);
1597 CHECK_NULL_RETURN(ni_class, NULL);
1598 }
1599
1600 /*
1601 * If multicast to a specific interface then return the
1602 * interface (for IF2) or the any address on that interface
1603 * (for IF).
1604 */
1605 if (index > 0) {
1606 ni = Java_java_net_NetworkInterface_getByIndex0(env, ni_class,
1607 index);
1608 if (ni == NULL) {
1609 char errmsg[255];
1610 sprintf(errmsg,
1611 "IPV6_MULTICAST_IF returned index to unrecognized interface: %d",
1612 index);
1613 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", errmsg);
1614 return NULL;
1615 }
1616
1617 /*
1618 * For IP_MULTICAST_IF2 return the NetworkInterface
1619 */
1620 if (opt == java_net_SocketOptions_IP_MULTICAST_IF2) {
1621 return ni;
1622 }
1623
1624 /*
1625 * For IP_MULTICAST_IF return addrs[0]
1626 */
1627 addrArray = (*env)->GetObjectField(env, ni, ni_addrsID);
1628 if ((*env)->GetArrayLength(env, addrArray) < 1) {
1629 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1630 "IPV6_MULTICAST_IF returned interface without IP bindings");
1631 return NULL;
1632 }
1633
1634 addr = (*env)->GetObjectArrayElement(env, addrArray, 0);
1635 return addr;
1636 }
1637
1638 /*
1639 * Multicast to any address - return anyLocalAddress
1640 * or a NetworkInterface with addrs[0] set to anyLocalAddress
1641 */
1642
1643 addr = (*env)->CallStaticObjectMethod(env, ia_class, ia_anyLocalAddressID,
1644 NULL);
1645 if (opt == java_net_SocketOptions_IP_MULTICAST_IF) {
1646 return addr;
1647 }
1648
1649 ni = (*env)->NewObject(env, ni_class, ni_ctrID, 0);
1650 CHECK_NULL_RETURN(ni, NULL);
1651 (*env)->SetIntField(env, ni, ni_indexID, -1);
1652 addrArray = (*env)->NewObjectArray(env, 1, ia_class, NULL);
1653 CHECK_NULL_RETURN(addrArray, NULL);
1654 (*env)->SetObjectArrayElement(env, addrArray, 0, addr);
1655 (*env)->SetObjectField(env, ni, ni_addrsID, addrArray);
1656 ni_name = (*env)->NewStringUTF(env, "");
1657 if (ni_name != NULL) {
1658 (*env)->SetObjectField(env, ni, ni_nameID, ni_name);
1659 }
1660 return ni;
1661 }
1662 #endif
1663 return NULL;
1664 }
1665
1666
1667
1668 /*
1669 * Returns relevant info as a jint.
1670 *
1671 * Class: java_net_PlainDatagramSocketImpl
1672 * Method: socketGetOption
1673 * Signature: (I)Ljava/lang/Object;
1674 */
1675 JNIEXPORT jobject JNICALL
1676 Java_java_net_PlainDatagramSocketImpl_socketGetOption(JNIEnv *env, jobject this,
1677 jint opt) {
1678 int fd;
1679 int level, optname, optlen;
1680 union {
1681 int i;
1682 char c;
1683 } optval;
1684
1685 fd = getFD(env, this);
1686 if (fd < 0) {
1687 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1688 "socket closed");
1689 return NULL;
1690 }
1691
1692 /*
1693 * Handle IP_MULTICAST_IF separately
1694 */
1695 if (opt == java_net_SocketOptions_IP_MULTICAST_IF ||
1696 opt == java_net_SocketOptions_IP_MULTICAST_IF2) {
1697 return getMulticastInterface(env, this, fd, opt);
1698
1699 }
1700
1701 /*
1702 * SO_BINDADDR implemented using getsockname
1703 */
1704 if (opt == java_net_SocketOptions_SO_BINDADDR) {
1705 /* find out local IP address */
1706 SOCKADDR him;
1707 socklen_t len = 0;
1708 int port;
1709 jobject iaObj;
1710
1711 len = SOCKADDR_LEN;
1712
1713 if (getsockname(fd, (struct sockaddr *)&him, &len) == -1) {
1714 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1715 "Error getting socket name");
1716 return NULL;
1717 }
1718 iaObj = NET_SockaddrToInetAddress(env, (struct sockaddr *)&him, &port);
1719
1720 return iaObj;
1721 }
1722
1723 /*
1724 * Map the Java level socket option to the platform specific
1725 * level and option name.
1726 */
1727 if (NET_MapSocketOption(opt, &level, &optname)) {
1728 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Invalid option");
1729 return NULL;
1730 }
1731
1732 if (opt == java_net_SocketOptions_IP_MULTICAST_LOOP &&
1733 level == IPPROTO_IP) {
1734 optlen = sizeof(optval.c);
1735 } else {
1736 optlen = sizeof(optval.i);
1737 }
1738
1739 if (NET_GetSockOpt(fd, level, optname, (void *)&optval, &optlen) < 0) {
1740 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1741 "Error getting socket option");
1742 return NULL;
1743 }
1744
1745 switch (opt) {
1746 case java_net_SocketOptions_IP_MULTICAST_LOOP:
1747 /* getLoopbackMode() returns true if IP_MULTICAST_LOOP disabled */
1748 if (level == IPPROTO_IP) {
1749 return createBoolean(env, (int)!optval.c);
1750 } else {
1751 return createBoolean(env, !optval.i);
1752 }
1753
1754 case java_net_SocketOptions_SO_BROADCAST:
1755 case java_net_SocketOptions_SO_REUSEADDR:
1756 return createBoolean(env, optval.i);
1757
1758 case java_net_SocketOptions_SO_SNDBUF:
1759 case java_net_SocketOptions_SO_RCVBUF:
1760 case java_net_SocketOptions_IP_TOS:
1761 return createInteger(env, optval.i);
1762
1763 }
1764
1765 /* should never reach here */
1766 return NULL;
1767 }
1768
1769 /*
1770 * Multicast-related calls
1771 */
1772
1773 JNIEXPORT void JNICALL
1774 Java_java_net_PlainDatagramSocketImpl_setTTL(JNIEnv *env, jobject this,
1775 jbyte ttl) {
1776 jint ittl = ttl;
1777 if (ittl < 0) {
1778 ittl += 0x100;
1779 }
1780 Java_java_net_PlainDatagramSocketImpl_setTimeToLive(env, this, ittl);
1781 }
1782
1783 /*
1784 * Set TTL for a socket. Throw exception if failed.
1785 */
1786 static void setTTL(JNIEnv *env, int fd, jint ttl) {
1787 char ittl = (char)ttl;
1788 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&ittl,
1789 sizeof(ittl)) < 0) {
1790 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1791 "Error setting socket option");
1792 }
1793 }
1794
1795 /*
1796 * Set hops limit for a socket. Throw exception if failed.
1797 */
1798 #ifdef AF_INET6
1799 static void setHopLimit(JNIEnv *env, int fd, jint ttl) {
1800 int ittl = (int)ttl;
1801 if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
1802 (char*)&ittl, sizeof(ittl)) < 0) {
1803 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1804 "Error setting socket option");
1805 }
1806 }
1807 #endif
1808
1809 /*
1810 * Class: java_net_PlainDatagramSocketImpl
1811 * Method: setTTL
1812 * Signature: (B)V
1813 */
1814 JNIEXPORT void JNICALL
1815 Java_java_net_PlainDatagramSocketImpl_setTimeToLive(JNIEnv *env, jobject this,
1816 jint ttl) {
1817
1818 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
1819 int fd;
1820 /* it is important to cast this to a char, otherwise setsockopt gets confused */
1821
1822 if (IS_NULL(fdObj)) {
1823 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1824 "Socket closed");
1825 return;
1826 } else {
1827 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1828 }
1829 /* setsockopt to be correct TTL */
1830 #ifdef AF_INET6
1831 #ifdef __linux__
1832 setTTL(env, fd, ttl);
1833 JNU_CHECK_EXCEPTION(env);
1834 if (ipv6_available()) {
1835 setHopLimit(env, fd, ttl);
1836 }
1837 #else /* __linux__ not defined */
1838 if (ipv6_available()) {
1839 setHopLimit(env, fd, ttl);
1840 } else {
1841 setTTL(env, fd, ttl);
1842 }
1843 #endif /* __linux__ */
1844 #else
1845 setTTL(env, fd, ttl);
1846 #endif /* AF_INET6 */
1847 }
1848
1849 /*
1850 * Class: java_net_PlainDatagramSocketImpl
1851 * Method: getTTL
1852 * Signature: ()B
1853 */
1854 JNIEXPORT jbyte JNICALL
1855 Java_java_net_PlainDatagramSocketImpl_getTTL(JNIEnv *env, jobject this) {
1856 return (jbyte)Java_java_net_PlainDatagramSocketImpl_getTimeToLive(env, this);
1857 }
1858
1859
1860 /*
1861 * Class: java_net_PlainDatagramSocketImpl
1862 * Method: getTTL
1863 * Signature: ()B
1864 */
1865 JNIEXPORT jint JNICALL
1866 Java_java_net_PlainDatagramSocketImpl_getTimeToLive(JNIEnv *env, jobject this) {
1867
1868 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
1869 jint fd = -1;
1870
1871 if (IS_NULL(fdObj)) {
1872 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1873 "Socket closed");
1874 return -1;
1875 } else {
1876 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1877 }
1878 /* getsockopt of TTL */
1879 #ifdef AF_INET6
1880 if (ipv6_available()) {
1881 int ttl = 0;
1882 socklen_t len = sizeof(ttl);
1883
1884 if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
1885 (char*)&ttl, &len) < 0) {
1886 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1887 "Error getting socket option");
1888 return -1;
1889 }
1890 return (jint)ttl;
1891 } else
1892 #endif /* AF_INET6 */
1893 {
1894 u_char ttl = 0;
1895 socklen_t len = sizeof(ttl);
1896 if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL,
1897 (char*)&ttl, &len) < 0) {
1898 NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
1899 "Error getting socket option");
1900 return -1;
1901 }
1902 return (jint)ttl;
1903 }
1904 }
1905
1906
1907 /*
1908 * mcast_join_leave: Join or leave a multicast group.
1909 *
1910 * For IPv4 sockets use IP_ADD_MEMBERSHIP/IP_DROP_MEMBERSHIP socket option
1911 * to join/leave multicast group.
1912 *
1913 * For IPv6 sockets use IPV6_ADD_MEMBERSHIP/IPV6_DROP_MEMBERSHIP socket option
1914 * to join/leave multicast group. If multicast group is an IPv4 address then
1915 * an IPv4-mapped address is used.
1916 *
1917 * On Linux with IPv6 if we wish to join/leave an IPv4 multicast group then
1918 * we must use the IPv4 socket options. This is because the IPv6 socket options
1919 * don't support IPv4-mapped addresses. This is true as per 2.2.19 and 2.4.7
1920 * kernel releases. In the future it's possible that IP_ADD_MEMBERSHIP
1921 * will be updated to return ENOPROTOOPT if uses with an IPv6 socket (Solaris
1922 * already does this). Thus to cater for this we first try with the IPv4
1923 * socket options and if they fail we use the IPv6 socket options. This
1924 * seems a reasonable failsafe solution.
1925 */
1926 static void mcast_join_leave(JNIEnv *env, jobject this,
1927 jobject iaObj, jobject niObj,
1928 jboolean join) {
1929
1930 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
1931 jint fd;
1932 jint ipv6_join_leave;
1933
1934 if (IS_NULL(fdObj)) {
1935 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1936 "Socket closed");
1937 return;
1938 } else {
1939 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1940 }
1941 if (IS_NULL(iaObj)) {
1942 JNU_ThrowNullPointerException(env, "iaObj");
1943 return;
1944 }
1945
1946 /*
1947 * Determine if this is an IPv4 or IPv6 join/leave.
1948 */
1949 #ifdef AF_INET6
1950 ipv6_join_leave = ipv6_available();
1951
1952 #ifdef __linux__
1953 if (getInetAddress_family(env, iaObj) == IPv4) {
1954 ipv6_join_leave = JNI_FALSE;
1955 }
1956 #endif
1957
1958 #else
1959 /*
1960 * IPv6 not compiled in
1961 */
1962 ipv6_join_leave = JNI_FALSE;
1963 #endif
1964
1965 /*
1966 * For IPv4 join use IP_ADD_MEMBERSHIP/IP_DROP_MEMBERSHIP socket option
1967 *
1968 * On Linux if IPv4 or IPv6 use IP_ADD_MEMBERSHIP/IP_DROP_MEMBERSHIP
1969 */
1970 if (!ipv6_join_leave) {
1971 #ifdef __linux__
1972 struct ip_mreqn mname;
1973 #else
1974 struct ip_mreq mname;
1975 #endif
1976 int mname_len;
1977
1978 /*
1979 * joinGroup(InetAddress, NetworkInterface) implementation :-
1980 *
1981 * Linux/IPv6: use ip_mreqn structure populated with multicast
1982 * address and interface index.
1983 *
1984 * IPv4: use ip_mreq structure populated with multicast
1985 * address and first address obtained from
1986 * NetworkInterface
1987 */
1988 if (niObj != NULL) {
1989 #if defined(__linux__) && defined(AF_INET6)
1990 if (ipv6_available()) {
1991 static jfieldID ni_indexID;
1992
1993 if (ni_indexID == NULL) {
1994 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1995 CHECK_NULL(c);
1996 ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1997 CHECK_NULL(ni_indexID);
1998 }
1999
2000 mname.imr_multiaddr.s_addr = htonl(getInetAddress_addr(env, iaObj));
2001 mname.imr_address.s_addr = 0;
2002 mname.imr_ifindex = (*env)->GetIntField(env, niObj, ni_indexID);
2003 mname_len = sizeof(struct ip_mreqn);
2004 } else
2005 #endif
2006 {
2007 jobjectArray addrArray = (*env)->GetObjectField(env, niObj, ni_addrsID);
2008 jobject addr;
2009
2010 if ((*env)->GetArrayLength(env, addrArray) < 1) {
2011 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2012 "bad argument for IP_ADD_MEMBERSHIP: "
2013 "No IP addresses bound to interface");
2014 return;
2015 }
2016 addr = (*env)->GetObjectArrayElement(env, addrArray, 0);
2017
2018 mname.imr_multiaddr.s_addr = htonl(getInetAddress_addr(env, iaObj));
2019 #ifdef __linux__
2020 mname.imr_address.s_addr = htonl(getInetAddress_addr(env, addr));
2021 #else
2022 mname.imr_interface.s_addr = htonl(getInetAddress_addr(env, addr));
2023 #endif
2024 mname_len = sizeof(struct ip_mreq);
2025 }
2026 }
2027
2028
2029 /*
2030 * joinGroup(InetAddress) implementation :-
2031 *
2032 * Linux/IPv6: use ip_mreqn structure populated with multicast
2033 * address and interface index. index obtained
2034 * from cached value or IPV6_MULTICAST_IF.
2035 *
2036 * IPv4: use ip_mreq structure populated with multicast
2037 * address and local address obtained from
2038 * IP_MULTICAST_IF. On Linux IP_MULTICAST_IF
2039 * returns different structure depending on
2040 * kernel.
2041 */
2042
2043 if (niObj == NULL) {
2044
2045 #if defined(__linux__) && defined(AF_INET6)
2046 if (ipv6_available()) {
2047
2048 int index;
2049 socklen_t len = sizeof(index);
2050
2051 if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
2052 (char*)&index, &len) < 0) {
2053 NET_ThrowCurrent(env, "getsockopt IPV6_MULTICAST_IF failed");
2054 return;
2055 }
2056
2057 mname.imr_multiaddr.s_addr = htonl(getInetAddress_addr(env, iaObj));
2058 mname.imr_address.s_addr = 0 ;
2059 mname.imr_ifindex = index;
2060 mname_len = sizeof(struct ip_mreqn);
2061 } else
2062 #endif
2063 {
2064 struct in_addr in;
2065 struct in_addr *inP = ∈
2066 socklen_t len = sizeof(struct in_addr);
2067
2068 if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, (char *)inP, &len) < 0) {
2069 NET_ThrowCurrent(env, "getsockopt IP_MULTICAST_IF failed");
2070 return;
2071 }
2072
2073 #ifdef __linux__
2074 mname.imr_address.s_addr = in.s_addr;
2075
2076 #else
2077 mname.imr_interface.s_addr = in.s_addr;
2078 #endif
2079 mname.imr_multiaddr.s_addr = htonl(getInetAddress_addr(env, iaObj));
2080 mname_len = sizeof(struct ip_mreq);
2081 }
2082 }
2083
2084
2085 /*
2086 * Join the multicast group.
2087 */
2088 if (setsockopt(fd, IPPROTO_IP, (join ? IP_ADD_MEMBERSHIP:IP_DROP_MEMBERSHIP),
2089 (char *) &mname, mname_len) < 0) {
2090
2091 /*
2092 * If IP_ADD_MEMBERSHIP returns ENOPROTOOPT on Linux and we've got
2093 * IPv6 enabled then it's possible that the kernel has been fixed
2094 * so we switch to IPV6_ADD_MEMBERSHIP socket option.
2095 * As of 2.4.7 kernel IPV6_ADD_MEMBERSHIP can't handle IPv4-mapped
2096 * addresses so we have to use IP_ADD_MEMBERSHIP for IPv4 multicast
2097 * groups. However if the socket is an IPv6 socket then setsockopt
2098 * should return ENOPROTOOPT. We assume this will be fixed in Linux
2099 * at some stage.
2100 */
2101 #if defined(__linux__) && defined(AF_INET6)
2102 if (errno == ENOPROTOOPT) {
2103 if (ipv6_available()) {
2104 ipv6_join_leave = JNI_TRUE;
2105 errno = 0;
2106 } else {
2107 errno = ENOPROTOOPT; /* errno can be changed by ipv6_available */
2108 }
2109 }
2110 #endif
2111 if (errno) {
2112 if (join) {
2113 NET_ThrowCurrent(env, "setsockopt IP_ADD_MEMBERSHIP failed");
2114 } else {
2115 if (errno == ENOENT)
2116 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2117 "Not a member of the multicast group");
2118 else
2119 NET_ThrowCurrent(env, "setsockopt IP_DROP_MEMBERSHIP failed");
2120 }
2121 return;
2122 }
2123 }
2124
2125 /*
2126 * If we haven't switched to IPv6 socket option then we're done.
2127 */
2128 if (!ipv6_join_leave) {
2129 return;
2130 }
2131 }
2132
2133
2134 /*
2135 * IPv6 join. If it's an IPv4 multicast group then we use an IPv4-mapped
2136 * address.
2137 */
2138 #ifdef AF_INET6
2139 {
2140 struct ipv6_mreq mname6;
2141 jbyteArray ipaddress;
2142 jbyte caddr[16];
2143 jint family;
2144 jint address;
2145 family = getInetAddress_family(env, iaObj) == IPv4? AF_INET : AF_INET6;
2146 if (family == AF_INET) { /* will convert to IPv4-mapped address */
2147 memset((char *) caddr, 0, 16);
2148 address = getInetAddress_addr(env, iaObj);
2149
2150 caddr[10] = 0xff;
2151 caddr[11] = 0xff;
2152
2153 caddr[12] = ((address >> 24) & 0xff);
2154 caddr[13] = ((address >> 16) & 0xff);
2155 caddr[14] = ((address >> 8) & 0xff);
2156 caddr[15] = (address & 0xff);
2157 } else {
2158 getInet6Address_ipaddress(env, iaObj, (char*)caddr);
2159 }
2160
2161 memcpy((void *)&(mname6.ipv6mr_multiaddr), caddr, sizeof(struct in6_addr));
2162 if (IS_NULL(niObj)) {
2163 int index;
2164 socklen_t len = sizeof(index);
2165
2166 if (getsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
2167 (char*)&index, &len) < 0) {
2168 NET_ThrowCurrent(env, "getsockopt IPV6_MULTICAST_IF failed");
2169 return;
2170 }
2171
2172 #ifdef __linux__
2173 /*
2174 * On 2.4.8+ if we join a group with the interface set to 0
2175 * then the kernel records the interface it decides. This causes
2176 * subsequent leave groups to fail as there is no match. Thus we
2177 * pick the interface if there is a matching route.
2178 */
2179 if (index == 0) {
2180 int rt_index = getDefaultIPv6Interface(&(mname6.ipv6mr_multiaddr));
2181 if (rt_index > 0) {
2182 index = rt_index;
2183 }
2184 }
2185 #endif
2186 #ifdef MACOSX
2187 if (family == AF_INET6 && index == 0) {
2188 index = getDefaultScopeID(env);
2189 }
2190 #endif
2191 mname6.ipv6mr_interface = index;
2192 } else {
2193 jint idx = (*env)->GetIntField(env, niObj, ni_indexID);
2194 mname6.ipv6mr_interface = idx;
2195 }
2196
2197 #if defined(_ALLBSD_SOURCE)
2198 #define ADD_MEMBERSHIP IPV6_JOIN_GROUP
2199 #define DRP_MEMBERSHIP IPV6_LEAVE_GROUP
2200 #define S_ADD_MEMBERSHIP "IPV6_JOIN_GROUP"
2201 #define S_DRP_MEMBERSHIP "IPV6_LEAVE_GROUP"
2202 #else
2203 #define ADD_MEMBERSHIP IPV6_ADD_MEMBERSHIP
2204 #define DRP_MEMBERSHIP IPV6_DROP_MEMBERSHIP
2205 #define S_ADD_MEMBERSHIP "IPV6_ADD_MEMBERSHIP"
2206 #define S_DRP_MEMBERSHIP "IPV6_DROP_MEMBERSHIP"
2207 #endif
2208
2209 /* Join the multicast group */
2210 if (setsockopt(fd, IPPROTO_IPV6, (join ? ADD_MEMBERSHIP : DRP_MEMBERSHIP),
2211 (char *) &mname6, sizeof (mname6)) < 0) {
2212
2213 if (join) {
2214 NET_ThrowCurrent(env, "setsockopt " S_ADD_MEMBERSHIP " failed");
2215 } else {
2216 if (errno == ENOENT) {
2217 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2218 "Not a member of the multicast group");
2219 } else {
2220 NET_ThrowCurrent(env, "setsockopt " S_DRP_MEMBERSHIP " failed");
2221 }
2222 }
2223 }
2224 }
2225 #endif
2226 }
2227
2228 /*
2229 * Class: java_net_PlainDatagramSocketImpl
2230 * Method: join
2231 * Signature: (Ljava/net/InetAddress;)V
2232 */
2233 JNIEXPORT void JNICALL
2234 Java_java_net_PlainDatagramSocketImpl_join(JNIEnv *env, jobject this,
2235 jobject iaObj, jobject niObj)
2236 {
2237 mcast_join_leave(env, this, iaObj, niObj, JNI_TRUE);
2238 }
2239
2240 /*
2241 * Class: java_net_PlainDatagramSocketImpl
2242 * Method: leave
2243 * Signature: (Ljava/net/InetAddress;)V
2244 */
2245 JNIEXPORT void JNICALL
2246 Java_java_net_PlainDatagramSocketImpl_leave(JNIEnv *env, jobject this,
2247 jobject iaObj, jobject niObj)
2248 {
2249 mcast_join_leave(env, this, iaObj, niObj, JNI_FALSE);
2250 }
2251
2252 /*
2253 * Class: java_net_PlainDatagramSocketImpl
2254 * Method: dataAvailable
2255 * Signature: ()I
2256 */
2257 JNIEXPORT jint JNICALL
2258 Java_java_net_PlainDatagramSocketImpl_dataAvailable(JNIEnv *env, jobject this)
2259 {
2260 int fd, retval;
2261
2262 jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
2263
2264 if (IS_NULL(fdObj)) {
2265 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2266 "Socket closed");
2267 return -1;
2268 }
2269 fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
2270
2271 if (ioctl(fd, FIONREAD, &retval) < 0) {
2272 return -1;
2273 }
2274 return retval;
2275 }