1 /*
   2  * Copyright (c) 1997, 2018, 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 #include <malloc.h>
  26 
  27 #include "net_util.h"
  28 #include "NetworkInterface.h"
  29 
  30 #include "java_net_TwoStacksPlainDatagramSocketImpl.h"
  31 #include "java_net_SocketOptions.h"
  32 #include "java_net_NetworkInterface.h"
  33 #include "java_net_InetAddress.h"
  34 
  35 #ifndef IPTOS_TOS_MASK
  36 #define IPTOS_TOS_MASK 0x1e
  37 #endif
  38 #ifndef IPTOS_PREC_MASK
  39 #define IPTOS_PREC_MASK 0xe0
  40 #endif
  41 
  42 
  43 #define IN_CLASSD(i)    (((long)(i) & 0xf0000000) == 0xe0000000)
  44 #define IN_MULTICAST(i) IN_CLASSD(i)
  45 
  46 extern int getAllInterfacesAndAddresses(JNIEnv *env, netif **netifPP);
  47 
  48 /************************************************************************
  49  * TwoStacksPlainDatagramSocketImpl
  50  */
  51 
  52 static jfieldID IO_fd_fdID;
  53 static jfieldID pdsi_trafficClassID;
  54 jfieldID pdsi_fdID;
  55 jfieldID pdsi_fd1ID;
  56 jfieldID pdsi_fduseID;
  57 jfieldID pdsi_lastfdID;
  58 jfieldID pdsi_timeoutID;
  59 
  60 jfieldID pdsi_localPortID;
  61 jfieldID pdsi_connected;
  62 
  63 static jclass ia4_clazz;
  64 static jmethodID ia4_ctor;
  65 
  66 /*
  67  * Notes about UDP/IPV6 on Windows (XP and 2003 server):
  68  *
  69  * fd always points to the IPv4 fd, and fd1 points to the IPv6 fd.
  70  * Both fds are used when we bind to a wild-card address. When a specific
  71  * address is used, only one of them is used.
  72  */
  73 
  74 /*
  75  * Returns a java.lang.Integer based on 'i'
  76  */
  77 jobject createInteger(JNIEnv *env, int i) {
  78     static jclass i_class = NULL;
  79     static jmethodID i_ctrID;
  80     static jfieldID i_valueID;
  81 
  82     if (i_class == NULL) {
  83         jclass c = (*env)->FindClass(env, "java/lang/Integer");
  84         CHECK_NULL_RETURN(c, NULL);
  85         i_ctrID = (*env)->GetMethodID(env, c, "<init>", "(I)V");
  86         CHECK_NULL_RETURN(i_ctrID, NULL);
  87         i_class = (*env)->NewGlobalRef(env, c);
  88         CHECK_NULL_RETURN(i_class, NULL);
  89     }
  90 
  91     return (*env)->NewObject(env, i_class, i_ctrID, i);
  92 }
  93 
  94 /*
  95  * Returns a java.lang.Boolean based on 'b'
  96  */
  97 jobject createBoolean(JNIEnv *env, int b) {
  98     static jclass b_class = NULL;
  99     static jmethodID b_ctrID;
 100     static jfieldID b_valueID;
 101 
 102     if (b_class == NULL) {
 103         jclass c = (*env)->FindClass(env, "java/lang/Boolean");
 104         CHECK_NULL_RETURN(c, NULL);
 105         b_ctrID = (*env)->GetMethodID(env, c, "<init>", "(Z)V");
 106         CHECK_NULL_RETURN(b_ctrID, NULL);
 107         b_class = (*env)->NewGlobalRef(env, c);
 108         CHECK_NULL_RETURN(b_class, NULL);
 109     }
 110 
 111     return (*env)->NewObject(env, b_class, b_ctrID, (jboolean)(b!=0));
 112 }
 113 
 114 static int getFD(JNIEnv *env, jobject this) {
 115     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 116 
 117     if (fdObj == NULL) {
 118         return -1;
 119     }
 120     return (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 121 }
 122 
 123 static int getFD1(JNIEnv *env, jobject this) {
 124     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
 125 
 126     if (fdObj == NULL) {
 127         return -1;
 128     }
 129     return (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 130 }
 131 
 132 /*
 133  * This function "purges" all outstanding ICMP port unreachable packets
 134  * outstanding on a socket and returns JNI_TRUE if any ICMP messages
 135  * have been purged. The rational for purging is to emulate normal BSD
 136  * behaviour whereby receiving a "connection reset" status resets the
 137  * socket.
 138  */
 139 static jboolean purgeOutstandingICMP(JNIEnv *env, jobject this, jint fd)
 140 {
 141     jboolean got_icmp = JNI_FALSE;
 142     char buf[1];
 143     fd_set tbl;
 144     struct timeval t = { 0, 0 };
 145     SOCKETADDRESS rmtaddr;
 146     int addrlen = sizeof(SOCKETADDRESS);
 147 
 148     memset((char *)&rmtaddr, 0, sizeof(rmtaddr));
 149 
 150     /*
 151      * Peek at the queue to see if there is an ICMP port unreachable. If there
 152      * is then receive it.
 153      */
 154     FD_ZERO(&tbl);
 155     FD_SET(fd, &tbl);
 156     while(1) {
 157         if (select(/*ignored*/fd+1, &tbl, 0, 0, &t) <= 0) {
 158             break;
 159         }
 160         if (recvfrom(fd, buf, 1, MSG_PEEK, &rmtaddr.sa, &addrlen) != SOCKET_ERROR) {
 161             break;
 162         }
 163         if (WSAGetLastError() != WSAECONNRESET) {
 164             /* some other error - we don't care here */
 165             break;
 166         }
 167 
 168         recvfrom(fd, buf, 1, 0, &rmtaddr.sa, &addrlen);
 169         got_icmp = JNI_TRUE;
 170     }
 171 
 172     return got_icmp;
 173 }
 174 
 175 
 176 /*
 177  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
 178  * Method:    init
 179  * Signature: ()V
 180  */
 181 JNIEXPORT void JNICALL
 182 Java_java_net_TwoStacksPlainDatagramSocketImpl_init(JNIEnv *env, jclass cls) {
 183     /* get fieldIDs */
 184     pdsi_fdID = (*env)->GetFieldID(env, cls, "fd", "Ljava/io/FileDescriptor;");
 185     CHECK_NULL(pdsi_fdID);
 186     pdsi_fd1ID = (*env)->GetFieldID(env, cls, "fd1", "Ljava/io/FileDescriptor;");
 187     CHECK_NULL(pdsi_fd1ID);
 188     pdsi_timeoutID = (*env)->GetFieldID(env, cls, "timeout", "I");
 189     CHECK_NULL(pdsi_timeoutID);
 190     pdsi_fduseID = (*env)->GetFieldID(env, cls, "fduse", "I");
 191     CHECK_NULL(pdsi_fduseID);
 192     pdsi_lastfdID = (*env)->GetFieldID(env, cls, "lastfd", "I");
 193     CHECK_NULL(pdsi_lastfdID);
 194     pdsi_trafficClassID = (*env)->GetFieldID(env, cls, "trafficClass", "I");
 195     CHECK_NULL(pdsi_trafficClassID);
 196     pdsi_localPortID = (*env)->GetFieldID(env, cls, "localPort", "I");
 197     CHECK_NULL(pdsi_localPortID);
 198     pdsi_connected = (*env)->GetFieldID(env, cls, "connected", "Z");
 199     CHECK_NULL(pdsi_connected);
 200 
 201     cls = (*env)->FindClass(env, "java/io/FileDescriptor");
 202     CHECK_NULL(cls);
 203     IO_fd_fdID = NET_GetFileDescriptorID(env);
 204     CHECK_NULL(IO_fd_fdID);
 205 
 206     ia4_clazz = (*env)->FindClass(env, "java/net/Inet4Address");
 207     CHECK_NULL(ia4_clazz);
 208     ia4_clazz = (*env)->NewGlobalRef(env, ia4_clazz);
 209     CHECK_NULL(ia4_clazz);
 210     ia4_ctor = (*env)->GetMethodID(env, ia4_clazz, "<init>", "()V");
 211     CHECK_NULL(ia4_ctor);
 212 }
 213 
 214 JNIEXPORT void JNICALL
 215 Java_java_net_TwoStacksPlainDatagramSocketImpl_bind0(JNIEnv *env, jobject this,
 216                                            jint port, jobject addressObj,
 217                                            jboolean exclBind) {
 218     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 219     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
 220     int ipv6_supported = ipv6_available();
 221     int fd, fd1 = -1, lcladdrlen = 0;
 222     jint family;
 223     SOCKETADDRESS lcladdr;
 224 
 225     family = getInetAddress_family(env, addressObj);
 226     JNU_CHECK_EXCEPTION(env);
 227     if (family == java_net_InetAddress_IPv6 && !ipv6_supported) {
 228         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 229                         "Protocol family not supported");
 230         return;
 231     }
 232     if (IS_NULL(fdObj) || (ipv6_supported && IS_NULL(fd1Obj))) {
 233         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed");
 234         return;
 235     } else {
 236         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 237         if (ipv6_supported) {
 238             fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
 239         }
 240     }
 241 
 242     if (IS_NULL(addressObj)) {
 243         JNU_ThrowNullPointerException(env, "argument address");
 244         return;
 245     }
 246 
 247     if (NET_InetAddressToSockaddr(env, addressObj, port, &lcladdr,
 248                                   &lcladdrlen, JNI_FALSE) != 0) {
 249         return;
 250     }
 251 
 252     if (ipv6_supported) {
 253         struct ipv6bind v6bind;
 254         v6bind.addr = &lcladdr;
 255         v6bind.ipv4_fd = fd;
 256         v6bind.ipv6_fd = fd1;
 257         if (NET_BindV6(&v6bind, exclBind) != -1) {
 258             /* check if the fds have changed */
 259             if (v6bind.ipv4_fd != fd) {
 260                 fd = v6bind.ipv4_fd;
 261                 if (fd == -1) {
 262                     /* socket is closed. */
 263                     (*env)->SetObjectField(env, this, pdsi_fdID, NULL);
 264                 } else {
 265                     /* socket was re-created */
 266                     (*env)->SetIntField(env, fdObj, IO_fd_fdID, fd);
 267                 }
 268             }
 269             if (v6bind.ipv6_fd != fd1) {
 270                 fd1 = v6bind.ipv6_fd;
 271                 if (fd1 == -1) {
 272                     /* socket is closed. */
 273                     (*env)->SetObjectField(env, this, pdsi_fd1ID, NULL);
 274                 } else {
 275                     /* socket was re-created */
 276                     (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
 277                 }
 278             }
 279         } else {
 280             /* NET_BindV6() closes both sockets upon a failure */
 281             (*env)->SetObjectField(env, this, pdsi_fdID, NULL);
 282             (*env)->SetObjectField(env, this, pdsi_fd1ID, NULL);
 283             NET_ThrowCurrent (env, "Cannot bind");
 284             return;
 285         }
 286     } else {
 287         if (NET_WinBind(fd, &lcladdr, lcladdrlen, exclBind) == -1) {
 288             if (WSAGetLastError() == WSAEACCES) {
 289                 WSASetLastError(WSAEADDRINUSE);
 290             }
 291             (*env)->SetObjectField(env, this, pdsi_fdID, NULL);
 292             NET_ThrowCurrent(env, "Cannot bind");
 293             closesocket(fd);
 294             return;
 295         }
 296     }
 297 
 298     if (port == 0) {
 299         if (getsockname(fd == -1 ? fd1 : fd, &lcladdr.sa, &lcladdrlen) == -1) {
 300             NET_ThrowCurrent(env, "getsockname");
 301             return;
 302         }
 303         port = ntohs((u_short)GET_PORT(&lcladdr));
 304     }
 305     (*env)->SetIntField(env, this, pdsi_localPortID, port);
 306 }
 307 
 308 
 309 /*
 310  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
 311  * Method:    connect0
 312  * Signature: (Ljava/net/InetAddress;I)V
 313  */
 314 
 315 JNIEXPORT void JNICALL
 316 Java_java_net_TwoStacksPlainDatagramSocketImpl_connect0
 317   (JNIEnv *env, jobject this, jobject address, jint port)
 318 {
 319     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 320     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
 321     jint fd = -1, fd1 = -1, fdc, family;
 322     SOCKETADDRESS rmtaddr;
 323     int rmtaddrlen = 0;
 324     DWORD x1, x2; /* ignored result codes */
 325     int res, t;
 326 
 327     if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
 328         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 329                         "Socket closed");
 330         return;
 331     }
 332 
 333     if (!IS_NULL(fdObj)) {
 334         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 335     }
 336 
 337     if (!IS_NULL(fd1Obj)) {
 338         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
 339     }
 340 
 341     if (IS_NULL(address)) {
 342         JNU_ThrowNullPointerException(env, "address");
 343         return;
 344     }
 345 
 346     family = getInetAddress_family(env, address);
 347     JNU_CHECK_EXCEPTION(env);
 348     if (family == java_net_InetAddress_IPv6 && !ipv6_available()) {
 349         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 350                         "Protocol family not supported");
 351         return;
 352     }
 353 
 354     fdc = family == java_net_InetAddress_IPv4 ? fd : fd1;
 355 
 356     /* SIO_UDP_CONNRESET fixes a bug introduced in Windows 2000, which
 357      * returns connection reset errors on connected UDP sockets (as well
 358      * as connected sockets). The solution is to only enable this feature
 359      * when the socket is connected
 360      */
 361     t = TRUE;
 362     res = WSAIoctl(fdc, SIO_UDP_CONNRESET, &t, sizeof(t), &x1, sizeof(x1), &x2, 0, 0);
 363 
 364     if (NET_InetAddressToSockaddr(env, address, port, &rmtaddr,
 365                                   &rmtaddrlen, JNI_FALSE) != 0) {
 366         return;
 367     }
 368 
 369     if (connect(fdc, &rmtaddr.sa, rmtaddrlen) == -1) {
 370         NET_ThrowCurrent(env, "connect");
 371         return;
 372     }
 373 }
 374 
 375 /*
 376  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
 377  * Method:    disconnect0
 378  * Signature: ()V
 379  */
 380 
 381 JNIEXPORT void JNICALL
 382 Java_java_net_TwoStacksPlainDatagramSocketImpl_disconnect0(JNIEnv *env, jobject this, jint family) {
 383     /* The object's field */
 384     jobject fdObj;
 385     /* The fdObj'fd */
 386     jint fd, len;
 387     SOCKETADDRESS addr;
 388     DWORD x1 = 0, x2 = 0; /* ignored result codes */
 389     int t;
 390 
 391     if (family == java_net_InetAddress_IPv4) {
 392         fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 393         len = sizeof(struct sockaddr_in);
 394     } else {
 395         fdObj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
 396         len = sizeof(struct sockaddr_in6);
 397     }
 398 
 399     if (IS_NULL(fdObj)) {
 400         /* disconnect doesn't throw any exceptions */
 401         return;
 402     }
 403     fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 404 
 405     memset((char *)&addr, 0, len);
 406     connect(fd, &addr.sa, len);
 407 
 408     /*
 409      * use SIO_UDP_CONNRESET
 410      * to disable ICMP port unreachable handling here.
 411      */
 412     t = FALSE;
 413     WSAIoctl(fd, SIO_UDP_CONNRESET, &t, sizeof(t), &x1, sizeof(x1), &x2, 0, 0);
 414 }
 415 
 416 /*
 417  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
 418  * Method:    send0
 419  * Signature: (Ljava/net/DatagramPacket;)V
 420  */
 421 JNIEXPORT void JNICALL
 422 Java_java_net_TwoStacksPlainDatagramSocketImpl_send0
 423   (JNIEnv *env, jobject this, jobject packet)
 424 {
 425     char BUF[MAX_BUFFER_LEN];
 426     char *fullPacket;
 427     jobject fdObj;
 428     jint fd;
 429 
 430     jobject iaObj;
 431     jint family;
 432 
 433     jint packetBufferOffset, packetBufferLen, packetPort;
 434     jbyteArray packetBuffer;
 435     jboolean connected;
 436 
 437     SOCKETADDRESS rmtaddr;
 438     struct sockaddr *addrp = 0;
 439     int addrlen = 0;
 440 
 441     if (IS_NULL(packet)) {
 442         JNU_ThrowNullPointerException(env, "null packet");
 443         return;
 444     }
 445 
 446     iaObj = (*env)->GetObjectField(env, packet, dp_addressID);
 447 
 448     packetPort = (*env)->GetIntField(env, packet, dp_portID);
 449     packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
 450     packetBuffer = (jbyteArray)(*env)->GetObjectField(env, packet, dp_bufID);
 451     connected = (*env)->GetBooleanField(env, this, pdsi_connected);
 452 
 453     if (IS_NULL(iaObj) || IS_NULL(packetBuffer)) {
 454         JNU_ThrowNullPointerException(env, "null address || null buffer");
 455         return;
 456     }
 457 
 458     family = getInetAddress_family(env, iaObj);
 459     JNU_CHECK_EXCEPTION(env);
 460     if (family == java_net_InetAddress_IPv4) {
 461         fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 462     } else {
 463         if (!ipv6_available()) {
 464             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 465                         "Protocol not allowed");
 466             return;
 467         }
 468         fdObj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
 469     }
 470 
 471     if (IS_NULL(fdObj)) {
 472         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 473                         "Socket closed");
 474         return;
 475     }
 476     fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 477 
 478     packetBufferLen = (*env)->GetIntField(env, packet, dp_lengthID);
 479     /* Note: the buffer needn't be greater than 65,536 (0xFFFF)...
 480      * the maximum size of an IP packet. Anything bigger is truncated anyway.
 481      */
 482     if (packetBufferLen > MAX_PACKET_LEN) {
 483         packetBufferLen = MAX_PACKET_LEN;
 484     }
 485 
 486     // sockaddr arg to sendto() is null if already connected
 487     if (!connected) {
 488         if (NET_InetAddressToSockaddr(env, iaObj, packetPort, &rmtaddr,
 489                                       &addrlen, JNI_FALSE) != 0) {
 490             return;
 491         }
 492         addrp = &rmtaddr.sa;
 493     }
 494 
 495     if (packetBufferLen > MAX_BUFFER_LEN) {
 496         /* When JNI-ifying the JDK's IO routines, we turned
 497          * reads and writes of byte arrays of size greater
 498          * than 2048 bytes into several operations of size 2048.
 499          * This saves a malloc()/memcpy()/free() for big
 500          * buffers.  This is OK for file IO and TCP, but that
 501          * strategy violates the semantics of a datagram protocol.
 502          * (one big send) != (several smaller sends).  So here
 503          * we *must* alloc the buffer.  Note it needn't be bigger
 504          * than 65,536 (0xFFFF) the max size of an IP packet.
 505          * anything bigger is truncated anyway.
 506          */
 507         fullPacket = (char *)malloc(packetBufferLen);
 508         if (!fullPacket) {
 509             JNU_ThrowOutOfMemoryError(env, "Send buf native heap allocation failed");
 510             return;
 511         }
 512     } else {
 513         fullPacket = &(BUF[0]);
 514     }
 515 
 516     (*env)->GetByteArrayRegion(env, packetBuffer, packetBufferOffset,
 517                                packetBufferLen, (jbyte *)fullPacket);
 518     if (sendto(fd, fullPacket, packetBufferLen, 0, addrp,
 519                addrlen) == SOCKET_ERROR)
 520     {
 521         NET_ThrowCurrent(env, "Datagram send failed");
 522     }
 523 
 524     if (packetBufferLen > MAX_BUFFER_LEN) {
 525         free(fullPacket);
 526     }
 527 }
 528 
 529 /*
 530  * check which socket was last serviced when there was data on both sockets.
 531  * Only call this if sure that there is data on both sockets.
 532  */
 533 static int checkLastFD (JNIEnv *env, jobject this, int fd, int fd1) {
 534     int nextfd, lastfd = (*env)->GetIntField(env, this, pdsi_lastfdID);
 535     if (lastfd == -1) {
 536         /* arbitrary. Choose fd */
 537         (*env)->SetIntField(env, this, pdsi_lastfdID, fd);
 538         return fd;
 539     } else {
 540         if (lastfd == fd) {
 541             nextfd = fd1;
 542         } else {
 543             nextfd = fd;
 544         }
 545         (*env)->SetIntField(env, this, pdsi_lastfdID, nextfd);
 546         return nextfd;
 547     }
 548 }
 549 
 550 /*
 551  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
 552  * Method:    peek
 553  * Signature: (Ljava/net/InetAddress;)I
 554  */
 555 JNIEXPORT jint JNICALL
 556 Java_java_net_TwoStacksPlainDatagramSocketImpl_peek(JNIEnv *env, jobject this,
 557                                            jobject addressObj) {
 558 
 559     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 560     jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
 561     jint fd;
 562 
 563     /* The address and family fields of addressObj */
 564     jint address, family;
 565 
 566     int n;
 567     SOCKETADDRESS remote_addr;
 568     jint remote_addrsize = sizeof(SOCKETADDRESS);
 569     char buf[1];
 570     BOOL retry;
 571     jlong prevTime = 0;
 572 
 573     if (IS_NULL(fdObj)) {
 574         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
 575         return -1;
 576     } else {
 577         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 578         if (fd < 0) {
 579            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 580                            "socket closed");
 581            return -1;
 582         }
 583     }
 584     if (IS_NULL(addressObj)) {
 585         JNU_ThrowNullPointerException(env, "Null address in peek()");
 586         return -1;
 587     } else {
 588         address = getInetAddress_addr(env, addressObj);
 589         JNU_CHECK_EXCEPTION_RETURN(env, -1);
 590         /* We only handle IPv4 for now. Will support IPv6 once its in the os */
 591         family = AF_INET;
 592     }
 593 
 594     do {
 595         retry = FALSE;
 596 
 597         /*
 598          * If a timeout has been specified then we select on the socket
 599          * waiting for a read event or a timeout.
 600          */
 601         if (timeout) {
 602             int ret;
 603             prevTime = JVM_CurrentTimeMillis(env, 0);
 604             ret = NET_Timeout (fd, timeout);
 605             if (ret == 0) {
 606                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 607                                 "Peek timed out");
 608                 return ret;
 609             } else if (ret == -1) {
 610                 NET_ThrowCurrent(env, "timeout in datagram socket peek");
 611                 return ret;
 612             }
 613         }
 614 
 615         /* now try the peek */
 616         n = recvfrom(fd, buf, 1, MSG_PEEK, &remote_addr.sa, &remote_addrsize);
 617 
 618         if (n == SOCKET_ERROR) {
 619             if (WSAGetLastError() == WSAECONNRESET) {
 620                 jboolean connected;
 621 
 622                 /*
 623                  * An icmp port unreachable - we must receive this as Windows
 624                  * does not reset the state of the socket until this has been
 625                  * received.
 626                  */
 627                 purgeOutstandingICMP(env, this, fd);
 628 
 629                 connected =  (*env)->GetBooleanField(env, this, pdsi_connected);
 630                 if (connected) {
 631                     JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",
 632                                        "ICMP Port Unreachable");
 633                     return 0;
 634                 }
 635 
 636                 /*
 637                  * If a timeout was specified then we need to adjust it because
 638                  * we may have used up some of the timeout befor the icmp port
 639                  * unreachable arrived.
 640                  */
 641                 if (timeout) {
 642                     jlong newTime = JVM_CurrentTimeMillis(env, 0);
 643                     timeout -= (jint)(newTime - prevTime);
 644                     if (timeout <= 0) {
 645                         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 646                                 "Receive timed out");
 647                         return 0;
 648                     }
 649                     prevTime = newTime;
 650                 }
 651 
 652                 /* Need to retry the recv */
 653                 retry = TRUE;
 654             }
 655         }
 656     } while (retry);
 657 
 658     if (n == SOCKET_ERROR && WSAGetLastError() != WSAEMSGSIZE) {
 659         NET_ThrowCurrent(env, "Datagram peek failed");
 660         return 0;
 661     }
 662     setInetAddress_addr(env, addressObj, ntohl(remote_addr.sa4.sin_addr.s_addr));
 663     JNU_CHECK_EXCEPTION_RETURN(env, -1);
 664     setInetAddress_family(env, addressObj, java_net_InetAddress_IPv4);
 665     JNU_CHECK_EXCEPTION_RETURN(env, -1);
 666 
 667     /* return port */
 668     return ntohs(remote_addr.sa4.sin_port);
 669 }
 670 
 671 JNIEXPORT jint JNICALL
 672 Java_java_net_TwoStacksPlainDatagramSocketImpl_peekData(JNIEnv *env, jobject this,
 673                                            jobject packet) {
 674 
 675      char BUF[MAX_BUFFER_LEN];
 676     char *fullPacket;
 677     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 678     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
 679     jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
 680 
 681     jbyteArray packetBuffer;
 682     jint packetBufferOffset, packetBufferLen;
 683 
 684     int fd = -1, fd1 = -1, fduse, nsockets = 0, errorCode;
 685     int port;
 686 
 687     int checkBoth = 0;
 688     int n;
 689     SOCKETADDRESS remote_addr;
 690     jint remote_addrsize = sizeof(SOCKETADDRESS);
 691     BOOL retry;
 692     jlong prevTime = 0;
 693 
 694     if (!IS_NULL(fdObj)) {
 695         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 696         if (fd < 0) {
 697            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 698                            "socket closed");
 699            return -1;
 700         }
 701         nsockets = 1;
 702     }
 703 
 704     if (!IS_NULL(fd1Obj)) {
 705         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
 706         if (fd1 < 0) {
 707            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 708                            "socket closed");
 709            return -1;
 710         }
 711         nsockets ++;
 712     }
 713 
 714     switch (nsockets) {
 715       case 0:
 716         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 717                        "socket closed");
 718         return -1;
 719       case 1:
 720         if (!IS_NULL(fdObj)) {
 721            fduse = fd;
 722         } else {
 723            fduse = fd1;
 724         }
 725         break;
 726       case 2:
 727         checkBoth = TRUE;
 728         break;
 729     }
 730 
 731     if (IS_NULL(packet)) {
 732         JNU_ThrowNullPointerException(env, "packet");
 733         return -1;
 734     }
 735 
 736     packetBuffer = (*env)->GetObjectField(env, packet, dp_bufID);
 737 
 738     if (IS_NULL(packetBuffer)) {
 739         JNU_ThrowNullPointerException(env, "packet buffer");
 740         return -1;
 741     }
 742 
 743     packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
 744     packetBufferLen = (*env)->GetIntField(env, packet, dp_bufLengthID);
 745 
 746     if (packetBufferLen > MAX_BUFFER_LEN) {
 747 
 748         /* When JNI-ifying the JDK's IO routines, we turned
 749          * read's and write's of byte arrays of size greater
 750          * than 2048 bytes into several operations of size 2048.
 751          * This saves a malloc()/memcpy()/free() for big
 752          * buffers.  This is OK for file IO and TCP, but that
 753          * strategy violates the semantics of a datagram protocol.
 754          * (one big send) != (several smaller sends).  So here
 755          * we *must* alloc the buffer.  Note it needn't be bigger
 756          * than 65,536 (0xFFFF) the max size of an IP packet.
 757          * anything bigger is truncated anyway.
 758          */
 759         fullPacket = (char *)malloc(packetBufferLen);
 760         if (!fullPacket) {
 761             JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed");
 762             return -1;
 763         }
 764     } else {
 765         fullPacket = &(BUF[0]);
 766     }
 767 
 768     do {
 769         int ret;
 770         retry = FALSE;
 771 
 772         /*
 773          * If a timeout has been specified then we select on the socket
 774          * waiting for a read event or a timeout.
 775          */
 776         if (checkBoth) {
 777             int t = timeout == 0 ? -1: timeout;
 778             prevTime = JVM_CurrentTimeMillis(env, 0);
 779             ret = NET_Timeout2 (fd, fd1, t, &fduse);
 780             /* all subsequent calls to recv() or select() will use the same fd
 781              * for this call to peek() */
 782             if (ret <= 0) {
 783                 if (ret == 0) {
 784                     JNU_ThrowByName(env,JNU_JAVANETPKG "SocketTimeoutException",
 785                                         "Peek timed out");
 786                 } else if (ret == -1) {
 787                     NET_ThrowCurrent(env, "timeout in datagram socket peek");
 788                 }
 789                 if (packetBufferLen > MAX_BUFFER_LEN) {
 790                     free(fullPacket);
 791                 }
 792                 return -1;
 793             }
 794             if (ret == 2) {
 795                 fduse = checkLastFD (env, this, fd, fd1);
 796             }
 797             checkBoth = FALSE;
 798         } else if (timeout) {
 799             if (prevTime == 0) {
 800                 prevTime = JVM_CurrentTimeMillis(env, 0);
 801             }
 802             ret = NET_Timeout (fduse, timeout);
 803             if (ret <= 0) {
 804                 if (ret == 0) {
 805                     JNU_ThrowByName(env,JNU_JAVANETPKG "SocketTimeoutException",
 806                                     "Receive timed out");
 807                 } else if (ret == -1) {
 808                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 809                                     "Socket closed");
 810                 }
 811                 if (packetBufferLen > MAX_BUFFER_LEN) {
 812                     free(fullPacket);
 813                 }
 814                 return -1;
 815             }
 816         }
 817 
 818         /* receive the packet */
 819         n = recvfrom(fduse, fullPacket, packetBufferLen, MSG_PEEK,
 820                      &remote_addr.sa, &remote_addrsize);
 821         port = (int) ntohs ((u_short) GET_PORT((SOCKETADDRESS *)&remote_addr));
 822         if (n == SOCKET_ERROR) {
 823             if (WSAGetLastError() == WSAECONNRESET) {
 824                 jboolean connected;
 825 
 826                 /*
 827                  * An icmp port unreachable - we must receive this as Windows
 828                  * does not reset the state of the socket until this has been
 829                  * received.
 830                  */
 831                 purgeOutstandingICMP(env, this, fduse);
 832 
 833                 connected = (*env)->GetBooleanField(env, this, pdsi_connected);
 834                 if (connected) {
 835                     JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",
 836                                        "ICMP Port Unreachable");
 837 
 838                     if (packetBufferLen > MAX_BUFFER_LEN) {
 839                         free(fullPacket);
 840                     }
 841                     return -1;
 842                 }
 843 
 844                 /*
 845                  * If a timeout was specified then we need to adjust it because
 846                  * we may have used up some of the timeout befor the icmp port
 847                  * unreachable arrived.
 848                  */
 849                 if (timeout) {
 850                     jlong newTime = JVM_CurrentTimeMillis(env, 0);
 851                     timeout -= (jint)(newTime - prevTime);
 852                     if (timeout <= 0) {
 853                         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
 854                                 "Receive timed out");
 855                         if (packetBufferLen > MAX_BUFFER_LEN) {
 856                             free(fullPacket);
 857                         }
 858                         return -1;
 859                     }
 860                     prevTime = newTime;
 861                 }
 862                 retry = TRUE;
 863             }
 864         }
 865     } while (retry);
 866 
 867     /* truncate the data if the packet's length is too small */
 868     if (n > packetBufferLen) {
 869         n = packetBufferLen;
 870     }
 871     if (n < 0) {
 872         errorCode = WSAGetLastError();
 873         /* check to see if it's because the buffer was too small */
 874         if (errorCode == WSAEMSGSIZE) {
 875             /* it is because the buffer is too small. It's UDP, it's
 876              * unreliable, it's all good. discard the rest of the
 877              * data..
 878              */
 879             n = packetBufferLen;
 880         } else {
 881             /* failure */
 882             (*env)->SetIntField(env, packet, dp_lengthID, 0);
 883         }
 884     }
 885     if (n == -1) {
 886         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed");
 887         if (packetBufferLen > MAX_BUFFER_LEN) {
 888             free(fullPacket);
 889         }
 890         return -1;
 891     } else if (n == -2) {
 892         JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
 893                         "operation interrupted");
 894         if (packetBufferLen > MAX_BUFFER_LEN) {
 895             free(fullPacket);
 896         }
 897         return -1;
 898     } else if (n < 0) {
 899         NET_ThrowCurrent(env, "Datagram receive failed");
 900         if (packetBufferLen > MAX_BUFFER_LEN) {
 901             free(fullPacket);
 902         }
 903         return -1;
 904     } else {
 905         jobject packetAddress;
 906 
 907         /*
 908          * Check if there is an InetAddress already associated with this
 909          * packet. If so we check if it is the same source address. We
 910          * can't update any existing InetAddress because it is immutable
 911          */
 912         packetAddress = (*env)->GetObjectField(env, packet, dp_addressID);
 913         if (packetAddress != NULL) {
 914             if (!NET_SockaddrEqualsInetAddress(env, &remote_addr,
 915                                                packetAddress)) {
 916                 /* force a new InetAddress to be created */
 917                 packetAddress = NULL;
 918             }
 919         }
 920         if (packetAddress == NULL) {
 921             packetAddress = NET_SockaddrToInetAddress(env, &remote_addr,
 922                                                       &port);
 923             /* stuff the new Inetaddress in the packet */
 924             (*env)->SetObjectField(env, packet, dp_addressID, packetAddress);
 925         }
 926 
 927         /* populate the packet */
 928         (*env)->SetByteArrayRegion(env, packetBuffer, packetBufferOffset, n,
 929                                    (jbyte *)fullPacket);
 930         (*env)->SetIntField(env, packet, dp_portID, port);
 931         (*env)->SetIntField(env, packet, dp_lengthID, n);
 932     }
 933 
 934     /* make sure receive() picks up the right fd */
 935     (*env)->SetIntField(env, this, pdsi_fduseID, fduse);
 936 
 937     if (packetBufferLen > MAX_BUFFER_LEN) {
 938         free(fullPacket);
 939     }
 940     return port;
 941 }
 942 
 943 /*
 944  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
 945  * Method:    receive
 946  * Signature: (Ljava/net/DatagramPacket;)V
 947  */
 948 JNIEXPORT void JNICALL
 949 Java_java_net_TwoStacksPlainDatagramSocketImpl_receive0(JNIEnv *env, jobject this,
 950                                               jobject packet) {
 951 
 952     char BUF[MAX_BUFFER_LEN];
 953     char *fullPacket;
 954     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
 955     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
 956     jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);
 957     jbyteArray packetBuffer;
 958     jint packetBufferOffset, packetBufferLen;
 959     int ipv6_supported = ipv6_available();
 960 
 961     /* as a result of the changes for ipv6, peek() or peekData()
 962      * must be called prior to receive() so that fduse can be set.
 963      */
 964     int fd = -1, fd1 = -1, fduse, errorCode;
 965 
 966     int n, nsockets=0;
 967     SOCKETADDRESS remote_addr;
 968     jint remote_addrsize = sizeof(SOCKETADDRESS);
 969     BOOL retry;
 970     jlong prevTime = 0, selectTime=0;
 971     jboolean connected;
 972 
 973     if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
 974         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
 975                         "Socket closed");
 976         return;
 977     }
 978 
 979     if (!IS_NULL(fdObj)) {
 980         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
 981         nsockets ++;
 982     }
 983     if (!IS_NULL(fd1Obj)) {
 984         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
 985         nsockets ++;
 986     }
 987 
 988     if (nsockets == 2) { /* need to choose one of them */
 989         /* was fduse set in peek? */
 990         fduse = (*env)->GetIntField(env, this, pdsi_fduseID);
 991         if (fduse == -1) {
 992             /* not set in peek(), must select on both sockets */
 993             int ret, t = (timeout == 0) ? -1: timeout;
 994             ret = NET_Timeout2 (fd, fd1, t, &fduse);
 995             if (ret == 2) {
 996                 fduse = checkLastFD (env, this, fd, fd1);
 997             } else if (ret <= 0) {
 998                 if (ret == 0) {
 999                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
1000                                     "Receive timed out");
1001                 } else if (ret == -1) {
1002                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1003                                     "Socket closed");
1004                 }
1005                 return;
1006             }
1007         }
1008     } else if (!ipv6_supported) {
1009         fduse = fd;
1010     } else if (IS_NULL(fdObj)) {
1011         /* ipv6 supported: and this socket bound to an IPV6 only address */
1012         fduse = fd1;
1013     } else {
1014         /* ipv6 supported: and this socket bound to an IPV4 only address */
1015         fduse = fd;
1016     }
1017 
1018     if (IS_NULL(packet)) {
1019         JNU_ThrowNullPointerException(env, "packet");
1020         return;
1021     }
1022 
1023     packetBuffer = (*env)->GetObjectField(env, packet, dp_bufID);
1024 
1025     if (IS_NULL(packetBuffer)) {
1026         JNU_ThrowNullPointerException(env, "packet buffer");
1027         return;
1028     }
1029 
1030     packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);
1031     packetBufferLen = (*env)->GetIntField(env, packet, dp_bufLengthID);
1032 
1033     if (packetBufferLen > MAX_BUFFER_LEN) {
1034 
1035         /* When JNI-ifying the JDK's IO routines, we turned
1036          * read's and write's of byte arrays of size greater
1037          * than 2048 bytes into several operations of size 2048.
1038          * This saves a malloc()/memcpy()/free() for big
1039          * buffers.  This is OK for file IO and TCP, but that
1040          * strategy violates the semantics of a datagram protocol.
1041          * (one big send) != (several smaller sends).  So here
1042          * we *must* alloc the buffer.  Note it needn't be bigger
1043          * than 65,536 (0xFFFF) the max size of an IP packet.
1044          * anything bigger is truncated anyway.
1045          */
1046         fullPacket = (char *)malloc(packetBufferLen);
1047         if (!fullPacket) {
1048             JNU_ThrowOutOfMemoryError(env, "Receive buf native heap allocation failed");
1049             return;
1050         }
1051     } else {
1052         fullPacket = &(BUF[0]);
1053     }
1054 
1055 
1056 
1057     /*
1058      * If we are not connected then we need to know if a timeout has been
1059      * specified and if so we need to pick up the current time. These are
1060      * required in order to implement the semantics of timeout, viz :-
1061      * timeout set to t1 but ICMP port unreachable arrives in t2 where
1062      * t2 < t1. In this case we must discard the ICMP packets and then
1063      * wait for the next packet up to a maximum of t1 minus t2.
1064      */
1065     connected = (*env)->GetBooleanField(env, this, pdsi_connected);
1066     if (!connected && timeout && !ipv6_supported) {
1067         prevTime = JVM_CurrentTimeMillis(env, 0);
1068     }
1069 
1070     if (timeout && nsockets == 1) {
1071         int ret;
1072         ret = NET_Timeout(fduse, timeout);
1073         if (ret <= 0) {
1074             if (ret == 0) {
1075                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
1076                                 "Receive timed out");
1077             } else if (ret == -1) {
1078                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1079                                 "Socket closed");
1080             }
1081             if (packetBufferLen > MAX_BUFFER_LEN) {
1082                 free(fullPacket);
1083             }
1084             return;
1085         }
1086     }
1087 
1088     /*
1089      * Loop only if we discarding ICMP port unreachable packets
1090      */
1091     do {
1092         retry = FALSE;
1093 
1094         /* receive the packet */
1095         n = recvfrom(fduse, fullPacket, packetBufferLen, 0, &remote_addr.sa,
1096                      &remote_addrsize);
1097 
1098         if (n == SOCKET_ERROR) {
1099             if (WSAGetLastError() == WSAECONNRESET) {
1100                 /*
1101                  * An icmp port unreachable has been received - consume any other
1102                  * outstanding packets.
1103                  */
1104                 purgeOutstandingICMP(env, this, fduse);
1105 
1106                 /*
1107                  * If connected throw a PortUnreachableException
1108                  */
1109 
1110                 if (connected) {
1111                     JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",
1112                                        "ICMP Port Unreachable");
1113 
1114                     if (packetBufferLen > MAX_BUFFER_LEN) {
1115                         free(fullPacket);
1116                     }
1117 
1118                     return;
1119                 }
1120 
1121                 /*
1122                  * If a timeout was specified then we need to adjust it because
1123                  * we may have used up some of the timeout before the icmp port
1124                  * unreachable arrived.
1125                  */
1126                 if (timeout) {
1127                     int ret;
1128                     jlong newTime = JVM_CurrentTimeMillis(env, 0);
1129                     timeout -= (jint)(newTime - prevTime);
1130                     prevTime = newTime;
1131 
1132                     if (timeout <= 0) {
1133                         ret = 0;
1134                     } else {
1135                         ret = NET_Timeout(fduse, timeout);
1136                     }
1137 
1138                     if (ret <= 0) {
1139                         if (ret == 0) {
1140                             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
1141                                             "Receive timed out");
1142                         } else if (ret == -1) {
1143                             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1144                                             "Socket closed");
1145                         }
1146                         if (packetBufferLen > MAX_BUFFER_LEN) {
1147                             free(fullPacket);
1148                         }
1149                         return;
1150                     }
1151                 }
1152 
1153                 /*
1154                  * An ICMP port unreachable was received but we are
1155                  * not connected so ignore it.
1156                  */
1157                 retry = TRUE;
1158             }
1159         }
1160     } while (retry);
1161 
1162     /* truncate the data if the packet's length is too small */
1163     if (n > packetBufferLen) {
1164         n = packetBufferLen;
1165     }
1166     if (n < 0) {
1167         errorCode = WSAGetLastError();
1168         /* check to see if it's because the buffer was too small */
1169         if (errorCode == WSAEMSGSIZE) {
1170             /* it is because the buffer is too small. It's UDP, it's
1171              * unreliable, it's all good. discard the rest of the
1172              * data..
1173              */
1174             n = packetBufferLen;
1175         } else {
1176             /* failure */
1177             (*env)->SetIntField(env, packet, dp_lengthID, 0);
1178         }
1179     }
1180     if (n == -1) {
1181         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed");
1182     } else if (n == -2) {
1183         JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
1184                         "operation interrupted");
1185     } else if (n < 0) {
1186         NET_ThrowCurrent(env, "Datagram receive failed");
1187     } else {
1188         int port = 0;
1189         jobject packetAddress;
1190 
1191         /*
1192          * Check if there is an InetAddress already associated with this
1193          * packet. If so we check if it is the same source address. We
1194          * can't update any existing InetAddress because it is immutable
1195          */
1196         packetAddress = (*env)->GetObjectField(env, packet, dp_addressID);
1197         if (packetAddress != NULL) {
1198             if (!NET_SockaddrEqualsInetAddress(env, &remote_addr,
1199                                                packetAddress)) {
1200                 /* force a new InetAddress to be created */
1201                 packetAddress = NULL;
1202             }
1203         }
1204         if (packetAddress == NULL) {
1205             packetAddress = NET_SockaddrToInetAddress(env, &remote_addr,
1206                                                       &port);
1207             /* stuff the new Inetaddress in the packet */
1208             (*env)->SetObjectField(env, packet, dp_addressID, packetAddress);
1209         } else {
1210             /* only get the new port number */
1211             port = NET_GetPortFromSockaddr(&remote_addr);
1212         }
1213         /* populate the packet */
1214         (*env)->SetByteArrayRegion(env, packetBuffer, packetBufferOffset, n,
1215                                    (jbyte *)fullPacket);
1216         (*env)->SetIntField(env, packet, dp_portID, port);
1217         (*env)->SetIntField(env, packet, dp_lengthID, n);
1218     }
1219     if (packetBufferLen > MAX_BUFFER_LEN) {
1220         free(fullPacket);
1221     }
1222 }
1223 
1224 /*
1225  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
1226  * Method:    datagramSocketCreate
1227  * Signature: ()V
1228  */
1229 JNIEXPORT void JNICALL
1230 Java_java_net_TwoStacksPlainDatagramSocketImpl_datagramSocketCreate(JNIEnv *env,
1231                                                            jobject this) {
1232     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
1233     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
1234 
1235     int fd, fd1;
1236     int t = TRUE;
1237     DWORD x1, x2; /* ignored result codes */
1238     int ipv6_supported = ipv6_available();
1239 
1240     int arg = -1;
1241 
1242     if (IS_NULL(fdObj) || (ipv6_supported && IS_NULL(fd1Obj))) {
1243         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
1244         return;
1245     } else {
1246         fd =  (int) socket (AF_INET, SOCK_DGRAM, 0);
1247     }
1248     if (fd == SOCKET_ERROR) {
1249         NET_ThrowCurrent(env, "Socket creation failed");
1250         return;
1251     }
1252     SetHandleInformation((HANDLE)(UINT_PTR)fd, HANDLE_FLAG_INHERIT, FALSE);
1253     (*env)->SetIntField(env, fdObj, IO_fd_fdID, fd);
1254     NET_SetSockOpt(fd, SOL_SOCKET, SO_BROADCAST, (char*)&t, sizeof(BOOL));
1255 
1256     if (ipv6_supported) {
1257         /* SIO_UDP_CONNRESET fixes a bug introduced in Windows 2000, which
1258          * returns connection reset errors un connected UDP sockets (as well
1259          * as connected sockets. The solution is to only enable this feature
1260          * when the socket is connected
1261          */
1262         t = FALSE;
1263         WSAIoctl(fd,SIO_UDP_CONNRESET,&t,sizeof(t),&x1,sizeof(x1),&x2,0,0);
1264         t = TRUE;
1265         fd1 = socket (AF_INET6, SOCK_DGRAM, 0);
1266         if (fd1 == SOCKET_ERROR) {
1267             NET_ThrowCurrent(env, "Socket creation failed");
1268             return;
1269         }
1270         NET_SetSockOpt(fd1, SOL_SOCKET, SO_BROADCAST, (char*)&t, sizeof(BOOL));
1271         t = FALSE;
1272         WSAIoctl(fd1,SIO_UDP_CONNRESET,&t,sizeof(t),&x1,sizeof(x1),&x2,0,0);
1273         (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);
1274         SetHandleInformation((HANDLE)(UINT_PTR)fd1, HANDLE_FLAG_INHERIT, FALSE);
1275     } else {
1276         /* drop the second fd */
1277         (*env)->SetObjectField(env, this, pdsi_fd1ID, NULL);
1278     }
1279 }
1280 
1281 /*
1282  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
1283  * Method:    datagramSocketClose
1284  * Signature: ()V
1285  */
1286 JNIEXPORT void JNICALL
1287 Java_java_net_TwoStacksPlainDatagramSocketImpl_datagramSocketClose(JNIEnv *env,
1288                                                           jobject this) {
1289     /*
1290      * REMIND: PUT A LOCK AROUND THIS CODE
1291      */
1292     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
1293     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
1294     int ipv6_supported = ipv6_available();
1295     int fd = -1, fd1 = -1;
1296 
1297     if (IS_NULL(fdObj) && (!ipv6_supported || IS_NULL(fd1Obj))) {
1298         return;
1299     }
1300 
1301     if (!IS_NULL(fdObj)) {
1302         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
1303         if (fd != -1) {
1304             (*env)->SetIntField(env, fdObj, IO_fd_fdID, -1);
1305             NET_SocketClose(fd);
1306         }
1307     }
1308 
1309     if (ipv6_supported && fd1Obj != NULL) {
1310         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
1311         if (fd1 == -1) {
1312             return;
1313         }
1314         (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, -1);
1315         NET_SocketClose(fd1);
1316     }
1317 }
1318 
1319 /*
1320  * check the addresses attached to the NetworkInterface object
1321  * and return the first one (of the requested family Ipv4 or Ipv6)
1322  * in *iaddr
1323  */
1324 
1325 static int getInetAddrFromIf (JNIEnv *env, int family, jobject nif, jobject *iaddr)
1326 {
1327     jobjectArray addrArray;
1328     static jfieldID ni_addrsID=0;
1329     jsize len;
1330     jobject addr;
1331     int i;
1332 
1333     if (ni_addrsID == NULL ) {
1334         jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1335         CHECK_NULL_RETURN (c, -1);
1336         ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1337                                         "[Ljava/net/InetAddress;");
1338         CHECK_NULL_RETURN (ni_addrsID, -1);
1339     }
1340 
1341     addrArray = (*env)->GetObjectField(env, nif, ni_addrsID);
1342     len = (*env)->GetArrayLength(env, addrArray);
1343 
1344     /*
1345      * Check that there is at least one address bound to this
1346      * interface.
1347      */
1348     if (len < 1) {
1349         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1350             "bad argument for IP_MULTICAST_IF2: No IP addresses bound to interface");
1351         return -1;
1352     }
1353     for (i=0; i<len; i++) {
1354         int fam;
1355         addr = (*env)->GetObjectArrayElement(env, addrArray, i);
1356         fam = getInetAddress_family(env, addr);
1357         JNU_CHECK_EXCEPTION_RETURN(env, -1);
1358         if (fam == family) {
1359             *iaddr = addr;
1360             return 0;
1361         }
1362     }
1363     return -1;
1364 }
1365 
1366 static int getInet4AddrFromIf (JNIEnv *env, jobject nif, struct in_addr *iaddr)
1367 {
1368     jobject addr;
1369 
1370     int ret = getInetAddrFromIf(env, java_net_InetAddress_IPv4, nif, &addr);
1371     if (ret == -1) {
1372         return -1;
1373     }
1374 
1375     iaddr->s_addr = htonl(getInetAddress_addr(env, addr));
1376     JNU_CHECK_EXCEPTION_RETURN(env, -1);
1377     return 0;
1378 }
1379 
1380 /* Get the multicasting index from the interface */
1381 
1382 static int getIndexFromIf (JNIEnv *env, jobject nif) {
1383     static jfieldID ni_indexID = NULL;
1384 
1385     if (ni_indexID == NULL) {
1386         jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1387         CHECK_NULL_RETURN(c, -1);
1388         ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1389         CHECK_NULL_RETURN(ni_indexID, -1);
1390     }
1391 
1392     return (*env)->GetIntField(env, nif, ni_indexID);
1393 }
1394 
1395 static int isAdapterIpv6Enabled(JNIEnv *env, int index) {
1396   netif *ifList, *curr;
1397   int ipv6Enabled = 0;
1398   if (getAllInterfacesAndAddresses(env, &ifList) < 0) {
1399       return ipv6Enabled;
1400   }
1401 
1402   /* search by index */
1403   curr = ifList;
1404   while (curr != NULL) {
1405       if (index == curr->index) {
1406           break;
1407       }
1408       curr = curr->next;
1409   }
1410 
1411   /* if found ipv6Index != 0 then interface is configured with IPV6 */
1412   if ((curr != NULL) && (curr->ipv6Index !=0)) {
1413       ipv6Enabled = 1;
1414   }
1415 
1416   /* release the interface list */
1417   free_netif(ifList);
1418 
1419   return ipv6Enabled;
1420 }
1421 
1422 /*
1423  * Sets the multicast interface.
1424  *
1425  * SocketOptions.IP_MULTICAST_IF (argument is an InetAddress) :-
1426  *      IPv4:   set outgoing multicast interface using
1427  *              IPPROTO_IP/IP_MULTICAST_IF
1428  *
1429  *      IPv6:   Get the interface to which the
1430  *              InetAddress is bound
1431  *              and do same as SockOptions.IF_MULTICAST_IF2
1432  *
1433  * SockOptions.IF_MULTICAST_IF2 (argument is a NetworkInterface ) :-
1434  *      For each stack:
1435  *      IPv4:   Obtain IP address bound to network interface
1436  *              (NetworkInterface.addres[0])
1437  *              set outgoing multicast interface using
1438  *              IPPROTO_IP/IP_MULTICAST_IF
1439  *
1440  *      IPv6:   Obtain NetworkInterface.index
1441  *              Set outgoing multicast interface using
1442  *              IPPROTO_IPV6/IPV6_MULTICAST_IF
1443  *
1444  */
1445 static void setMulticastInterface(JNIEnv *env, jobject this, int fd, int fd1,
1446                                   jint opt, jobject value)
1447 {
1448     int ipv6_supported = ipv6_available();
1449 
1450     if (opt == java_net_SocketOptions_IP_MULTICAST_IF) {
1451         /*
1452          * value is an InetAddress.
1453          * On IPv4 system use IP_MULTICAST_IF socket option
1454          * On IPv6 system get the NetworkInterface that this IP
1455          * address is bound to and use the IPV6_MULTICAST_IF
1456          * option instead of IP_MULTICAST_IF
1457          */
1458         if (ipv6_supported) {
1459             static jclass ni_class = NULL;
1460             if (ni_class == NULL) {
1461                 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1462                 CHECK_NULL(c);
1463                 ni_class = (*env)->NewGlobalRef(env, c);
1464                 CHECK_NULL(ni_class);
1465             }
1466 
1467             value = Java_java_net_NetworkInterface_getByInetAddress0(env, ni_class, value);
1468             if (value == NULL) {
1469                 if (!(*env)->ExceptionOccurred(env)) {
1470                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1471                          "bad argument for IP_MULTICAST_IF"
1472                          ": address not bound to any interface");
1473                 }
1474                 return;
1475             }
1476             opt = java_net_SocketOptions_IP_MULTICAST_IF2;
1477         } else {
1478             struct in_addr in;
1479 
1480             in.s_addr = htonl(getInetAddress_addr(env, value));
1481             JNU_CHECK_EXCEPTION(env);
1482             if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1483                                (const char*)&in, sizeof(in)) < 0) {
1484                 JNU_ThrowByNameWithMessageAndLastError
1485                     (env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1486             }
1487             return;
1488         }
1489     }
1490 
1491     if (opt == java_net_SocketOptions_IP_MULTICAST_IF2) {
1492         /*
1493          * value is a NetworkInterface.
1494          * On IPv6 system get the index of the interface and use the
1495          * IPV6_MULTICAST_IF socket option
1496          * On IPv4 system extract addr[0] and use the IP_MULTICAST_IF
1497          * option. For IPv6 both must be done.
1498          */
1499         if (ipv6_supported) {
1500             static jfieldID ni_indexID = NULL;
1501             struct in_addr in;
1502             int index;
1503 
1504             if (ni_indexID == NULL) {
1505                 jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1506                 CHECK_NULL(c);
1507                 ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1508                 CHECK_NULL(ni_indexID);
1509             }
1510             index = (*env)->GetIntField(env, value, ni_indexID);
1511 
1512             if (isAdapterIpv6Enabled(env, index) != 0) {
1513                 if (setsockopt(fd1, IPPROTO_IPV6, IPV6_MULTICAST_IF,
1514                                (const char*)&index, sizeof(index)) < 0) {
1515                     if (errno == EINVAL && index > 0) {
1516                         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1517                             "IPV6_MULTICAST_IF failed (interface has IPv4 "
1518                             "address only?)");
1519                     } else {
1520                         JNU_ThrowByNameWithMessageAndLastError
1521                             (env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1522                     }
1523                     return;
1524                 }
1525             }
1526             /* If there are any IPv4 addresses on this interface then
1527              * repeat the operation on the IPv4 fd */
1528 
1529             if (getInet4AddrFromIf(env, value, &in) < 0) {
1530                 return;
1531             }
1532             if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1533                                (const char*)&in, sizeof(in)) < 0) {
1534                 JNU_ThrowByNameWithMessageAndLastError
1535                     (env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1536             }
1537             return;
1538         } else {
1539             struct in_addr in;
1540 
1541             if (getInet4AddrFromIf (env, value, &in) < 0) {
1542                 if ((*env)->ExceptionOccurred(env)) {
1543                     return;
1544                 }
1545                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1546                         "no InetAddress instances of requested type");
1547                 return;
1548             }
1549 
1550             if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1551                                (const char*)&in, sizeof(in)) < 0) {
1552                 JNU_ThrowByNameWithMessageAndLastError
1553                     (env, JNU_JAVANETPKG "SocketException", "Error setting socket option");
1554             }
1555             return;
1556         }
1557     }
1558 }
1559 
1560 /*
1561  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
1562  * Method:    socketNativeSetOption
1563  * Signature: (ILjava/lang/Object;)V
1564  */
1565 JNIEXPORT void JNICALL
1566 Java_java_net_TwoStacksPlainDatagramSocketImpl_socketNativeSetOption
1567   (JNIEnv *env,jobject this, jint opt,jobject value)
1568 {
1569     int fd = -1, fd1 = -1;
1570     int levelv4 = 0, levelv6 = 0, optnamev4 = 0, optnamev6 = 0, optlen = 0;
1571     union {
1572         int i;
1573         char c;
1574     } optval = { 0 };
1575     int ipv6_supported = ipv6_available();
1576     fd = getFD(env, this);
1577 
1578     if (ipv6_supported) {
1579         fd1 = getFD1(env, this);
1580     }
1581     if (fd < 0 && fd1 < 0) {
1582         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed");
1583         return;
1584     }
1585 
1586     if ((opt == java_net_SocketOptions_IP_MULTICAST_IF) ||
1587         (opt == java_net_SocketOptions_IP_MULTICAST_IF2)) {
1588 
1589         setMulticastInterface(env, this, fd, fd1, opt, value);
1590         return;
1591     }
1592 
1593     /*
1594      * Map the Java level socket option to the platform specific
1595      * level(s) and option name(s).
1596      */
1597     if (fd1 != -1) {
1598         if (NET_MapSocketOptionV6(opt, &levelv6, &optnamev6)) {
1599             JNU_ThrowByName(env, "java/net/SocketException", "Invalid option");
1600             return;
1601         }
1602     }
1603     if (fd != -1) {
1604         if (NET_MapSocketOption(opt, &levelv4, &optnamev4)) {
1605             JNU_ThrowByName(env, "java/net/SocketException", "Invalid option");
1606             return;
1607         }
1608     }
1609 
1610     switch (opt) {
1611         case java_net_SocketOptions_SO_SNDBUF :
1612         case java_net_SocketOptions_SO_RCVBUF :
1613         case java_net_SocketOptions_IP_TOS :
1614             {
1615                 jclass cls;
1616                 jfieldID fid;
1617 
1618                 cls = (*env)->FindClass(env, "java/lang/Integer");
1619                 CHECK_NULL(cls);
1620                 fid =  (*env)->GetFieldID(env, cls, "value", "I");
1621                 CHECK_NULL(fid);
1622 
1623                 optval.i = (*env)->GetIntField(env, value, fid);
1624                 optlen = sizeof(optval.i);
1625             }
1626             break;
1627 
1628         case java_net_SocketOptions_SO_REUSEADDR:
1629         case java_net_SocketOptions_SO_BROADCAST:
1630         case java_net_SocketOptions_IP_MULTICAST_LOOP:
1631             {
1632                 jclass cls;
1633                 jfieldID fid;
1634                 jboolean on;
1635 
1636                 cls = (*env)->FindClass(env, "java/lang/Boolean");
1637                 CHECK_NULL(cls);
1638                 fid =  (*env)->GetFieldID(env, cls, "value", "Z");
1639                 CHECK_NULL(fid);
1640 
1641                 on = (*env)->GetBooleanField(env, value, fid);
1642                 optval.i = (on ? 1 : 0);
1643                 /*
1644                  * setLoopbackMode (true) disables IP_MULTICAST_LOOP rather
1645                  * than enabling it.
1646                  */
1647                 if (opt == java_net_SocketOptions_IP_MULTICAST_LOOP) {
1648                     optval.i = !optval.i;
1649                 }
1650                 optlen = sizeof(optval.i);
1651             }
1652             break;
1653 
1654         default :
1655             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1656                 "Socket option not supported by PlainDatagramSocketImp");
1657             return;
1658 
1659     }
1660 
1661     if (fd1 != -1) {
1662         if (NET_SetSockOpt(fd1, levelv6, optnamev6, (void *)&optval, optlen) < 0) {
1663             NET_ThrowCurrent(env, "setsockopt IPv6");
1664             return;
1665         }
1666     }
1667     if (fd != -1) {
1668         if (NET_SetSockOpt(fd, levelv4, optnamev4, (void *)&optval, optlen) < 0) {
1669             NET_ThrowCurrent(env, "setsockopt");
1670             return;
1671         }
1672     }
1673 }
1674 
1675 /*
1676  *
1677  * called by getMulticastInterface to retrieve a NetworkInterface
1678  * configured for IPv4.
1679  * The ipv4Mode parameter, is a closet boolean, which allows for a NULL return,
1680  * or forces the creation of a NetworkInterface object with null data.
1681  * It relates to its calling context in getMulticastInterface.
1682  * ipv4Mode == 1, the context is IPV4 processing only.
1683  * ipv4Mode == 0, the context is IPV6 processing
1684  *
1685  */
1686 static jobject getIPv4NetworkInterface (JNIEnv *env, jobject this, int fd, jint opt, int ipv4Mode) {
1687         static jclass inet4_class;
1688         static jmethodID inet4_ctrID;
1689 
1690         static jclass ni_class; static jmethodID ni_ctrID;
1691         static jfieldID ni_indexID;
1692         static jfieldID ni_addrsID;
1693 
1694         jobjectArray addrArray;
1695         jobject addr;
1696         jobject ni;
1697 
1698         struct in_addr in;
1699         struct in_addr *inP = &in;
1700         int len = sizeof(struct in_addr);
1701         if (getsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
1702                            (char *)inP, &len) < 0) {
1703             JNU_ThrowByNameWithMessageAndLastError
1704                 (env, JNU_JAVANETPKG "SocketException", "Error getting socket option");
1705             return NULL;
1706         }
1707 
1708         /*
1709          * Construct and populate an Inet4Address
1710          */
1711         if (inet4_class == NULL) {
1712             jclass c = (*env)->FindClass(env, "java/net/Inet4Address");
1713             CHECK_NULL_RETURN(c, NULL);
1714             inet4_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1715             CHECK_NULL_RETURN(inet4_ctrID, NULL);
1716             inet4_class = (*env)->NewGlobalRef(env, c);
1717             CHECK_NULL_RETURN(inet4_class, NULL);
1718         }
1719         addr = (*env)->NewObject(env, inet4_class, inet4_ctrID, 0);
1720         CHECK_NULL_RETURN(addr, NULL);
1721 
1722         setInetAddress_addr(env, addr, ntohl(in.s_addr));
1723         JNU_CHECK_EXCEPTION_RETURN(env, NULL);
1724         /*
1725          * For IP_MULTICAST_IF return InetAddress
1726          */
1727         if (opt == java_net_SocketOptions_IP_MULTICAST_IF) {
1728             return addr;
1729         }
1730 
1731         /*
1732          * For IP_MULTICAST_IF2 we get the NetworkInterface for
1733          * this address and return it
1734          */
1735         if (ni_class == NULL) {
1736             jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1737             CHECK_NULL_RETURN(c, NULL);
1738             ni_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1739             CHECK_NULL_RETURN(ni_ctrID, NULL);
1740             ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1741             CHECK_NULL_RETURN(ni_indexID, NULL);
1742             ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1743                                             "[Ljava/net/InetAddress;");
1744             CHECK_NULL_RETURN(ni_addrsID, NULL);
1745             ni_class = (*env)->NewGlobalRef(env, c);
1746             CHECK_NULL_RETURN(ni_class, NULL);
1747         }
1748         ni = Java_java_net_NetworkInterface_getByInetAddress0(env, ni_class, addr);
1749         if (ni) {
1750             return ni;
1751         }
1752         if (ipv4Mode) {
1753             ni = (*env)->NewObject(env, ni_class, ni_ctrID, 0);
1754             CHECK_NULL_RETURN(ni, NULL);
1755 
1756             (*env)->SetIntField(env, ni, ni_indexID, -1);
1757             addrArray = (*env)->NewObjectArray(env, 1, inet4_class, NULL);
1758             CHECK_NULL_RETURN(addrArray, NULL);
1759             (*env)->SetObjectArrayElement(env, addrArray, 0, addr);
1760             (*env)->SetObjectField(env, ni, ni_addrsID, addrArray);
1761         } else {
1762             ni = NULL;
1763         }
1764         return ni;
1765 }
1766 
1767 /*
1768  * Return the multicast interface:
1769  *
1770  * SocketOptions.IP_MULTICAST_IF
1771  *      IPv4:   Query IPPROTO_IP/IP_MULTICAST_IF
1772  *              Create InetAddress
1773  *              IP_MULTICAST_IF returns struct ip_mreqn on 2.2
1774  *              kernel but struct in_addr on 2.4 kernel
1775  *      IPv6:   Query IPPROTO_IPV6 / IPV6_MULTICAST_IF or
1776  *              obtain from impl is Linux 2.2 kernel
1777  *              If index == 0 return InetAddress representing
1778  *              anyLocalAddress.
1779  *              If index > 0 query NetworkInterface by index
1780  *              and returns addrs[0]
1781  *
1782  * SocketOptions.IP_MULTICAST_IF2
1783  *      IPv4:   Query IPPROTO_IP/IP_MULTICAST_IF
1784  *              Query NetworkInterface by IP address and
1785  *              return the NetworkInterface that the address
1786  *              is bound too.
1787  *      IPv6:   Query IPPROTO_IPV6 / IPV6_MULTICAST_IF
1788  *              (except Linux .2 kernel)
1789  *              Query NetworkInterface by index and
1790  *              return NetworkInterface.
1791  */
1792 jobject getMulticastInterface(JNIEnv *env, jobject this, int fd, int fd1, jint opt) {
1793     jboolean isIPV4 = !ipv6_available() || fd1 == -1;
1794 
1795     /*
1796      * IPv4 implementation
1797      */
1798     if (isIPV4) {
1799         jobject netObject = NULL; // return is either an addr or a netif
1800         netObject = getIPv4NetworkInterface(env, this, fd, opt, 1);
1801         return netObject;
1802     }
1803 
1804     /*
1805      * IPv6 implementation
1806      */
1807     if ((opt == java_net_SocketOptions_IP_MULTICAST_IF) ||
1808         (opt == java_net_SocketOptions_IP_MULTICAST_IF2)) {
1809 
1810         static jclass ni_class;
1811         static jmethodID ni_ctrID;
1812         static jfieldID ni_indexID;
1813         static jfieldID ni_addrsID;
1814         static jclass ia_class;
1815         static jmethodID ia_anyLocalAddressID;
1816 
1817         int index;
1818         int len = sizeof(index);
1819 
1820         jobjectArray addrArray;
1821         jobject addr;
1822         jobject ni;
1823 
1824         {
1825             if (getsockopt(fd1, IPPROTO_IPV6, IPV6_MULTICAST_IF,
1826                                (char*)&index, &len) < 0) {
1827                 JNU_ThrowByNameWithMessageAndLastError
1828                     (env, JNU_JAVANETPKG "SocketException", "Error getting socket option");
1829                 return NULL;
1830             }
1831         }
1832 
1833         if (ni_class == NULL) {
1834             jclass c = (*env)->FindClass(env, "java/net/NetworkInterface");
1835             CHECK_NULL_RETURN(c, NULL);
1836             ni_ctrID = (*env)->GetMethodID(env, c, "<init>", "()V");
1837             CHECK_NULL_RETURN(ni_ctrID, NULL);
1838             ni_indexID = (*env)->GetFieldID(env, c, "index", "I");
1839             CHECK_NULL_RETURN(ni_indexID, NULL);
1840             ni_addrsID = (*env)->GetFieldID(env, c, "addrs",
1841                                             "[Ljava/net/InetAddress;");
1842             CHECK_NULL_RETURN(ni_addrsID, NULL);
1843 
1844             ia_class = (*env)->FindClass(env, "java/net/InetAddress");
1845             CHECK_NULL_RETURN(ia_class, NULL);
1846             ia_class = (*env)->NewGlobalRef(env, ia_class);
1847             CHECK_NULL_RETURN(ia_class, NULL);
1848             ia_anyLocalAddressID = (*env)->GetStaticMethodID(env,
1849                                                              ia_class,
1850                                                              "anyLocalAddress",
1851                                                              "()Ljava/net/InetAddress;");
1852             CHECK_NULL_RETURN(ia_anyLocalAddressID, NULL);
1853             ni_class = (*env)->NewGlobalRef(env, c);
1854             CHECK_NULL_RETURN(ni_class, NULL);
1855         }
1856 
1857         /*
1858          * If multicast to a specific interface then return the
1859          * interface (for IF2) or the any address on that interface
1860          * (for IF).
1861          */
1862         if (index > 0) {
1863             ni = Java_java_net_NetworkInterface_getByIndex0(env, ni_class,
1864                                                                    index);
1865             if (ni == NULL) {
1866                 char errmsg[255];
1867                 sprintf(errmsg,
1868                         "IPV6_MULTICAST_IF returned index to unrecognized interface: %d",
1869                         index);
1870                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", errmsg);
1871                 return NULL;
1872             }
1873 
1874             /*
1875              * For IP_MULTICAST_IF2 return the NetworkInterface
1876              */
1877             if (opt == java_net_SocketOptions_IP_MULTICAST_IF2) {
1878                 return ni;
1879             }
1880 
1881             /*
1882              * For IP_MULTICAST_IF return addrs[0]
1883              */
1884             addrArray = (*env)->GetObjectField(env, ni, ni_addrsID);
1885             if ((*env)->GetArrayLength(env, addrArray) < 1) {
1886                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1887                     "IPV6_MULTICAST_IF returned interface without IP bindings");
1888                 return NULL;
1889             }
1890 
1891             addr = (*env)->GetObjectArrayElement(env, addrArray, 0);
1892             return addr;
1893         } else if (index == 0) { // index == 0 typically means IPv6 not configured on the interfaces
1894             // falling back to treat interface as configured for IPv4
1895             jobject netObject = NULL;
1896             netObject = getIPv4NetworkInterface(env, this, fd, opt, 0);
1897             if (netObject != NULL) {
1898                 return netObject;
1899             }
1900         }
1901 
1902         /*
1903          * Multicast to any address - return anyLocalAddress
1904          * or a NetworkInterface with addrs[0] set to anyLocalAddress
1905          */
1906 
1907         addr = (*env)->CallStaticObjectMethod(env, ia_class, ia_anyLocalAddressID,
1908                                               NULL);
1909         if (opt == java_net_SocketOptions_IP_MULTICAST_IF) {
1910             return addr;
1911         }
1912 
1913         ni = (*env)->NewObject(env, ni_class, ni_ctrID, 0);
1914         CHECK_NULL_RETURN(ni, NULL);
1915         (*env)->SetIntField(env, ni, ni_indexID, -1);
1916         addrArray = (*env)->NewObjectArray(env, 1, ia_class, NULL);
1917         CHECK_NULL_RETURN(addrArray, NULL);
1918         (*env)->SetObjectArrayElement(env, addrArray, 0, addr);
1919         (*env)->SetObjectField(env, ni, ni_addrsID, addrArray);
1920         return ni;
1921     }
1922     return NULL;
1923 }
1924 
1925 
1926 /*
1927  * Returns relevant info as a jint.
1928  *
1929  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
1930  * Method:    socketGetOption
1931  * Signature: (I)Ljava/lang/Object;
1932  */
1933 JNIEXPORT jobject JNICALL
1934 Java_java_net_TwoStacksPlainDatagramSocketImpl_socketGetOption
1935   (JNIEnv *env, jobject this, jint opt)
1936 {
1937     int fd = -1, fd1 = -1;
1938     int level, optname, optlen;
1939     union {
1940         int i;
1941     } optval = {0};
1942     int ipv6_supported = ipv6_available();
1943 
1944     fd = getFD(env, this);
1945     if (ipv6_supported) {
1946         fd1 = getFD1(env, this);
1947     }
1948 
1949     if (fd < 0 && fd1 < 0) {
1950         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
1951                         "Socket closed");
1952         return NULL;
1953     }
1954 
1955     /*
1956      * Handle IP_MULTICAST_IF separately
1957      */
1958     if (opt == java_net_SocketOptions_IP_MULTICAST_IF ||
1959         opt == java_net_SocketOptions_IP_MULTICAST_IF2) {
1960         return getMulticastInterface(env, this, fd, fd1, opt);
1961     }
1962 
1963     /*
1964      * Map the Java level socket option to the platform specific
1965      * level and option name.
1966      */
1967     if (NET_MapSocketOption(opt, &level, &optname)) {
1968         JNU_ThrowByName(env, "java/net/SocketException", "Invalid option");
1969         return NULL;
1970     }
1971 
1972     if (fd == -1) {
1973         if (NET_MapSocketOptionV6(opt, &level, &optname)) {
1974             JNU_ThrowByName(env, "java/net/SocketException", "Invalid option");
1975             return NULL;
1976         }
1977         fd = fd1; /* must be IPv6 only */
1978     }
1979 
1980     optlen = sizeof(optval.i);
1981     if (NET_GetSockOpt(fd, level, optname, (void *)&optval, &optlen) < 0) {
1982         char tmpbuf[255];
1983         int size = 0;
1984         char errmsg[255 + 31];
1985         getErrorString(errno, tmpbuf, sizeof(tmpbuf));
1986         sprintf(errmsg, "error getting socket option: %s", tmpbuf);
1987         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", errmsg);
1988         return NULL;
1989     }
1990 
1991     switch (opt) {
1992         case java_net_SocketOptions_SO_BROADCAST:
1993         case java_net_SocketOptions_SO_REUSEADDR:
1994             return createBoolean(env, optval.i);
1995 
1996         case java_net_SocketOptions_IP_MULTICAST_LOOP:
1997             /* getLoopbackMode() returns true if IP_MULTICAST_LOOP is disabled */
1998             return createBoolean(env, !optval.i);
1999 
2000         case java_net_SocketOptions_SO_SNDBUF:
2001         case java_net_SocketOptions_SO_RCVBUF:
2002         case java_net_SocketOptions_IP_TOS:
2003             return createInteger(env, optval.i);
2004 
2005         default :
2006             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2007                 "Socket option not supported by TwoStacksPlainDatagramSocketImpl");
2008             return NULL;
2009 
2010     }
2011 }
2012 
2013 /*
2014  * Returns local address of the socket.
2015  *
2016  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2017  * Method:    socketLocalAddress
2018  * Signature: (I)Ljava/lang/Object;
2019  */
2020 JNIEXPORT jobject JNICALL
2021 Java_java_net_TwoStacksPlainDatagramSocketImpl_socketLocalAddress
2022   (JNIEnv *env, jobject this, jint family)
2023 {
2024     int fd = -1, fd1 = -1;
2025     SOCKETADDRESS sa;
2026     int len = 0;
2027     int port;
2028     jobject iaObj;
2029     int ipv6_supported = ipv6_available();
2030 
2031     fd = getFD(env, this);
2032     if (ipv6_supported) {
2033         fd1 = getFD1(env, this);
2034     }
2035 
2036     if (fd < 0 && fd1 < 0) {
2037         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2038                         "Socket closed");
2039         return NULL;
2040     }
2041 
2042     /* find out local IP address */
2043 
2044     len = sizeof(struct sockaddr_in);
2045 
2046     /* family==-1 when socket is not connected */
2047     if ((family == java_net_InetAddress_IPv6) || (family == -1 && fd == -1)) {
2048         fd = fd1; /* must be IPv6 only */
2049         len = sizeof(struct sockaddr_in6);
2050     }
2051 
2052     if (fd == -1) {
2053         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2054                         "Socket closed");
2055         return NULL;
2056     }
2057 
2058     if (getsockname(fd, &sa.sa, &len) == -1) {
2059         JNU_ThrowByNameWithMessageAndLastError
2060             (env, JNU_JAVANETPKG "SocketException", "Error getting socket name");
2061         return NULL;
2062     }
2063     iaObj = NET_SockaddrToInetAddress(env, &sa, &port);
2064 
2065     return iaObj;
2066 }
2067 
2068 /*
2069  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2070  * Method:    setTimeToLive
2071  * Signature: (I)V
2072  */
2073 JNIEXPORT void JNICALL
2074 Java_java_net_TwoStacksPlainDatagramSocketImpl_setTimeToLive(JNIEnv *env, jobject this,
2075                                                     jint ttl) {
2076 
2077     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
2078     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
2079     int fd = -1, fd1 = -1;
2080     int ittl = (int)ttl;
2081 
2082     if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
2083         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2084                         "Socket closed");
2085         return;
2086     } else {
2087       if (!IS_NULL(fdObj)) {
2088         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
2089       }
2090       if (!IS_NULL(fd1Obj)) {
2091         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
2092       }
2093     }
2094 
2095     /* setsockopt to be correct ttl */
2096     if (fd >= 0) {
2097       if (NET_SetSockOpt(fd, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&ittl,
2098                          sizeof (ittl)) < 0) {
2099         NET_ThrowCurrent(env, "set IP_MULTICAST_TTL failed");
2100         return;
2101       }
2102     }
2103 
2104     if (fd1 >= 0) {
2105       if (NET_SetSockOpt(fd1, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&ittl,
2106                          sizeof(ittl)) <0) {
2107         NET_ThrowCurrent(env, "set IPV6_MULTICAST_HOPS failed");
2108       }
2109     }
2110 }
2111 
2112 /*
2113  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2114  * Method:    setTTL
2115  * Signature: (B)V
2116  */
2117 JNIEXPORT void JNICALL
2118 Java_java_net_TwoStacksPlainDatagramSocketImpl_setTTL(JNIEnv *env, jobject this,
2119                                              jbyte ttl) {
2120     Java_java_net_TwoStacksPlainDatagramSocketImpl_setTimeToLive(env, this,
2121                                                         (jint)ttl & 0xFF);
2122 }
2123 
2124 /*
2125  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2126  * Method:    getTimeToLive
2127  * Signature: ()I
2128  */
2129 JNIEXPORT jint JNICALL
2130 Java_java_net_TwoStacksPlainDatagramSocketImpl_getTimeToLive(JNIEnv *env, jobject this) {
2131     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
2132     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
2133     int fd = -1, fd1 = -1;
2134     int ttl = 0;
2135     int len = sizeof(ttl);
2136 
2137     if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
2138         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2139                         "Socket closed");
2140         return -1;
2141     } else {
2142       if (!IS_NULL(fdObj)) {
2143         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
2144       }
2145       if (!IS_NULL(fd1Obj)) {
2146         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
2147       }
2148     }
2149 
2150     /* getsockopt of ttl */
2151     if (fd >= 0) {
2152       if (NET_GetSockOpt(fd, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&ttl, &len) < 0) {
2153         NET_ThrowCurrent(env, "get IP_MULTICAST_TTL failed");
2154         return -1;
2155       }
2156       return (jint)ttl;
2157     }
2158     if (fd1 >= 0) {
2159       if (NET_GetSockOpt(fd1, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char*)&ttl, &len) < 0) {
2160         NET_ThrowCurrent(env, "get IP_MULTICAST_TTL failed");
2161         return -1;
2162       }
2163       return (jint)ttl;
2164     }
2165     return -1;
2166 }
2167 
2168 /*
2169  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2170  * Method:    getTTL
2171  * Signature: ()B
2172  */
2173 JNIEXPORT jbyte JNICALL
2174 Java_java_net_TwoStacksPlainDatagramSocketImpl_getTTL(JNIEnv *env, jobject this) {
2175     int result = Java_java_net_TwoStacksPlainDatagramSocketImpl_getTimeToLive(env, this);
2176 
2177     return (jbyte)result;
2178 }
2179 
2180 /* join/leave the named group on the named interface, or if no interface specified
2181  * then the interface set with setInterfac(), or the default interface otherwise */
2182 
2183 static void mcast_join_leave(JNIEnv *env, jobject this,
2184                              jobject iaObj, jobject niObj,
2185                              jboolean join)
2186 {
2187     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
2188     jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
2189     jint fd = -1, fd1 = -1;
2190 
2191     SOCKETADDRESS name;
2192     struct ip_mreq mname;
2193     struct ipv6_mreq mname6;
2194 
2195     struct in_addr in;
2196     DWORD ifindex = 0;
2197 
2198     int len, family;
2199     int ipv6_supported = ipv6_available();
2200     int cmd;
2201 
2202     memset((char *)&in, 0, sizeof(in));
2203     memset((char *)&name, 0, sizeof(name));
2204 
2205     if (IS_NULL(fdObj) && IS_NULL(fd1Obj)) {
2206         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2207                         "Socket closed");
2208         return;
2209     }
2210     if (!IS_NULL(fdObj)) {
2211         fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
2212     }
2213     if (ipv6_supported && !IS_NULL(fd1Obj)) {
2214         fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
2215     }
2216 
2217     if (IS_NULL(iaObj)) {
2218         JNU_ThrowNullPointerException(env, "address");
2219         return;
2220     }
2221 
2222     if (NET_InetAddressToSockaddr(env, iaObj, 0, &name, &len, JNI_FALSE) != 0) {
2223       return;
2224     }
2225 
2226     /* Set the multicast group address in the ip_mreq field
2227      * eventually this check should be done by the security manager
2228      */
2229     family = name.sa.sa_family;
2230 
2231     if (family == AF_INET) {
2232         int address = name.sa4.sin_addr.s_addr;
2233         if (!IN_MULTICAST(ntohl(address))) {
2234             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "not in multicast");
2235             return;
2236         }
2237         mname.imr_multiaddr.s_addr = address;
2238         if (fd < 0) {
2239           JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Can't join an IPv4 group on an IPv6 only socket");
2240           return;
2241         }
2242         if (IS_NULL(niObj)) {
2243             len = sizeof(in);
2244             if (NET_GetSockOpt(fd, IPPROTO_IP, IP_MULTICAST_IF,
2245                            (char *)&in, &len) < 0) {
2246                 NET_ThrowCurrent(env, "get IP_MULTICAST_IF failed");
2247                 return;
2248             }
2249             mname.imr_interface.s_addr = in.s_addr;
2250         } else {
2251             if (getInet4AddrFromIf (env, niObj, &mname.imr_interface) != 0) {
2252                 NET_ThrowCurrent(env, "no Inet4Address associated with interface");
2253                 return;
2254             }
2255         }
2256 
2257         cmd = join ? IP_ADD_MEMBERSHIP: IP_DROP_MEMBERSHIP;
2258 
2259         /* Join the multicast group */
2260         if (NET_SetSockOpt(fd, IPPROTO_IP, cmd, (char *) &mname, sizeof (mname)) < 0) {
2261             if (WSAGetLastError() == WSAENOBUFS) {
2262                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2263                     "IP_ADD_MEMBERSHIP failed (out of hardware filters?)");
2264             } else {
2265                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException","error setting options");
2266             }
2267         }
2268     } else /* AF_INET6 */ {
2269         if (ipv6_supported) {
2270             struct in6_addr *address;
2271             address = &name.sa6.sin6_addr;
2272             if (!IN6_IS_ADDR_MULTICAST(address)) {
2273                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "not in6 multicast");
2274                 return;
2275             }
2276             mname6.ipv6mr_multiaddr = *address;
2277         } else {
2278             JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "IPv6 not supported");
2279             return;
2280         }
2281         if (fd1 < 0) {
2282           JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Can't join an IPv6 group on a IPv4 socket");
2283           return;
2284         }
2285         if (IS_NULL(niObj)) {
2286             len = sizeof (ifindex);
2287             if (NET_GetSockOpt(fd1, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, &len) < 0) {
2288                 NET_ThrowCurrent(env, "get IPV6_MULTICAST_IF failed");
2289                 return;
2290             }
2291         } else {
2292             ifindex = getIndexFromIf (env, niObj);
2293             if (ifindex == -1) {
2294                 if ((*env)->ExceptionOccurred(env)) {
2295                     return;
2296                 }
2297                 NET_ThrowCurrent(env, "get ifindex failed");
2298                 return;
2299             }
2300         }
2301         mname6.ipv6mr_interface = ifindex;
2302         cmd = join ? IPV6_ADD_MEMBERSHIP: IPV6_DROP_MEMBERSHIP;
2303 
2304         /* Join the multicast group */
2305         if (NET_SetSockOpt(fd1, IPPROTO_IPV6, cmd, (char *) &mname6, sizeof (mname6)) < 0) {
2306             if (WSAGetLastError() == WSAENOBUFS) {
2307                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2308                     "IP_ADD_MEMBERSHIP failed (out of hardware filters?)");
2309             } else {
2310                 JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException","error setting options");
2311             }
2312         }
2313     }
2314 
2315     return;
2316 }
2317 
2318 /*
2319  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2320  * Method:    join
2321  * Signature: (Ljava/net/InetAddress;)V
2322  */
2323 JNIEXPORT void JNICALL
2324 Java_java_net_TwoStacksPlainDatagramSocketImpl_join(JNIEnv *env, jobject this,
2325                                            jobject iaObj, jobject niObj)
2326 {
2327     mcast_join_leave (env, this, iaObj, niObj, JNI_TRUE);
2328 }
2329 
2330 /*
2331  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2332  * Method:    leave
2333  * Signature: (Ljava/net/InetAddress;)V
2334  */
2335 JNIEXPORT void JNICALL
2336 Java_java_net_TwoStacksPlainDatagramSocketImpl_leave(JNIEnv *env, jobject this,
2337                                             jobject iaObj, jobject niObj)
2338 {
2339     mcast_join_leave (env, this, iaObj, niObj, JNI_FALSE);
2340 }
2341 
2342 /*
2343  * Class:     java_net_TwoStacksPlainDatagramSocketImpl
2344  * Method:    dataAvailable
2345  * Signature: ()I
2346  */
2347 JNIEXPORT jint JNICALL Java_java_net_TwoStacksPlainDatagramSocketImpl_dataAvailable
2348 (JNIEnv *env, jobject this) {
2349     SOCKET fd;
2350     SOCKET fd1;
2351     int  rv = -1, rv1 = -1;
2352     jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);
2353     jobject fd1Obj;
2354 
2355     if (!IS_NULL(fdObj)) {
2356         int retval = 0;
2357         fd = (SOCKET)(*env)->GetIntField(env, fdObj, IO_fd_fdID);
2358         rv = ioctlsocket(fd, FIONREAD, &retval);
2359         if (retval > 0) {
2360             return retval;
2361         }
2362     }
2363 
2364     fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);
2365     if (!IS_NULL(fd1Obj)) {
2366         int retval = 0;
2367         fd1 = (SOCKET)(*env)->GetIntField(env, fd1Obj, IO_fd_fdID);
2368         rv1 = ioctlsocket(fd1, FIONREAD, &retval);
2369         if (retval > 0) {
2370             return retval;
2371         }
2372     }
2373 
2374     if (rv < 0 && rv1 < 0) {
2375         JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
2376                         "Socket closed");
2377         return -1;
2378     }
2379 
2380     return 0;
2381 }