/*

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

#include <winsock2.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <sys/types.h>

#include "java_net_SocketOptions.h"

#include "java_net_TwoStacksPlainSocketImpl.h"

#include "java_net_SocketImpl.h"

#include "java_net_InetAddress.h"

#include "java_io_FileDescriptor.h"

#include "java_lang_Integer.h"

#include "jvm.h"

#include "net_util.h"

#include "jni_util.h"

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

 * TwoStacksPlainSocketImpl

 */

static jfieldID IO_fd_fdID;

jfieldID psi_fdID;

jfieldID psi_fd1ID;

jfieldID psi_addressID;

jfieldID psi_portID;

jfieldID psi_localportID;

jfieldID psi_timeoutID;

jfieldID psi_trafficClassID;

jfieldID psi_serverSocketID;

jfieldID psi_lastfdID;

/*

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

}

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

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

    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_fd1ID =(*env)->GetFieldID(env, cls , "fd1", "Ljava/io/FileDescriptor;");

    CHECK_NULL(psi_fd1ID);

    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_lastfdID = (*env)->GetFieldID(env, cls, "lastfd", "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) {

    jobject fdObj, fd1Obj;

    int fd, fd1;

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

    }

    if (ipv6_available()) {

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

        if (IS_NULL(fd1Obj)) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                            "null fd1 object");

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

            NET_SocketClose(fd);

            return;

        }

        fd1 = socket(AF_INET6, (stream ? SOCK_STREAM: SOCK_DGRAM), 0);

        if (fd1 == -1) {

            NET_ThrowCurrent(env, "create");

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

            NET_SocketClose(fd);

            return;

        } else {

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

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

            (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);

        }

    } else {

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

    }

}

/*

 * 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 fd, fd1=-1;

    jint len;

    int  ipv6_supported = ipv6_available();

    /* fd initially points to the IPv4 socket and fd1 to the IPv6 socket

     * If we want to connect to IPv6 then we swap the two sockets/objects

     * This way, fd is always the connected socket, and fd1 always gets closed.

     */

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

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

    SOCKETADDRESS him;

    /* The result of the connection */

    int connect_res;

    if (!IS_NULL(fdObj)) {

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

    }

    if (ipv6_supported && !IS_NULL(fd1Obj)) {

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

    }

    if (IS_NULL(iaObj)) {

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

        return;

    }

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

      return;

    }

    family = him.him.sa_family;

    if (family == AF_INET6) {

        if (!ipv6_supported) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                            "Protocol family not supported");

            return;

        } else {

            if (fd1 == -1) {

                JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                                "Destination unreachable");

                return;

            }

            /* close the v4 socket, and set fd to be the v6 socket */

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

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

            NET_SocketClose(fd);

            fd = fd1; fdObj = fd1Obj;

        }

    } else {

        if (fd1 != -1) {

            (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, -1);

            NET_SocketClose(fd1);

        }

        if (fd == -1) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                            "Destination unreachable");

            return;

        }

    }

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

    if (timeout <= 0) {

        connect_res = connect(fd, (struct sockaddr *) &him, SOCKETADDRESS_LEN(&him));

        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, (struct sockaddr *) &him, SOCKETADDRESS_LEN(&him));

        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 = SOCKETADDRESS_LEN(&him);

        if (getsockname(fd, (struct sockaddr *)&him, &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(&him));

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

    /* fdObj is the FileDescriptor field on this */

    jobject fdObj, fd1Obj;

    /* fd is an int field on fdObj */

    int fd, fd1, len;

    int ipv6_supported = ipv6_available();

    /* family is an int field of iaObj */

    int family;

    int rv;

    SOCKETADDRESS him;

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

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

    family = (*env)->GetIntField(env, iaObj, ia_familyID);

    if (family == 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(iaObj)) {

        JNU_ThrowNullPointerException(env, "inet address argument");

        return;

    }

    if (NET_InetAddressToSockaddr(env, iaObj, localport,

                          (struct sockaddr *)&him, &len, JNI_FALSE) != 0) {

      return;

    }

    if (ipv6_supported) {

        struct ipv6bind v6bind;

        v6bind.addr = &him;

        v6bind.ipv4_fd = fd;

        v6bind.ipv6_fd = fd1;

        rv = NET_BindV6(&v6bind);

        if (rv != -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, psi_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, psi_fd1ID, NULL);

                } else {

                    /* socket was re-created */

                    (*env)->SetIntField(env, fd1Obj, IO_fd_fdID, fd1);

                }

            }

        }

    } else {

        rv = NET_Bind(fd, (struct sockaddr *)&him, len);

    }

    if (rv == -1) {

        NET_ThrowCurrent(env, "JVM_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 = SOCKETADDRESS_LEN(&him);

        u_short port;

        fd = him.him.sa_family == AF_INET? fd: fd1;

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

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

            return;

        }

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

        (*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 fd1Obj = (*env)->GetObjectField(env, this, psi_fd1ID);

    jobject address;

    /* fdObj's int fd field */

    int fd, fd1;

    SOCKETADDRESS addr; int addrlen;

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

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",

                        "socket closed");

        return;

    }

    if (!IS_NULL(fdObj)) {