/*

 * 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

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

 *

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

 *

 */

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#if defined(__linux__) && !defined(USE_SELECT)

#include <sys/poll.h>

#endif

#include <netinet/tcp.h>        /* Defines TCP_NODELAY, needed for 2.6 */

#include <netinet/in.h>

#ifdef __linux__

#include <netinet/ip.h>

#endif

#include <netdb.h>

#include <stdlib.h>

#ifdef __solaris__

#include <fcntl.h>

#endif

#ifdef __linux__

#include <linux/unistd.h>

#include <linux/sysctl.h>

#endif

#include "jvm.h"

#include "jni_util.h"

#include "net_util.h"

#include "java_net_SocketOptions.h"

#include "java_net_PlainSocketImpl.h"

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

 * PlainSocketImpl

 */

static jfieldID IO_fd_fdID;

jfieldID psi_fdID;

jfieldID psi_addressID;

jfieldID psi_ipaddressID;

jfieldID psi_portID;

jfieldID psi_localportID;

jfieldID psi_timeoutID;

jfieldID psi_trafficClassID;

jfieldID psi_serverSocketID;

jfieldID psi_fdLockID;

jfieldID psi_closePendingID;

/*

 * file descriptor used for dup2

 */

static int marker_fd = -1;

#define SET_NONBLOCKING(fd) {           \

        int flags = fcntl(fd, F_GETFL); \

        flags |= O_NONBLOCK;            \

        fcntl(fd, F_SETFL, flags);      \

}

#define SET_BLOCKING(fd) {              \

        int flags = fcntl(fd, F_GETFL); \

        flags &= ~O_NONBLOCK;           \

        fcntl(fd, F_SETFL, flags);      \

}

/*

 * Create the marker file descriptor by establishing a loopback connection

 * which we shutdown but do not close the fd. The result is an fd that

 * can be used for read/write.

 */

static int getMarkerFD()

{

    int sv[2];

#ifdef AF_UNIX

    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {

        return -1;

    }

#else

    return -1;

#endif

    /*

     * Finally shutdown sv[0] (any reads to this fd will get

     * EOF; any writes will get an error).

     */

    JVM_SocketShutdown(sv[0], 2);

    JVM_SocketClose(sv[1]);

    return sv[0];

}

/*

 * Return the file descriptor given a PlainSocketImpl

 */

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

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

    CHECK_NULL_RETURN(fdObj, -1);

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

}

/*

 * The initroto function is called whenever PlainSocketImpl is

 * loaded, to cache fieldIds for efficiency. This is called everytime

 * the Java class is loaded.

 *

 * Class:     java_net_PlainSocketImpl

 * Method:    initProto

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_java_net_PlainSocketImpl_initProto(JNIEnv *env, jclass cls) {

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

                                  "Ljava/io/FileDescriptor;");

    CHECK_NULL(psi_fdID);

    psi_addressID = (*env)->GetFieldID(env, cls, "address",

                                          "Ljava/net/InetAddress;");

    CHECK_NULL(psi_addressID);

    psi_portID = (*env)->GetFieldID(env, cls, "port", "I");

    CHECK_NULL(psi_portID);

    psi_localportID = (*env)->GetFieldID(env, cls, "localport", "I");

    CHECK_NULL(psi_localportID);

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

    CHECK_NULL(psi_timeoutID);

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

    CHECK_NULL(psi_trafficClassID);

    psi_serverSocketID = (*env)->GetFieldID(env, cls, "serverSocket",

                        "Ljava/net/ServerSocket;");

    CHECK_NULL(psi_serverSocketID);

    psi_fdLockID = (*env)->GetFieldID(env, cls, "fdLock",

                                      "Ljava/lang/Object;");

    CHECK_NULL(psi_fdLockID);

    psi_closePendingID = (*env)->GetFieldID(env, cls, "closePending", "Z");

    CHECK_NULL(psi_closePendingID);

    IO_fd_fdID = NET_GetFileDescriptorID(env);

    CHECK_NULL(IO_fd_fdID);

    /* Create the marker fd used for dup2 */

    marker_fd = getMarkerFD();

}

/* a global reference to the java.net.SocketException class. In

 * socketCreate, we ensure that this is initialized. This is to

 * prevent the problem where socketCreate runs out of file

 * descriptors, and is then unable to load the exception class.

 */

static jclass socketExceptionCls;

/*

 * Class:     java_net_PlainSocketImpl

 * Method:    socketCreate

 * Signature: (Z)V */

JNIEXPORT void JNICALL

Java_java_net_PlainSocketImpl_socketCreate(JNIEnv *env, jobject this,

                                           jboolean stream) {

    jobject fdObj, ssObj;

    int fd;

    if (socketExceptionCls == NULL) {

        jclass c = (*env)->FindClass(env, "java/net/SocketException");

        CHECK_NULL(c);

        socketExceptionCls = (jclass)(*env)->NewGlobalRef(env, c);

        CHECK_NULL(socketExceptionCls);

    }

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

    if (fdObj == NULL) {

        (*env)->ThrowNew(env, socketExceptionCls, "null fd object");

        return;

    }

#ifdef AF_INET6

    if (ipv6_available()) {

        fd = JVM_Socket(AF_INET6, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);

    } else

#endif /* AF_INET6 */

        {

            fd = JVM_Socket(AF_INET, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);

        }

    if (fd == JVM_IO_ERR) {

        /* note: if you run out of fds, you may not be able to load

         * the exception class, and get a NoClassDefFoundError

         * instead.

         */

        NET_ThrowNew(env, errno, "can't create socket");

        return;

    } else {

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

    }

    /*

     * If this is a server socket then enable SO_REUSEADDR

     * automatically and set to non blocking.

     */

    ssObj = (*env)->GetObjectField(env, this, psi_serverSocketID);

    if (ssObj != NULL) {

        int arg = 1;

        SET_NONBLOCKING(fd);

        JVM_SetSockOpt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&arg,

            sizeof(arg));

    }

}

/*

 * inetAddress is the address object passed to the socket connect

 * call.

 *

 * Class:     java_net_PlainSocketImpl

 * Method:    socketConnect

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

 */

JNIEXPORT void JNICALL

Java_java_net_PlainSocketImpl_socketConnect(JNIEnv *env, jobject this,

                                            jobject iaObj, jint port,

                                            jint timeout)

{

    jint localport = (*env)->GetIntField(env, this, psi_localportID);

    int len = 0;

    /* fdObj is the FileDescriptor field on this */

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

    jobject fdLock;

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

    /* fd is an int field on iaObj */

    jint fd;

    SOCKADDR him;

    /* The result of the connection */

    int connect_rv = -1;

    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, "inet address argument null.");

        return;

    }

    /* connect */

    if (NET_InetAddressToSockaddr(env, iaObj, port, (struct sockaddr *)&him, &len, JNI_TRUE) != 0) {

      return;

    }

#ifdef AF_INET6

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

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

    }

#endif /* AF_INET6 */

    if (timeout <= 0) {

        connect_rv = NET_Connect(fd, (struct sockaddr *)&him, len);

#ifdef __solaris__

        if (connect_rv == JVM_IO_ERR && errno == EINPROGRESS ) {

            /* This can happen if a blocking connect is interrupted by a signal.

             * See 6343810.

             */

            while (1) {

#ifndef USE_SELECT

                {

                    struct pollfd pfd;

                    pfd.fd = fd;

                    pfd.events = POLLOUT;

                    connect_rv = NET_Poll(&pfd, 1, -1);

                }

#else

                {

                    fd_set wr, ex;

                    FD_ZERO(&wr);

                    FD_SET(fd, &wr);

                    FD_ZERO(&ex);

                    FD_SET(fd, &ex);

                    connect_rv = NET_Select(fd+1, 0, &wr, &ex, 0);

                }

#endif

                if (connect_rv == JVM_IO_ERR) {

                    if (errno == EINTR) {

                        continue;

                    } else {

                        break;

                    }

                }

                if (connect_rv > 0) {

                    int optlen;

                    /* has connection been established */

                    optlen = sizeof(connect_rv);

                    if (JVM_GetSockOpt(fd, SOL_SOCKET, SO_ERROR,

                                        (void*)&connect_rv, &optlen) <0) {

                        connect_rv = errno;

                    }

                    if (connect_rv != 0) {

                        /* restore errno */

                        errno = connect_rv;

                        connect_rv = JVM_IO_ERR;

                    }

                    break;

                }

            }

        }

#endif

    } else {

        /*

         * A timeout was specified. We put the socket into non-blocking

         * mode, connect, and then wait for the connection to be

         * established, fail, or timeout.

         */

        SET_NONBLOCKING(fd);

        /* no need to use NET_Connect as non-blocking */

        connect_rv = connect(fd, (struct sockaddr *)&him, len);

        /* connection not established immediately */

        if (connect_rv != 0) {

            int optlen;

            jlong prevTime = JVM_CurrentTimeMillis(env, 0);

            if (errno != EINPROGRESS) {

                NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "ConnectException",

                             "connect failed");

                SET_BLOCKING(fd);

                return;

            }

            /*

             * Wait for the connection to be established or a

             * timeout occurs. poll/select needs to handle EINTR in

             * case lwp sig handler redirects any process signals to

             * this thread.

             */

            while (1) {

                jlong newTime;

#ifndef USE_SELECT

                {

                    struct pollfd pfd;

                    pfd.fd = fd;

                    pfd.events = POLLOUT;

                    errno = 0;

                    connect_rv = NET_Poll(&pfd, 1, timeout);

                }

#else

                {

                    fd_set wr, ex;

                    struct timeval t;

                    t.tv_sec = timeout / 1000;

                    t.tv_usec = (timeout % 1000) * 1000;

                    FD_ZERO(&wr);

                    FD_SET(fd, &wr);

                    FD_ZERO(&ex);

                    FD_SET(fd, &ex);

                    errno = 0;

                    connect_rv = NET_Select(fd+1, 0, &wr, &ex, &t);

                }

#endif

                if (connect_rv >= 0) {

                    break;

                }

                if (errno != EINTR) {

                    break;

                }

                /*

                 * The poll was interrupted so adjust timeout and

                 * restart

                 */

                newTime = JVM_CurrentTimeMillis(env, 0);

                timeout -= (newTime - prevTime);

                if (timeout <= 0) {

                    connect_rv = 0;

                    break;

                }

                prevTime = newTime;

            } /* while */

            if (connect_rv == 0) {

                JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",

                            "connect timed out");

                /*

                 * Timeout out but connection may still be established.

                 * At the high level it should be closed immediately but

                 * just in case we make the socket blocking again and

                 * shutdown input & output.

                 */

                SET_BLOCKING(fd);

                JVM_SocketShutdown(fd, 2);

                return;

            }

            /* has connection been established */

            optlen = sizeof(connect_rv);

            if (JVM_GetSockOpt(fd, SOL_SOCKET, SO_ERROR, (void*)&connect_rv,

                               &optlen) <0) {

                connect_rv = errno;

            }

        }

        /* make socket blocking again */

        SET_BLOCKING(fd);

        /* restore errno */

        if (connect_rv != 0) {

            errno = connect_rv;

            connect_rv = JVM_IO_ERR;

        }

    }

    /* report the appropriate exception */

    if (connect_rv < 0) {

#ifdef __linux__

        /*

         * Linux/GNU distribution setup /etc/hosts so that

         * InetAddress.getLocalHost gets back the loopback address

         * rather than the host address. Thus a socket can be

         * bound to the loopback address and the connect will

         * fail with EADDRNOTAVAIL. In addition the Linux kernel

         * returns the wrong error in this case - it returns EINVAL

         * instead of EADDRNOTAVAIL. We handle this here so that

         * a more descriptive exception text is used.

         */

        if (connect_rv == JVM_IO_ERR && errno == EINVAL) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                "Invalid argument or cannot assign requested address");

            return;

        }

#endif

        if (connect_rv == JVM_IO_INTR) {

            JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",

                            "operation interrupted");

        } else if (errno == EPROTO) {

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "ProtocolException",

                           "Protocol error");

        } else if (errno == ECONNREFUSED) {

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "ConnectException",

                           "Connection refused");

        } else if (errno == ETIMEDOUT) {

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "ConnectException",

                           "Connection timed out");

        } else if (errno == EHOSTUNREACH) {

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "NoRouteToHostException",

                           "Host unreachable");

        } else if (errno == EADDRNOTAVAIL) {

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "NoRouteToHostException",

                             "Address not available");

        } else if ((errno == EISCONN) || (errno == EBADF)) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                            "Socket closed");

        } else {

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

        }

        return;

    }

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

    /* set the remote peer address and port */

    (*env)->SetObjectField(env, this, psi_addressID, iaObj);

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

    /*

     * we need to initialize the local port field if bind was called

     * previously to the connect (by the client) then localport field

     * will already be initialized

     */

    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.

         */

        len = SOCKADDR_LEN;

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

            NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",

                           "Error getting socket name");

        } else {

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

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

        }

    }

}

/*

 * Class:     java_net_PlainSocketImpl

 * Method:    socketBind

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

 */