/*

 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.

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

 *

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

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

 * published by the Free Software Foundation.  Oracle designates this

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

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

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 */

#ifndef IPTOS_TOS_MASK

#define IPTOS_TOS_MASK 0x1e

#endif

#ifndef IPTOS_PREC_MASK

#define IPTOS_PREC_MASK 0xe0

#endif

#define IN_CLASSD(i)    (((long)(i) & 0xf0000000) == 0xe0000000)

#define IN_MULTICAST(i) IN_CLASSD(i)

extern int getAllInterfacesAndAddresses(JNIEnv *env, netif **netifPP);

/************************************************************************

 * TwoStacksPlainDatagramSocketImpl

 */

static jfieldID IO_fd_fdID;

static jfieldID pdsi_trafficClassID;

jfieldID pdsi_fdID;

jfieldID pdsi_fd1ID;

jfieldID pdsi_fduseID;

jfieldID pdsi_lastfdID;

jfieldID pdsi_timeoutID;

jfieldID pdsi_localPortID;

jfieldID pdsi_connected;

static jclass ia4_clazz;

static jmethodID ia4_ctor;

static CRITICAL_SECTION sizeCheckLock;

/* Windows OS version is XP or better */

static int xp_or_later = 0;

/* Windows OS version is Windows 2000 or better */

static int w2k_or_later = 0;

/*

 * Notes about UDP/IPV6 on Windows (XP and 2003 server):

 *

 * fd always points to the IPv4 fd, and fd1 points to the IPv6 fd.

 * Both fds are used when we bind to a wild-card address. When a specific

 * address is used, only one of them is used.

 */

/*

 * Returns a java.lang.Integer based on 'i'

 */

jobject createInteger(JNIEnv *env, int i) {

    static jclass i_class = NULL;

    static jmethodID i_ctrID;

    static jfieldID i_valueID;

    if (i_class == NULL) {

        jclass c = (*env)->FindClass(env, "java/lang/Integer");

        CHECK_NULL_RETURN(c, NULL);

        i_ctrID = (*env)->GetMethodID(env, c, "<init>", "(I)V");

        CHECK_NULL_RETURN(i_ctrID, NULL);

        i_class = (*env)->NewGlobalRef(env, c);

        CHECK_NULL_RETURN(i_class, NULL);

    }

    return (*env)->NewObject(env, i_class, i_ctrID, i);

}

/*

 * Returns a java.lang.Boolean based on 'b'

 */

jobject createBoolean(JNIEnv *env, int b) {

    static jclass b_class = NULL;

    static jmethodID b_ctrID;

    static jfieldID b_valueID;

    if (b_class == NULL) {

        jclass c = (*env)->FindClass(env, "java/lang/Boolean");

        CHECK_NULL_RETURN(c, NULL);

        b_ctrID = (*env)->GetMethodID(env, c, "<init>", "(Z)V");

        CHECK_NULL_RETURN(b_ctrID, NULL);

        b_class = (*env)->NewGlobalRef(env, c);

        CHECK_NULL_RETURN(b_class, NULL);

    }

    return (*env)->NewObject(env, b_class, b_ctrID, (jboolean)(b!=0));

}

static int getFD(JNIEnv *env, jobject this) {

    jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);

    if (fdObj == NULL) {

        return -1;

    }

    return (*env)->GetIntField(env, fdObj, IO_fd_fdID);

}

static int getFD1(JNIEnv *env, jobject this) {

    jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fd1ID);

    if (fdObj == NULL) {

        return -1;

    }

    return (*env)->GetIntField(env, fdObj, IO_fd_fdID);

}

/*

 * This function returns JNI_TRUE if the datagram size exceeds the underlying

 * provider's ability to send to the target address. The following OS

 * oddities have been observed :-

 *

 * 1. On Windows 95/98 if we try to send a datagram > 12k to an application

 *    on the same machine then the send will fail silently.

 *

 * 2. On Windows ME if we try to send a datagram > supported by underlying

 *    provider then send will not return an error.

 *

 * 3. On Windows NT/2000 if we exceeds the maximum size then send will fail

 *    with WSAEADDRNOTAVAIL.

 *

 * 4. On Windows 95/98 if we exceed the maximum size when sending to

 *    another machine then WSAEINVAL is returned.

 *

 */

jboolean exceedSizeLimit(JNIEnv *env, jint fd, jint addr, jint size)

{

#define DEFAULT_MSG_SIZE        65527

    static jboolean initDone;

    static jboolean is95or98;

    static int maxmsg;

    typedef struct _netaddr  {          /* Windows 95/98 only */

        unsigned long addr;

        struct _netaddr *next;

    } netaddr;

    static netaddr *addrList;

    netaddr *curr;

    /*

     * First time we are called we must determine which OS this is and also

     * get the maximum size supported by the underlying provider.

     *

     * In addition on 95/98 we must enumerate our IP addresses.

     */

    if (!initDone) {

        EnterCriticalSection(&sizeCheckLock);

        if (initDone) {

            /* another thread got there first */

            LeaveCriticalSection(&sizeCheckLock);

        } else {

            OSVERSIONINFO ver;

            int len;

            /*

             * Step 1: Determine which OS this is.

             */

            ver.dwOSVersionInfoSize = sizeof(ver);

            GetVersionEx(&ver);

            is95or98 = JNI_FALSE;

            if (ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&

                ver.dwMajorVersion == 4 &&

                (ver.dwMinorVersion == 0 || ver.dwMinorVersion == 10)) {

                is95or98 = JNI_TRUE;

            }

            /*

             * Step 2: Determine the maximum datagram supported by the

             * underlying provider. On Windows 95 if winsock hasn't been

             * upgraded (ie: unsupported configuration) then we assume

             * the default 64k limit.

             */

            len = sizeof(maxmsg);

            if (NET_GetSockOpt(fd, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&maxmsg, &len) < 0) {

                maxmsg = DEFAULT_MSG_SIZE;

            }

            /*

             * Step 3: On Windows 95/98 then enumerate the IP addresses on

             * this machine. This is neccesary because we need to check if the

             * datagram is being sent to an application on the same machine.

             */

            if (is95or98) {

                char hostname[255];

                struct hostent *hp;

                if (gethostname(hostname, sizeof(hostname)) == -1) {

                    LeaveCriticalSection(&sizeCheckLock);

                    JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Unable to obtain hostname");

                    return JNI_TRUE;

                }

                hp = (struct hostent *)gethostbyname(hostname);

                if (hp != NULL) {

                    struct in_addr **addrp = (struct in_addr **) hp->h_addr_list;

                    while (*addrp != (struct in_addr *) 0) {

                        curr = (netaddr *)malloc(sizeof(netaddr));

                        if (curr == NULL) {

                            while (addrList != NULL) {

                                curr = addrList->next;

                                free(addrList);

                                addrList = curr;

                            }

                            LeaveCriticalSection(&sizeCheckLock);

                            JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed");

                            return JNI_TRUE;

                        }

                        curr->addr = htonl((*addrp)->S_un.S_addr);

                        curr->next = addrList;

                        addrList = curr;

                        addrp++;

                    }

                }

            }

            /*

             * Step 4: initialization is done so set flag and unlock cs

             */

            initDone = JNI_TRUE;

            LeaveCriticalSection(&sizeCheckLock);

        }

    }

    /*

     * Now examine the size of the datagram :-

     *

     * (a) If exceeds size of service provider return 'false' to indicate that

     *     we exceed the limit.

     * (b) If not 95/98 then return 'true' to indicate that the size is okay.

     * (c) On 95/98 if the size is <12k we are okay.

     * (d) On 95/98 if size > 12k then check if the destination is the current

     *     machine.

     */

    if (size > maxmsg) {        /* step (a) */

        return JNI_TRUE;

    }

    if (!is95or98) {            /* step (b) */

        return JNI_FALSE;

    }

    if (size <= 12280) {        /* step (c) */

        return JNI_FALSE;

    }

    /* step (d) */

    if ((addr & 0x7f000000) == 0x7f000000) {

        return JNI_TRUE;

    }

    curr = addrList;

    while (curr != NULL) {

        if (curr->addr == addr) {

            return JNI_TRUE;

        }

        curr = curr->next;

    }

    return JNI_FALSE;

}

/*

 * Return JNI_TRUE if this Windows edition supports ICMP Port Unreachable

 */

__inline static jboolean supportPortUnreachable() {

    static jboolean initDone;

    static jboolean portUnreachableSupported;

    if (!initDone) {

        OSVERSIONINFO ver;

        ver.dwOSVersionInfoSize = sizeof(ver);

        GetVersionEx(&ver);

        if (ver.dwPlatformId == VER_PLATFORM_WIN32_NT && ver.dwMajorVersion >= 5) {

            portUnreachableSupported = JNI_TRUE;

        } else {

            portUnreachableSupported = JNI_FALSE;

        }

        initDone = JNI_TRUE;

    }

    return portUnreachableSupported;

}

/*

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

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

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

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

 * socket.

 */

static jboolean purgeOutstandingICMP(JNIEnv *env, jobject this, jint fd)

{

    jboolean got_icmp = JNI_FALSE;

    char buf[1];

    fd_set tbl;

    struct timeval t = { 0, 0 };

    SOCKETADDRESS rmtaddr;

    int addrlen = sizeof(SOCKETADDRESS);

    memset((char *)&rmtaddr, 0, sizeof(rmtaddr));

    /*

     * A no-op if this OS doesn't support it.

     */

    if (!supportPortUnreachable()) {

        return JNI_FALSE;

    }

    /*

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

     * is then receive it.

     */

    FD_ZERO(&tbl);

    FD_SET(fd, &tbl);

    while(1) {

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

            break;

        }

        if (recvfrom(fd, buf, 1, MSG_PEEK, &rmtaddr.sa, &addrlen) != SOCKET_ERROR) {

            break;

        }

        if (WSAGetLastError() != WSAECONNRESET) {

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

            break;

        }

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

        got_icmp = JNI_TRUE;

    }

    return got_icmp;

}

/*

 * Class:     java_net_TwoStacksPlainDatagramSocketImpl

 * Method:    init

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainDatagramSocketImpl_init(JNIEnv *env, jclass cls) {

    OSVERSIONINFO ver;

    int version;

    ver.dwOSVersionInfoSize = sizeof(ver);

    GetVersionEx(&ver);

    version = ver.dwMajorVersion * 10 + ver.dwMinorVersion;

    xp_or_later = (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) && (version >= 51);

    w2k_or_later = (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) && (version >= 50);

    /* get fieldIDs */

    pdsi_fdID = (*env)->GetFieldID(env, cls, "fd", "Ljava/io/FileDescriptor;");

    CHECK_NULL(pdsi_fdID);

    pdsi_fd1ID = (*env)->GetFieldID(env, cls, "fd1", "Ljava/io/FileDescriptor;");

    CHECK_NULL(pdsi_fd1ID);

    pdsi_timeoutID = (*env)->GetFieldID(env, cls, "timeout", "I");

    CHECK_NULL(pdsi_timeoutID);

    pdsi_fduseID = (*env)->GetFieldID(env, cls, "fduse", "I");

    CHECK_NULL(pdsi_fduseID);

    pdsi_lastfdID = (*env)->GetFieldID(env, cls, "lastfd", "I");

    CHECK_NULL(pdsi_lastfdID);

    pdsi_trafficClassID = (*env)->GetFieldID(env, cls, "trafficClass", "I");

    CHECK_NULL(pdsi_trafficClassID);

    pdsi_localPortID = (*env)->GetFieldID(env, cls, "localPort", "I");

    CHECK_NULL(pdsi_localPortID);

    pdsi_connected = (*env)->GetFieldID(env, cls, "connected", "Z");

    CHECK_NULL(pdsi_connected);

    cls = (*env)->FindClass(env, "java/io/FileDescriptor");

    CHECK_NULL(cls);

    IO_fd_fdID = NET_GetFileDescriptorID(env);

    CHECK_NULL(IO_fd_fdID);

    ia4_clazz = (*env)->FindClass(env, "java/net/Inet4Address");

    CHECK_NULL(ia4_clazz);

    ia4_clazz = (*env)->NewGlobalRef(env, ia4_clazz);

    CHECK_NULL(ia4_clazz);

    ia4_ctor = (*env)->GetMethodID(env, ia4_clazz, "<init>", "()V");

    CHECK_NULL(ia4_ctor);

    InitializeCriticalSection(&sizeCheckLock);

}

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainDatagramSocketImpl_bind0(JNIEnv *env, jobject this,

                                           jint port, jobject addressObj,

                                           jboolean exclBind) {

    jobject fdObj = (*env)->GetObjectField(env, this, pdsi_fdID);

    jobject fd1Obj = (*env)->GetObjectField(env, this, pdsi_fd1ID);

    int fd, fd1 = -1, family;

    int ipv6_supported = ipv6_available();

    SOCKETADDRESS lcladdr;

    int lcladdrlen = sizeof(SOCKETADDRESS);

    int address;

    memset((char *)&lcladdr, 0, sizeof(lcladdr));

    family = getInetAddress_family(env, addressObj);

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Protocol family not supported");

        return;

    }

    if (IS_NULL(fdObj) || (ipv6_supported && IS_NULL(fd1Obj))) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "socket closed");

        return;

    } else {

        fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);

        if (ipv6_supported) {

            fd1 = (*env)->GetIntField(env, fd1Obj, IO_fd_fdID);

        }

    }

    if (IS_NULL(addressObj)) {

        JNU_ThrowNullPointerException(env, "argument address");

        return;

    } else {

        address = getInetAddress_addr(env, addressObj);

    }

    if (NET_InetAddressToSockaddr(env, addressObj, port, &lcladdr.sa,

                                  &lcladdrlen, JNI_FALSE) != 0) {

        return;

    }

    if (ipv6_supported) {

        struct ipv6bind v6bind;

        v6bind.addr = &lcladdr;

        v6bind.ipv4_fd = fd;

        v6bind.ipv6_fd = fd1;

        if (NET_BindV6(&v6bind, exclBind) != -1) {

            /* check if the fds have changed */

            if (v6bind.ipv4_fd != fd) {

                fd = v6bind.ipv4_fd;

                if (fd == -1) {

                    /* socket is closed. */

                    (*env)->SetObjectField(env, this, pdsi_fdID, NULL);

                } else {

                    /* socket was re-created */

                    (*env)->SetIntField(env, fdObj, IO_fd_fdID, fd);

                }

            }

            if (v6bind.ipv6_fd != fd1) {

                fd1 = v6bind.ipv6_fd;

                if (fd1 == -1) {

                    /* socket is closed. */

                    (*env)->SetObjectField(env, this, pdsi_fd1ID, NULL);

                } else {

                    /* socket was re-created */

                    (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);

                }

            }

        } else {

            /* NET_BindV6() closes both sockets upon a failure */

            (*env)->SetObjectField(env, this, pdsi_fdID, NULL);

            (*env)->SetObjectField(env, this, pdsi_fd1ID, NULL);

            NET_ThrowCurrent (env, "Cannot bind");

            return;

        }

    } else {

        if (NET_WinBind(fd, &lcladdr.sa, lcladdrlen, exclBind) == -1) {

            if (WSAGetLastError() == WSAEACCES) {

                WSASetLastError(WSAEADDRINUSE);

            }

            NET_ThrowCurrent(env, "Cannot bind");

            return;

        }

    }

    if (port == 0) {

        if (getsockname(fd == -1 ? fd1 : fd, &lcladdr.sa, &lcladdrlen) == -1) {

            NET_ThrowCurrent(env, "getsockname");

            return;

        }

        port = ntohs((u_short) GET_PORT (&lcladdr));

    }

    (*env)->SetIntField(env, this, pdsi_localPortID, port);

}

/*

 * Class:     java_net_TwoStacksPlainDatagramSocketImpl

 * Method:    connect0

 * Signature: (Ljava/net/InetAddress;I)V

 */