/*

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

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>

#if defined(__solaris__)

#include <sys/filio.h>

#endif

#include "net_util.h"

#include "java_net_PlainDatagramSocketImpl.h"

#include "java_net_InetAddress.h"

#include "java_net_NetworkInterface.h"

#include "java_net_SocketOptions.h"

#ifdef __linux__

#define IPV6_MULTICAST_IF 17

#ifndef SO_BSDCOMPAT

#define SO_BSDCOMPAT  14

#endif

/**

 * IP_MULTICAST_ALL has been supported since kernel version 2.6.31

 * but we may be building on a machine that is older than that.

 */

#ifndef IP_MULTICAST_ALL

#define IP_MULTICAST_ALL      49

#endif

#endif  //  __linux__

#ifdef __solaris__

#ifndef BSD_COMP

#define BSD_COMP

#endif

#endif

#ifndef IPTOS_TOS_MASK

#define IPTOS_TOS_MASK 0x1e

#endif

#ifndef IPTOS_PREC_MASK

#define IPTOS_PREC_MASK 0xe0

#endif

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

 * PlainDatagramSocketImpl

 */

static jfieldID IO_fd_fdID;

static jfieldID pdsi_fdID;

static jfieldID pdsi_timeoutID;

static jfieldID pdsi_trafficClassID;

static jfieldID pdsi_localPortID;

static jfieldID pdsi_connected;

static jfieldID pdsi_connectedAddress;

static jfieldID pdsi_connectedPort;

/*

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

 */

static jobject createInteger(JNIEnv *env, int i) {

    static jclass i_class;

    static jmethodID i_ctrID;

    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'

 */

static jobject createBoolean(JNIEnv *env, int b) {

    static jclass b_class;

    static jmethodID b_ctrID;

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

}

/*

 * Returns the fd for a PlainDatagramSocketImpl or -1

 * if closed.

 */

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

}

/*

 * Class:     java_net_PlainDatagramSocketImpl

 * Method:    init

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_java_net_PlainDatagramSocketImpl_init(JNIEnv *env, jclass cls) {

    pdsi_fdID = (*env)->GetFieldID(env, cls, "fd",

                                   "Ljava/io/FileDescriptor;");

    CHECK_NULL(pdsi_fdID);

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

    CHECK_NULL(pdsi_timeoutID);

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

    pdsi_connectedAddress = (*env)->GetFieldID(env, cls, "connectedAddress",

                                               "Ljava/net/InetAddress;");

    CHECK_NULL(pdsi_connectedAddress);

    pdsi_connectedPort = (*env)->GetFieldID(env, cls, "connectedPort", "I");

    CHECK_NULL(pdsi_connectedPort);

    IO_fd_fdID = NET_GetFileDescriptorID(env);

    CHECK_NULL(IO_fd_fdID);

    initInetAddressIDs(env);

    JNU_CHECK_EXCEPTION(env);

    Java_java_net_NetworkInterface_init(env, 0);

}

/*

 * Class:     java_net_PlainDatagramSocketImpl

 * Method:    bind

 * Signature: (ILjava/net/InetAddress;)V

 */

JNIEXPORT void JNICALL

Java_java_net_PlainDatagramSocketImpl_bind0(JNIEnv *env, jobject this,

                                            jint localport, jobject iaObj) {

    /* fdObj is the FileDescriptor field on this */

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

    /* fd is an int field on fdObj */

    int fd;

    int len = 0;

    SOCKETADDRESS sa;

    socklen_t slen = sizeof(SOCKETADDRESS);

    if (IS_NULL(fdObj)) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Socket closed");

        return;

    } else {

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

    }

    if (IS_NULL(iaObj)) {

        JNU_ThrowNullPointerException(env, "iaObj is null.");

        return;

    }

    /* bind */

    if (NET_InetAddressToSockaddr(env, iaObj, localport, &sa, &len,

                                  JNI_TRUE) != 0) {

      return;

    }

    if (NET_Bind(fd, &sa, len) < 0)  {

        if (errno == EADDRINUSE || errno == EADDRNOTAVAIL ||

            errno == EPERM || errno == EACCES) {

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "BindException",

                            "Bind failed");

        } else {

            JNU_ThrowByNameWithMessageAndLastError

                (env, JNU_JAVANETPKG "SocketException", "Bind failed");

        }

        return;

    }

    /* initialize the local port */

    if (localport == 0) {

        /* Now that we're a connected socket, let's extract the port number

         * that the system chose for us and store it in the Socket object.

         */

        if (getsockname(fd, &sa.sa, &slen) == -1) {

            JNU_ThrowByNameWithMessageAndLastError

                (env, JNU_JAVANETPKG "SocketException", "Error getting socket name");

            return;

        }

        localport = NET_GetPortFromSockaddr(&sa);

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

    } else {

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

    }

}

/*

 * Class:     java_net_PlainDatagramSocketImpl

 * Method:    connect0

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

 */

JNIEXPORT void JNICALL

Java_java_net_PlainDatagramSocketImpl_connect0(JNIEnv *env, jobject this,

                                               jobject address, jint port) {

    /* The object's field */

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

    /* The fdObj'fd */

    jint fd;

    /* The packetAddress address, family and port */

    SOCKETADDRESS rmtaddr;

    int len = 0;

    if (IS_NULL(fdObj)) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Socket closed");

        return;

    }

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

    if (IS_NULL(address)) {

        JNU_ThrowNullPointerException(env, "address");

        return;

    }

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

                                  JNI_TRUE) != 0) {

      return;

    }

    if (NET_Connect(fd, &rmtaddr.sa, len) == -1) {

        NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "ConnectException",

                        "Connect failed");

    }

}

/*

 * Class:     java_net_PlainDatagramSocketImpl

 * Method:    disconnect0

 * Signature: ()V

 */

JNIEXPORT void JNICALL

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

    /* The object's field */

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

    /* The fdObj'fd */

    jint fd;

#if defined(__linux__) || defined(_ALLBSD_SOURCE)

    SOCKETADDRESS addr;

    socklen_t len;

#if defined(__linux__)

    int localPort = 0;

#endif

#endif

    if (IS_NULL(fdObj)) {

        return;

    }

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

#if defined(__linux__) || defined(_ALLBSD_SOURCE)

    memset(&addr, 0, sizeof(addr));

    if (ipv6_available()) {

        addr.sa6.sin6_family = AF_UNSPEC;

        len = sizeof(struct sockaddr_in6);

    } else {

        addr.sa4.sin_family = AF_UNSPEC;

        len = sizeof(struct sockaddr_in);

    }

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

#if defined(__linux__)

    if (getsockname(fd, &addr.sa, &len) == -1)

        return;

    localPort = NET_GetPortFromSockaddr(&addr);

    if (localPort == 0) {

        localPort = (*env)->GetIntField(env, this, pdsi_localPortID);

        if (addr.sa.sa_family == AF_INET6) {

            addr.sa6.sin6_port = htons(localPort);

        } else {

            addr.sa4.sin_port = htons(localPort);

        }

        NET_Bind(fd, &addr, len);

    }

#endif

#else

    NET_Connect(fd, 0, 0);

#endif

}

/*

 * Class:     java_net_PlainDatagramSocketImpl

 * Method:    send0

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

 */

JNIEXPORT void JNICALL

Java_java_net_PlainDatagramSocketImpl_send0(JNIEnv *env, jobject this,

                                           jobject packet) {

    char BUF[MAX_BUFFER_LEN];

    char *fullPacket = NULL;

    int ret, mallocedPacket = JNI_FALSE;

    /* The object's field */

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

    jint trafficClass = (*env)->GetIntField(env, this, pdsi_trafficClassID);

    jbyteArray packetBuffer;

    jobject packetAddress;

    jint packetBufferOffset, packetBufferLen, packetPort;

    jboolean connected;

    /* The fdObj'fd */

    jint fd;

    SOCKETADDRESS rmtaddr;

    struct sockaddr *rmtaddrP = 0;

    int len = 0;

    if (IS_NULL(fdObj)) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Socket closed");

        return;

    }

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

    if (IS_NULL(packet)) {

        JNU_ThrowNullPointerException(env, "packet");

        return;

    }

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

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

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

    if (IS_NULL(packetBuffer) || IS_NULL(packetAddress)) {

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

        return;

    }

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

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

    // arg to NET_Sendto() null, if connected

    if (!connected) {

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

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

                                      &len, JNI_TRUE) != 0) {

            return;

        }

        rmtaddrP = &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* allocate the buffer.  Note it needn't be bigger

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

         * Anything bigger should be truncated anyway.

         *

         * We may want to use a smarter allocation scheme at some

         * point.

         */

        if (packetBufferLen > MAX_PACKET_LEN) {

            packetBufferLen = MAX_PACKET_LEN;

        }

        fullPacket = (char *)malloc(packetBufferLen);

        if (!fullPacket) {

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

            return;

        } else {

            mallocedPacket = JNI_TRUE;

        }

    } else {

        fullPacket = &(BUF[0]);

    }

    (*env)->GetByteArrayRegion(env, packetBuffer, packetBufferOffset, packetBufferLen,

                               (jbyte *)fullPacket);

    if (trafficClass != 0 && ipv6_available()) {

        NET_SetTrafficClass(&rmtaddr, trafficClass);

    }

    /*

     * Send the datagram.

     *

     * If we are connected it's possible that sendto will return

     * ECONNREFUSED indicating that an ICMP port unreachable has

     * received.

     */

    ret = NET_SendTo(fd, fullPacket, packetBufferLen, 0, rmtaddrP, len);

    if (ret < 0) {

        if (errno == ECONNREFUSED) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",

                            "ICMP Port Unreachable");

        } else {

            JNU_ThrowIOExceptionWithLastError(env, "sendto failed");

        }

    }

    if (mallocedPacket) {

        free(fullPacket);

    }

    return;

}

/*

 * Class:     java_net_PlainDatagramSocketImpl

 * Method:    peek

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

 */

JNIEXPORT jint JNICALL

Java_java_net_PlainDatagramSocketImpl_peek(JNIEnv *env, jobject this,

                                           jobject addressObj) {

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

    jint timeout = (*env)->GetIntField(env, this, pdsi_timeoutID);

    jint fd;

    ssize_t n;

    SOCKETADDRESS rmtaddr;

    socklen_t slen = sizeof(SOCKETADDRESS);

    char buf[1];

    jint family;

    jobject iaObj;

    int port;

    if (IS_NULL(fdObj)) {

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

        return -1;

    } else {

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

    }

    if (IS_NULL(addressObj)) {

        JNU_ThrowNullPointerException(env, "Null address in peek()");

        return -1;

    }

    if (timeout) {

        int ret = NET_Timeout(env, fd, timeout, JVM_NanoTime(env, 0));

        if (ret == 0) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",

                            "Peek timed out");

            return ret;

        } else if (ret == -1) {

            if (errno == EBADF) {

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

            } else if (errno == ENOMEM) {

                 JNU_ThrowOutOfMemoryError(env, "NET_Timeout native heap allocation failed");

            } else {

                 JNU_ThrowByNameWithMessageAndLastError

                     (env, JNU_JAVANETPKG "SocketException", "Peek failed");

            }

            return ret;

        }

    }

    n = NET_RecvFrom(fd, buf, 1, MSG_PEEK, &rmtaddr.sa, &slen);

    if (n == -1) {

#ifdef __solaris__

        if (errno == ECONNREFUSED) {

            int orig_errno = errno;

            recv(fd, buf, 1, 0);

            errno = orig_errno;

        }

#endif

        if (errno == ECONNREFUSED) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",

                            "ICMP Port Unreachable");

        } else {

            if (errno == EBADF) {