/*

 * Copyright 2001-2007 Sun Microsystems, Inc.  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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <string.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include "jni.h"

#include "jni_util.h"

#include "jvm.h"

#include "jlong.h"

#include "sun_nio_ch_Net.h"

#include "net_util.h"

#include "net_util_md.h"

#include "nio_util.h"

#include "java_net_SocketOptions.h"

#include "nio.h"

#ifdef __linux__

#include <sys/utsname.h>

#define IPV6_MULTICAST_IF 17

#ifndef SO_BSDCOMPAT

#define SO_BSDCOMPAT  14

#endif

#endif

JNIEXPORT void JNICALL

Java_sun_nio_ch_Net_initIDs(JNIEnv *env, jclass clazz)

{

    /* Here because Windows native code does need to init IDs */

}

JNIEXPORT int JNICALL

Java_sun_nio_ch_Net_socket0(JNIEnv *env, jclass cl, jboolean stream,

                            jboolean reuse)

{

    int fd;

#ifdef AF_INET6

    if (ipv6_available())

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

    else

#endif /* AF_INET6 */

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

    if (fd < 0) {

        return handleSocketError(env, errno);

    }

    if (reuse) {

        int arg = 1;

        if (NET_SetSockOpt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&arg,

                           sizeof(arg)) < 0) {

            JNU_ThrowByNameWithLastError(env,

                                         JNU_JAVANETPKG "SocketException",

                                         "sun.nio.ch.Net.setIntOption");

        }

    }

    return fd;

}

JNIEXPORT void JNICALL

Java_sun_nio_ch_Net_bind(JNIEnv *env, jclass clazz, /* ## Needs rest of PSI gunk */

                         jobject fdo, jobject ia, int port)

{

    SOCKADDR sa;

    int sa_len = SOCKADDR_LEN;

    int rv = 0;

    if (NET_InetAddressToSockaddr(env, ia, port, (struct sockaddr *)&sa, &sa_len, JNI_TRUE) != 0) {

      return;

    }

    rv = NET_Bind(fdval(env, fdo), (struct sockaddr *)&sa, sa_len);

    if (rv != 0) {

        handleSocketError(env, errno);

    }

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_Net_connect(JNIEnv *env, jclass clazz,

                                jobject fdo, jobject iao, jint port,

                                jint trafficClass)

{

    SOCKADDR sa;

    int sa_len = SOCKADDR_LEN;

    int rv;

    if (NET_InetAddressToSockaddr(env, iao, port, (struct sockaddr *) &sa, &sa_len, JNI_TRUE) != 0) {

      return IOS_THROWN;

    }

#ifdef AF_INET6

#if 0

    if (trafficClass != 0 && ipv6_available()) { /* ## FIX */

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

    }

#endif

#endif

    rv = connect(fdval(env, fdo), (struct sockaddr *)&sa, sa_len);

    if (rv != 0) {

        if (errno == EINPROGRESS) {

            return IOS_UNAVAILABLE;

        } else if (errno == EINTR) {

            return IOS_INTERRUPTED;

        }

        return handleSocketError(env, errno);

    }

    return 1;

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_Net_localPort(JNIEnv *env, jclass clazz, jobject fdo)

{

    SOCKADDR sa;

    int sa_len = SOCKADDR_LEN;

    if (getsockname(fdval(env, fdo), (struct sockaddr *)&sa, &sa_len) < 0) {

        handleSocketError(env, errno);

        return -1;

    }

    return NET_GetPortFromSockaddr((struct sockaddr *)&sa);

}

JNIEXPORT jobject JNICALL

Java_sun_nio_ch_Net_localInetAddress(JNIEnv *env, jclass clazz, jobject fdo)

{

    SOCKADDR sa;

    int sa_len = SOCKADDR_LEN;

    int port;

    if (getsockname(fdval(env, fdo), (struct sockaddr *)&sa, &sa_len) < 0) {

        handleSocketError(env, errno);

        return NULL;

    }

    return NET_SockaddrToInetAddress(env, (struct sockaddr *)&sa, &port);

}

#ifdef NEEDED

/* ## This is gross.  We should generate platform-specific constant

 * ## definitions into a .java file and use those directly.

 */

static int

mapOption(JNIEnv *env, int opt, int *klevel, int *kopt)

{

    switch (opt) {

    case java_net_SocketOptions_IP_TOS:

        *klevel = IPPROTO_IP;

        *kopt = IP_TOS;

        break;

    case java_net_SocketOptions_SO_BROADCAST:

    case java_net_SocketOptions_SO_KEEPALIVE:

    case java_net_SocketOptions_SO_LINGER:

    case java_net_SocketOptions_SO_OOBINLINE:

    case java_net_SocketOptions_SO_RCVBUF:

    case java_net_SocketOptions_SO_REUSEADDR:

    case java_net_SocketOptions_SO_SNDBUF:

        *klevel = SOL_SOCKET;

        break;

    case java_net_SocketOptions_TCP_NODELAY:

        *klevel = IPPROTO_IP;

        *kopt = TCP_NODELAY;

        return 0;

    default:

        JNU_ThrowByName(env, "java/lang/IllegalArgumentException", NULL);

        return -1;

    }

    switch (opt) {

    case java_net_SocketOptions_SO_BROADCAST:   *kopt = SO_BROADCAST;  break;

    case java_net_SocketOptions_SO_KEEPALIVE:   *kopt = SO_KEEPALIVE;  break;

    case java_net_SocketOptions_SO_LINGER:      *kopt = SO_LINGER;  break;

    case java_net_SocketOptions_SO_OOBINLINE:   *kopt = SO_OOBINLINE;  break;

    case java_net_SocketOptions_SO_RCVBUF:      *kopt = SO_RCVBUF;  break;

    case java_net_SocketOptions_SO_REUSEADDR:   *kopt = SO_REUSEADDR;  break;

    case java_net_SocketOptions_SO_SNDBUF:      *kopt = SO_SNDBUF;  break;

    default:

        return -1;

    }

    return 0;

}

#endif

JNIEXPORT jint JNICALL

Java_sun_nio_ch_Net_getIntOption0(JNIEnv *env, jclass clazz,

                                  jobject fdo, jint opt)

{

    int klevel, kopt;

    int result;

    struct linger linger;

    void *arg;

    int arglen;

    if (NET_MapSocketOption(opt, &klevel, &kopt) < 0) {

        JNU_ThrowByNameWithLastError(env,

                                     JNU_JAVANETPKG "SocketException",

                                     "Unsupported socket option");

        return -1;

    }

    if (opt == java_net_SocketOptions_SO_LINGER) {

        arg = (void *)&linger;

        arglen = sizeof(linger);

    } else {

        arg = (void *)&result;

        arglen = sizeof(result);

    }

    if (NET_GetSockOpt(fdval(env, fdo), klevel, kopt, arg, &arglen) < 0) {

        JNU_ThrowByNameWithLastError(env,

                                     JNU_JAVANETPKG "SocketException",

                                     "sun.nio.ch.Net.getIntOption");

        return -1;

    }

    if (opt == java_net_SocketOptions_SO_LINGER)

        return linger.l_onoff ? linger.l_linger : -1;

    else

        return result;

}

JNIEXPORT void JNICALL

Java_sun_nio_ch_Net_setIntOption0(JNIEnv *env, jclass clazz,

                                  jobject fdo, jint opt, jint arg)

{

    int klevel, kopt;

    int result;

    struct linger linger;

    void *parg;

    int arglen;

    if (NET_MapSocketOption(opt, &klevel, &kopt) < 0) {

        JNU_ThrowByNameWithLastError(env,

                                     JNU_JAVANETPKG "SocketException",

                                     "Unsupported socket option");

        return;

    }

    if (opt == java_net_SocketOptions_SO_LINGER) {

        parg = (void *)&linger;

        arglen = sizeof(linger);

        if (arg >= 0) {

            linger.l_onoff = 1;

            linger.l_linger = arg;

        } else {

            linger.l_onoff = 0;

            linger.l_linger = 0;

        }

    } else {

        parg = (void *)&arg;

        arglen = sizeof(arg);

    }

    if (NET_SetSockOpt(fdval(env, fdo), klevel, kopt, parg, arglen) < 0) {

        JNU_ThrowByNameWithLastError(env,

                                     JNU_JAVANETPKG "SocketException",

                                     "sun.nio.ch.Net.setIntOption");

    }

}

/* Declared in nio_util.h */

jint

handleSocketError(JNIEnv *env, jint errorValue)

{

    char *xn;

    switch (errorValue) {

        case EINPROGRESS:       /* Non-blocking connect */

            return 0;

        case EPROTO:

            xn = JNU_JAVANETPKG "ProtocolException";

            break;

        case ECONNREFUSED:

            xn = JNU_JAVANETPKG "ConnectException";

            break;

        case ETIMEDOUT:

            xn = JNU_JAVANETPKG "ConnectException";

            break;

        case EHOSTUNREACH:

            xn = JNU_JAVANETPKG "NoRouteToHostException";

            break;

        case EADDRINUSE:  /* Fall through */

        case EADDRNOTAVAIL:

            xn = JNU_JAVANETPKG "BindException";

            break;

        default:

            xn = JNU_JAVANETPKG "SocketException";

            break;

    }

    errno = errorValue;

    JNU_ThrowByNameWithLastError(env, xn, "NioSocketError");

    return IOS_THROWN;

}