/*

 * 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 "java_net_TwoStacksPlainSocketImpl.h"

#include "java_net_SocketOptions.h"

#include "java_net_InetAddress.h"

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

 * TwoStacksPlainSocketImpl

 */

static jfieldID IO_fd_fdID;

jfieldID psi_fdID;

jfieldID psi_addressID;

jfieldID psi_portID;

jfieldID psi_localportID;

jfieldID psi_timeoutID;

jfieldID psi_trafficClassID;

jfieldID psi_serverSocketID;

/*

 * the level of the TCP protocol for setsockopt and getsockopt

 * we only want to look this up once, from the static initializer

 * of TwoStacksPlainSocketImpl

 */

static int tcp_level = -1;

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

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

    if (fdObj == NULL) {

        return -1;

    }

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

}

/*

 * The initProto function is called whenever TwoStacksPlainSocketImpl is

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

 * the Java class is loaded.

 *

 * Class:     java_net_TwoStacksPlainSocketImpl

 * Method:    initProto

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainSocketImpl_initProto(JNIEnv *env, jclass cls) {

    struct protoent *proto = getprotobyname("TCP");

    tcp_level = (proto == 0 ? IPPROTO_TCP: proto->p_proto);

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

    IO_fd_fdID = NET_GetFileDescriptorID(env);

    CHECK_NULL(IO_fd_fdID);

}

/*

 * Class:     java_net_TwoStacksPlainSocketImpl

 * Method:    socketCreate

 * Signature: (Z)V

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainSocketImpl_socketCreate(JNIEnv *env, jobject this,

                                           jboolean stream) {

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

    if (IS_NULL(fdObj)) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "null fd object");

        return;

    }

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

    if (fd == -1) {

        NET_ThrowCurrent(env, "create");

        return;

    } else {

        /* Set socket attribute so it is not passed to any child process */

        SetHandleInformation((HANDLE)(UINT_PTR)fd, HANDLE_FLAG_INHERIT, FALSE);

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

    }

}

/*

 * inetAddress is the address object passed to the socket connect

 * call.

 *

 * Class:     java_net_TwoStacksPlainSocketImpl

 * Method:    socketConnect

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

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainSocketImpl_socketConnect(JNIEnv *env, jobject this,

                                                     jobject iaObj, jint port,

                                                     jint timeout)

{

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

    /* family and localport are int fields of iaObj */

    int family;

    jint len;

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

    SOCKETADDRESS sa;

    /* The result of the connection */

    int connect_res;

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

    if (!IS_NULL(fdObj)) {

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

    }

    if (IS_NULL(iaObj)) {

        JNU_ThrowNullPointerException(env, "inet address argument is null.");

        return;

    }

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

                                  JNI_FALSE) != 0) {

        return;

    }

    family = sa.sa.sa_family;

    }

    if (timeout <= 0) {

        connect_res = connect(fd, &sa.sa, sizeof(SOCKETADDRESS));

        if (connect_res == SOCKET_ERROR) {

            connect_res = WSAGetLastError();

        }

    } else {

        int optval;

        int optlen = sizeof(optval);

        /* make socket non-blocking */

        optval = 1;

        ioctlsocket(fd, FIONBIO, &optval);

        /* initiate the connect */

        connect_res = connect(fd, &sa.sa, sizeof(SOCKETADDRESS));

        if (connect_res == SOCKET_ERROR) {

            if (WSAGetLastError() != WSAEWOULDBLOCK) {

                connect_res = WSAGetLastError();

            } else {

                fd_set wr, ex;

                struct timeval t;

                FD_ZERO(&wr);

                FD_ZERO(&ex);

                FD_SET(fd, &wr);

                FD_SET(fd, &ex);

                t.tv_sec = timeout / 1000;

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

                /*

                 * Wait for timout, connection established or

                 * connection failed.

                 */

                connect_res = select(fd+1, 0, &wr, &ex, &t);

                /*

                 * Timeout before connection is established/failed so

                 * we throw exception and shutdown input/output to prevent

                 * socket from being used.

                 * The socket should be closed immediately by the caller.

                 */

                if (connect_res == 0) {

                    JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",

                                    "connect timed out");

                    shutdown( fd, SD_BOTH );

                     /* make socket blocking again - just in case */

                    optval = 0;

                    ioctlsocket( fd, FIONBIO, &optval );

                    return;

                }

                /*

                 * We must now determine if the connection has been established

                 * or if it has failed. The logic here is designed to work around

                 * bug on Windows NT whereby using getsockopt to obtain the

                 * last error (SO_ERROR) indicates there is no error. The workaround

                 * on NT is to allow winsock to be scheduled and this is done by

                 * yielding and retrying. As yielding is problematic in heavy

                 * load conditions we attempt up to 3 times to get the error reason.

                 */

                if (!FD_ISSET(fd, &ex)) {

                    connect_res = 0;

                } else {

                    int retry;

                    for (retry=0; retry<3; retry++) {

                        NET_GetSockOpt(fd, SOL_SOCKET, SO_ERROR,

                                       (char*)&connect_res, &optlen);

                        if (connect_res) {

                            break;

                        }

                        Sleep(0);

                    }

                    if (connect_res == 0) {

                        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                                        "Unable to establish connection");

                        return;

                    }

                }

            }

        }

        /* make socket blocking again */

        optval = 0;

        ioctlsocket(fd, FIONBIO, &optval);

    }

    if (connect_res) {

        if (connect_res == WSAEADDRNOTAVAIL) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "ConnectException",

                "connect: Address is invalid on local machine, or port is not valid on remote machine");

        } else {

            NET_ThrowNew(env, connect_res, "connect");

        }

        return;

    }

    (*env)->SetIntField(env, fdObj, IO_fd_fdID, (int)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.

         */

        u_short port;

        int len = sizeof(SOCKETADDRESS);

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

            if (WSAGetLastError() == WSAENOTSOCK) {

                JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                                "Socket closed");

            } else {

                NET_ThrowCurrent(env, "getsockname failed");

            }

            return;

        }

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

        (*env)->SetIntField(env, this, psi_localportID, (int) port);

    }

}

/*

 * Class:     java_net_TwoStacksPlainSocketImpl

 * Method:    socketBind

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

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainSocketImpl_socketBind(JNIEnv *env, jobject this,

                                         jobject iaObj, jint localport,

                                         jboolean exclBind) {

    /* fdObj is the FileDescriptor field on this */

    /* fd is an int field on fdObj */

    /* family is an int field of iaObj */

    int family;

    int rv;

    SOCKETADDRESS sa;

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

    family = getInetAddress_family(env, iaObj);

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Protocol family not supported");

        return;

    }

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

        return;

    }

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

                                  JNI_FALSE) != 0) {

        return;

    }

    if (rv == -1) {

        NET_ThrowCurrent(env, "NET_Bind");

        return;

    }

    /* set the address */

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

    /* intialize the local port */

    if (localport == 0) {

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

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

         */

        int len = sizeof(SOCKETADDRESS);

        u_short port;

            NET_ThrowCurrent(env, "getsockname in plain socketBind");

            return;

        }

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

        (*env)->SetIntField(env, this, psi_localportID, (int)port);

    } else {

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

    }

}

/*

 * Class:     java_net_TwoStacksPlainSocketImpl

 * Method:    socketListen

 * Signature: (I)V

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainSocketImpl_socketListen

  (JNIEnv *env, jobject this, jint count)

{

    /* this FileDescriptor fd field */

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

    jobject address;

    /* fdObj's int fd field */

    SOCKETADDRESS addr;

    int addrlen;

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "socket closed");

        return;

    }

    if (!IS_NULL(fdObj)) {

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

    }

    address = (*env)->GetObjectField(env, this, psi_addressID);

    if (IS_NULL(address)) {

        JNU_ThrowNullPointerException(env, "socket address");

        return;

    }

    if (NET_InetAddressToSockaddr(env, address, 0, &addr, &addrlen,

                                  JNI_FALSE) != 0) {

        return;

    }

        /* listen on v4 */

        if (listen(fd, count) == -1) {

            NET_ThrowCurrent(env, "listen failed");

        }

    } else {

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

    }

}

/*

 * Class:     java_net_TwoStacksPlainSocketImpl

 * Method:    socketAccept

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

 */

JNIEXPORT void JNICALL

Java_java_net_TwoStacksPlainSocketImpl_socketAccept(JNIEnv *env, jobject this,

                                           jobject socket)

{

    /* fields on this */

    jint port;

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

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

    /* the FileDescriptor field on socket */

    jobject socketFdObj;

    static jclass inet4Cls;

    /* the InetAddress field on socket */

    jobject socketAddressObj;

    /* the fd int field on fdObj */

    SOCKETADDRESS sa;

    jint len;

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "Socket closed");

        return;

    }

    if (IS_NULL(socket)) {

        JNU_ThrowNullPointerException(env, "socket is null");

        return;

    } else {

        socketFdObj = (*env)->GetObjectField(env, socket, psi_fdID);

        socketAddressObj = (*env)->GetObjectField(env, socket, psi_addressID);

    }

    if ((IS_NULL(socketAddressObj)) || (IS_NULL(socketFdObj))) {

        JNU_ThrowNullPointerException(env, "socket address or fd obj");

        return;

    }

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",

                            "Accept timed out");

            return;

            return;

        }

    }

    fd = accept(fd, &sa.sa, &len);

    if (fd < 0) {

        /* REMIND: SOCKET CLOSED PROBLEM */

        if (fd == -2) {

            JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",

                            "operation interrupted");

        } else {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                            "socket closed");

        }

        return;

    }

    SetHandleInformation((HANDLE)(UINT_PTR)fd, HANDLE_FLAG_INHERIT, 0);