/*

 * Copyright (c) 1997, 2018, 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.

 */

#include <malloc.h>

#include "net_util.h"

#include "NetworkInterface.h"

#include "java_net_TwoStacksPlainDatagramSocketImpl.h"

#include "java_net_SocketOptions.h"

#include "java_net_NetworkInterface.h"

#include "java_net_InetAddress.h"

#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;

/*

 * 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 "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));

    /*

     * 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) {

    /* 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);

}

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 ipv6_supported = ipv6_available();

    int fd, fd1 = -1, lcladdrlen = 0;

    jint family;

    SOCKETADDRESS lcladdr;

    family = getInetAddress_family(env, addressObj);

    JNU_CHECK_EXCEPTION(env);

    if (family == java_net_InetAddress_IPv6 && !ipv6_supported) {

        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;

    }

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

                                  &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, lcladdrlen, exclBind) == -1) {

            if (WSAGetLastError() == WSAEACCES) {

                WSASetLastError(WSAEADDRINUSE);

            }

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

            NET_ThrowCurrent(env, "Cannot bind");

            closesocket(fd);

            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

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainDatagramSocketImpl_connect0

  (JNIEnv *env, jobject this, jobject address, jint port)

{

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

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

    jint fd = -1, fd1 = -1, fdc, family;

    SOCKETADDRESS rmtaddr;

    int rmtaddrlen = 0;

    DWORD x1, x2; /* ignored result codes */

    int res, t;

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

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Socket closed");

        return;

    }

    if (!IS_NULL(fdObj)) {

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

    }

    if (!IS_NULL(fd1Obj)) {

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

    }

    if (IS_NULL(address)) {

        JNU_ThrowNullPointerException(env, "address");

        return;

    }

    family = getInetAddress_family(env, address);

    JNU_CHECK_EXCEPTION(env);

    if (family == java_net_InetAddress_IPv6 && !ipv6_available()) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Protocol family not supported");

        return;

    }

    fdc = family == java_net_InetAddress_IPv4 ? fd : fd1;

    /* SIO_UDP_CONNRESET fixes a bug introduced in Windows 2000, which

     * returns connection reset errors on connected UDP sockets (as well

     * as connected sockets). The solution is to only enable this feature

     * when the socket is connected

     */

    t = TRUE;

    res = WSAIoctl(fdc, SIO_UDP_CONNRESET, &t, sizeof(t), &x1, sizeof(x1), &x2, 0, 0);

    if (NET_InetAddressToSockaddr(env, address, port, &rmtaddr,

                                  &rmtaddrlen, JNI_FALSE) != 0) {

        return;

    }

    if (connect(fdc, &rmtaddr.sa, rmtaddrlen) == -1) {

        NET_ThrowCurrent(env, "connect");

        return;

    }

}

/*

 * Class:     java_net_TwoStacksPlainDatagramSocketImpl

 * Method:    disconnect0

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainDatagramSocketImpl_disconnect0(JNIEnv *env, jobject this, jint family) {

    /* The object's field */

    jobject fdObj;

    /* The fdObj'fd */

    jint fd, len;

    SOCKETADDRESS addr;

    DWORD x1 = 0, x2 = 0; /* ignored result codes */

    int t;

    if (family == java_net_InetAddress_IPv4) {

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

        len = sizeof(struct sockaddr_in);

    } else {

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

        len = sizeof(struct sockaddr_in6);

    }

    if (IS_NULL(fdObj)) {

        /* disconnect doesn't throw any exceptions */

        return;

    }

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

    memset((char *)&addr, 0, len);

    connect(fd, &addr.sa, len);

    /*

     * use SIO_UDP_CONNRESET

     * to disable ICMP port unreachable handling here.

     */

    t = FALSE;

    WSAIoctl(fd, SIO_UDP_CONNRESET, &t, sizeof(t), &x1, sizeof(x1), &x2, 0, 0);

}

/*

 * Class:     java_net_TwoStacksPlainDatagramSocketImpl

 * Method:    send0

 * Signature: (Ljava/net/DatagramPacket;)V

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainDatagramSocketImpl_send0

  (JNIEnv *env, jobject this, jobject packet)

{

    char BUF[MAX_BUFFER_LEN];

    char *fullPacket;

    jobject fdObj;

    jint fd;

    jobject iaObj;

    jint family;

    jint packetBufferOffset, packetBufferLen, packetPort;

    jbyteArray packetBuffer;

    jboolean connected;

    SOCKETADDRESS rmtaddr;

    struct sockaddr *addrp = 0;

    int addrlen = 0;

    if (IS_NULL(packet)) {

        JNU_ThrowNullPointerException(env, "null packet");

        return;

    }

    iaObj = (*env)->GetObjectField(env, packet, dp_addressID);

    packetPort = (*env)->GetIntField(env, packet, dp_portID);

    packetBufferOffset = (*env)->GetIntField(env, packet, dp_offsetID);

    packetBuffer = (jbyteArray)(*env)->GetObjectField(env, packet, dp_bufID);

    connected = (*env)->GetBooleanField(env, this, pdsi_connected);

    if (IS_NULL(iaObj) || IS_NULL(packetBuffer)) {

        JNU_ThrowNullPointerException(env, "null address || null buffer");

        return;

    }

    family = getInetAddress_family(env, iaObj);

    JNU_CHECK_EXCEPTION(env);

    if (family == java_net_InetAddress_IPv4) {

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

    } else {

        if (!ipv6_available()) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Protocol not allowed");

            return;

        }

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

    }

    if (IS_NULL(fdObj)) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Socket closed");

        return;

    }

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

    packetBufferLen = (*env)->GetIntField(env, packet, dp_lengthID);

    /* Note: the buffer needn't be greater than 65,536 (0xFFFF)...

     * the maximum size of an IP packet. Anything bigger is truncated anyway.

     */

    if (packetBufferLen > MAX_PACKET_LEN) {

        packetBufferLen = MAX_PACKET_LEN;

    }

    // sockaddr arg to sendto() is null if already connected

    if (!connected) {

        if (NET_InetAddressToSockaddr(env, iaObj, packetPort, &rmtaddr,

                                      &addrlen, JNI_FALSE) != 0) {

            return;

        }

        addrp = &rmtaddr.sa;

    }

    if (packetBufferLen > MAX_BUFFER_LEN) {

        /* When JNI-ifying the JDK's IO routines, we turned

         * reads and writes of byte arrays of size greater

         * than 2048 bytes into several operations of size 2048.

         * This saves a malloc()/memcpy()/free() for big

         * buffers.  This is OK for file IO and TCP, but that

         * strategy violates the semantics of a datagram protocol.

         * (one big send) != (several smaller sends).  So here

         * we *must* alloc the buffer.  Note it needn't be bigger

         * than 65,536 (0xFFFF) the max size of an IP packet.

         * anything bigger is truncated anyway.

         */

        fullPacket = (char *)malloc(packetBufferLen);

        if (!fullPacket) {

            JNU_ThrowOutOfMemoryError(env, "Send buf native heap allocation failed");

            return;

        }

    } else {

        fullPacket = &(BUF[0]);

    }