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