/*

 * Copyright (c) 1997, 2012, 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 <netinet/in.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#ifdef __solaris__

#include <fcntl.h>

#endif

#ifdef __linux__

#include <unistd.h>

#include <sys/sysctl.h>

#include <sys/utsname.h>

#include <netinet/ip.h>

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

#ifndef IPTOS_TOS_MASK

#define IPTOS_TOS_MASK 0x1e

#endif

#ifndef IPTOS_PREC_MASK

#define IPTOS_PREC_MASK 0xe0

#endif

#include "jvm.h"

#include "jni_util.h"

#include "net_util.h"

#include "java_net_SocketOptions.h"

#include "java_net_PlainDatagramSocketImpl.h"

#include "java_net_NetworkInterface.h"

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

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

extern void setDefaultScopeID(JNIEnv *env, struct sockaddr *him);

extern int getDefaultScopeID(JNIEnv *env);

/*

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

#ifdef __linux__

    struct utsname sysinfo;

#endif

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

    Java_java_net_InetAddress_init(env, 0);

    Java_java_net_Inet4Address_init(env, 0);

    Java_java_net_Inet6Address_init(env, 0);

    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;

    SOCKADDR him;

    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, (struct sockaddr *)&him, &len, JNI_TRUE) != 0) {

      return;

    }

    setDefaultScopeID(env, (struct sockaddr *)&him);

    if (NET_Bind(fd, (struct sockaddr *)&him, len) < 0)  {

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

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

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "BindException",

                            "Bind failed");

        } else {

            NET_ThrowByNameWithLastError(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 (JVM_GetSockName(fd, (struct sockaddr *)&him, &len) == -1) {

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",

                            "Error getting socket name");

            return;

        }

        localport = NET_GetPortFromSockaddr((struct sockaddr *)&him);

        (*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 */

    SOCKADDR 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, (struct sockaddr *)&rmtaddr, &len, JNI_TRUE) != 0) {

      return;

    }

    setDefaultScopeID(env, (struct sockaddr *)&rmtaddr);

    if (JVM_Connect(fd, (struct sockaddr *)&rmtaddr, len) == -1) {

        NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "ConnectException",

                        "Connect failed");

        return;

    }

}

/*

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

    SOCKADDR addr;

    int len;

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

#ifdef AF_INET6

        if (ipv6_available()) {

            struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)&addr;

            him6->sin6_family = AF_UNSPEC;

            len = sizeof(struct sockaddr_in6);

        } else

#endif

        {

            struct sockaddr_in *him4 = (struct sockaddr_in*)&addr;

            him4->sin_family = AF_UNSPEC;

            len = sizeof(struct sockaddr_in);

        }

        JVM_Connect(fd, (struct sockaddr *)&addr, len);

#ifdef __linux__

        int localPort = 0;

        if (JVM_GetSockName(fd, (struct sockaddr *)&addr, &len) == -1)

            return;

        localPort = NET_GetPortFromSockaddr((struct sockaddr *)&addr);

        if (localPort == 0) {

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

#ifdef AF_INET6

            if (((struct sockaddr*)&addr)->sa_family == AF_INET6) {

                ((struct sockaddr_in6*)&addr)->sin6_port = htons(localPort);

            } else

#endif /* AF_INET6 */

            {

                ((struct sockaddr_in*)&addr)->sin_port = htons(localPort);

            }

            NET_Bind(fd, (struct sockaddr *)&addr, len);

        }

#endif

#else

    JVM_Connect(fd, 0, 0);

#endif

}

/*

 * Class:     java_net_PlainDatagramSocketImpl

 * Method:    send

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

 */

JNIEXPORT void JNICALL

Java_java_net_PlainDatagramSocketImpl_send(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;

    SOCKADDR rmtaddr, *rmtaddrP=&rmtaddr;

    int len;

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

    if (connected) {

        /* arg to NET_Sendto () null in this case */

        len = 0;

        rmtaddrP = 0;

    } else {

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

        if (NET_InetAddressToSockaddr(env, packetAddress, packetPort, (struct sockaddr *)&rmtaddr, &len, JNI_TRUE) != 0) {

          return;

        }

    }

    setDefaultScopeID(env, (struct sockaddr *)&rmtaddr);

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

#ifdef AF_INET6

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

        NET_SetTrafficClass((struct sockaddr *)&rmtaddr, trafficClass);

    }

#endif /* AF_INET6 */

    /*

     * 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,

                     (struct sockaddr *)rmtaddrP, len);

    if (ret < 0) {

        switch (ret) {

            case JVM_IO_ERR :

                if (errno == ECONNREFUSED) {

                    JNU_ThrowByName(env, JNU_JAVANETPKG "PortUnreachableException",

                            "ICMP Port Unreachable");

                } else {

                    NET_ThrowByNameWithLastError(env, "java/io/IOException", "sendto failed");

                }

                break;

            case JVM_IO_INTR:

                JNU_ThrowByName(env, "java/io/InterruptedIOException",

                                "operation interrupted");

                break;

        }

    }

    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;

    SOCKADDR remote_addr;

    int len;

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

    }

    if (timeout) {

        int ret = NET_Timeout(fd, timeout);

        if (ret == 0) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",

                            "Peek timed out");

            return ret;

        } else if (ret == JVM_IO_ERR) {

            if (errno == EBADF) {

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

            } else {

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

            }