1 /*

     2  * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include "jni.h"

    27 #include "jni_util.h"

    28 #include "jvm.h"

    29 #include "jlong.h"

    30 #include <io.h>

    31 #include "sun_nio_ch_DatagramChannelImpl.h"

    32 #include "nio.h"

    33 #include "nio_util.h"

    34 #include "net_util.h"

    35 #include <winsock2.h>

    36 

    37 static jfieldID dci_senderID;   /* sender in sun.nio.ch.DatagramChannelImpl */

    38 static jfieldID dci_senderAddrID; /* sender InetAddress in sun.nio.ch.DatagramChannelImpl */

    39 static jfieldID dci_senderPortID; /* sender port in sun.nio.ch.DatagramChannelImpl */

    40 static jclass isa_class;        /* java.net.InetSocketAddress */

    41 static jmethodID isa_ctorID;    /* java.net.InetSocketAddress(InetAddress, int) */

    42 

    43 

    44 JNIEXPORT void JNICALL

    45 Java_sun_nio_ch_DatagramChannelImpl_initIDs(JNIEnv *env, jclass clazz)

    46 {

    47     clazz = (*env)->FindClass(env, "java/net/InetSocketAddress");

    48     CHECK_NULL(clazz);

    49     isa_class = (*env)->NewGlobalRef(env, clazz);

    50     if (isa_class == NULL) {

    51         JNU_ThrowOutOfMemoryError(env, NULL);

    52         return;

    53     }

    54     isa_ctorID = (*env)->GetMethodID(env, clazz, "<init>",

    55                                      "(Ljava/net/InetAddress;I)V");

    56     CHECK_NULL(isa_ctorID);

    57 

    58     clazz = (*env)->FindClass(env, "sun/nio/ch/DatagramChannelImpl");

    59     CHECK_NULL(clazz);

    60     dci_senderID = (*env)->GetFieldID(env, clazz, "sender",

    61                                       "Ljava/net/SocketAddress;");

    62     CHECK_NULL(dci_senderID);

    63     dci_senderAddrID = (*env)->GetFieldID(env, clazz,

    64                                           "cachedSenderInetAddress",

    65                                           "Ljava/net/InetAddress;");

    66     CHECK_NULL(dci_senderAddrID);

    67     dci_senderPortID = (*env)->GetFieldID(env, clazz,

    68                                           "cachedSenderPort", "I");

    69     CHECK_NULL(dci_senderPortID);

    70 }

    71 

    72 /*

    73  * This function "purges" all outstanding ICMP port unreachable packets

    74  * outstanding on a socket and returns JNI_TRUE if any ICMP messages

    75  * have been purged. The rational for purging is to emulate normal BSD

    76  * behaviour whereby receiving a "connection reset" status resets the

    77  * socket.

    78  */

    79 jboolean purgeOutstandingICMP(JNIEnv *env, jclass clazz, jint fd)

    80 {

    81     jboolean got_icmp = JNI_FALSE;

    82     char buf[1];

    83     fd_set tbl;

    84     struct timeval t = { 0, 0 };

    85     SOCKETADDRESS sa;

    86     int addrlen = sizeof(sa);

    87 

    88     /*

    89      * Peek at the queue to see if there is an ICMP port unreachable. If there

    90      * is then receive it.

    91      */

    92     FD_ZERO(&tbl);

    93     FD_SET((u_int)fd, &tbl);

    94     while(1) {

    95         if (select(/*ignored*/fd+1, &tbl, 0, 0, &t) <= 0) {

    96             break;

    97         }

    98         if (recvfrom(fd, buf, 1, MSG_PEEK,

    99                      &sa.sa, &addrlen) != SOCKET_ERROR) {

   100             break;

   101         }

   102         if (WSAGetLastError() != WSAECONNRESET) {

   103             /* some other error - we don't care here */

   104             break;

   105         }

   106 

   107         recvfrom(fd, buf, 1, 0, &sa.sa, &addrlen);

   108         got_icmp = JNI_TRUE;

   109     }

   110 

   111     return got_icmp;

   112 }

   113 

   114 JNIEXPORT void JNICALL

   115 Java_sun_nio_ch_DatagramChannelImpl_disconnect0(JNIEnv *env, jobject this,

   116                                                 jobject fdo, jboolean isIPv6)

   117 {

   118     jint fd = fdval(env, fdo);

   119     int rv = 0;

   120     SOCKETADDRESS sa;

   121     int sa_len = sizeof(sa);

   122 

   123     memset(&sa, 0, sa_len);

   124 

   125     rv = connect((SOCKET)fd, &sa.sa, sa_len);

   126     if (rv == SOCKET_ERROR) {

   127         handleSocketError(env, WSAGetLastError());

   128     } else {

   129         /* Disable WSAECONNRESET errors as socket is no longer connected */

   130         BOOL enable = FALSE;

   131         DWORD bytesReturned = 0;

   132         WSAIoctl((SOCKET)fd, SIO_UDP_CONNRESET, &enable, sizeof(enable),

   133                  NULL, 0, &bytesReturned, NULL, NULL);

   134     }

   135 }

   136 

   137 JNIEXPORT jint JNICALL

   138 Java_sun_nio_ch_DatagramChannelImpl_receive0(JNIEnv *env, jobject this,

   139                                             jobject fdo, jlong address,

   140                                             jint len, jboolean connected)

   141 {

   142     jint fd = fdval(env, fdo);

   143     void *buf = (void *)jlong_to_ptr(address);

   144     SOCKETADDRESS sa;

   145     int sa_len = sizeof(sa);

   146     BOOL retry = FALSE;

   147     jint n;

   148     jobject senderAddr;

   149 

   150     do {

   151         retry = FALSE;

   152         n = recvfrom((SOCKET)fd,

   153                      (char *)buf,

   154                      len,

   155                      0,

   156                      &sa.sa,

   157                      &sa_len);

   158 

   159         if (n == SOCKET_ERROR) {

   160             int theErr = (jint)WSAGetLastError();

   161             if (theErr == WSAEMSGSIZE) {

   162                 /* Spec says the rest of the data will be discarded... */

   163                 n = len;

   164             } else if (theErr == WSAECONNRESET) {

   165                 purgeOutstandingICMP(env, this, fd);

   166                 if (connected == JNI_FALSE) {

   167                     retry = TRUE;

   168                 } else {

   169                     JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException", 0);

   170                     return IOS_THROWN;

   171                 }

   172             } else if (theErr == WSAEWOULDBLOCK) {

   173                 return IOS_UNAVAILABLE;

   174             } else return handleSocketError(env, theErr);

   175         }

   176     } while (retry);

   177 

   178     /*

   179      * If the source address and port match the cached address

   180      * and port in DatagramChannelImpl then we don't need to

   181      * create InetAddress and InetSocketAddress objects.

   182      */

   183     senderAddr = (*env)->GetObjectField(env, this, dci_senderAddrID);

   184     if (senderAddr != NULL) {

   185         if (!NET_SockaddrEqualsInetAddress(env, &sa, senderAddr)) {

   186             senderAddr = NULL;

   187         } else {

   188             jint port = (*env)->GetIntField(env, this, dci_senderPortID);

   189             if (port != NET_GetPortFromSockaddr(&sa)) {

   190                 senderAddr = NULL;

   191             }

   192         }

   193     }

   194     if (senderAddr == NULL) {

   195         jobject isa = NULL;

   196         int port;

   197         jobject ia = NET_SockaddrToInetAddress(env, &sa, &port);

   198         if (ia != NULL) {

   199             isa = (*env)->NewObject(env, isa_class, isa_ctorID, ia, port);

   200         }

   201         CHECK_NULL_RETURN(isa, IOS_THROWN);

   202 

   203         // update cachedSenderInetAddress/cachedSenderPort

   204         (*env)->SetObjectField(env, this, dci_senderAddrID, ia);

   205         (*env)->SetIntField(env, this, dci_senderPortID,

   206                             NET_GetPortFromSockaddr(&sa));

   207         (*env)->SetObjectField(env, this, dci_senderID, isa);

   208     }

   209     return n;

   210 }

   211 

   212 JNIEXPORT jint JNICALL

   213 Java_sun_nio_ch_DatagramChannelImpl_send0(JNIEnv *env, jobject this,

   214                                           jboolean preferIPv6, jobject fdo,

   215                                           jlong address, jint len,

   216                                           jobject destAddress, jint destPort)

   217 {

   218     jint fd = fdval(env, fdo);

   219     void *buf = (void *)jlong_to_ptr(address);

   220     SOCKETADDRESS sa;

   221     int sa_len = 0;

   222     jint rv = 0;

   223 

   224     if (NET_InetAddressToSockaddr(env, destAddress, destPort, &sa,

   225                                   &sa_len, preferIPv6) != 0) {

   226       return IOS_THROWN;

   227     }

   228 

   229     rv = sendto((SOCKET)fd, buf, len, 0, &sa.sa, sa_len);

   230     if (rv == SOCKET_ERROR) {

   231         int theErr = (jint)WSAGetLastError();

   232         if (theErr == WSAEWOULDBLOCK) {

   233             return IOS_UNAVAILABLE;

   234         }

   235         return handleSocketError(env, (jint)WSAGetLastError());

   236     }

   237     return rv;

   238 }