/*

 * Copyright (c) 2009, 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 <stdlib.h>

#include <string.h>

#include <dlfcn.h>

#include "Sctp.h"

#include "jni.h"

#include "jni_util.h"

#include "nio_util.h"

#include "nio.h"

#include "net_util.h"

#include "net_util_md.h"

#include "sun_nio_ch_SctpNet.h"

#include "sun_nio_ch_SctpStdSocketOption.h"

static jclass isaCls = 0;

static jmethodID isaCtrID = 0;

static const char* nativeSctpLib = "libsctp.so.1";

static jboolean funcsLoaded = JNI_FALSE;

JNIEXPORT jint JNICALL JNI_OnLoad

  (JavaVM *vm, void *reserved) {

    return JNI_VERSION_1_2;

}

static int preCloseFD = -1;     /* File descriptor to which we dup other fd's

                                   before closing them for real */

/**

 * Loads the native sctp library that contains the socket extension

 * functions, as well as locating the individual functions.

 * There will be a pending exception if this method returns false.

 */

jboolean loadSocketExtensionFuncs

  (JNIEnv* env) {

    if (dlopen(nativeSctpLib, RTLD_GLOBAL | RTLD_LAZY) == NULL) {

        JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

              dlerror());

        return JNI_FALSE;

    }

    if ((nio_sctp_getladdrs = (sctp_getladdrs_func*)

            dlsym(RTLD_DEFAULT, "sctp_getladdrs")) == NULL) {

        JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

              dlerror());

        return JNI_FALSE;

    }

    if ((nio_sctp_freeladdrs = (sctp_freeladdrs_func*)

            dlsym(RTLD_DEFAULT, "sctp_freeladdrs")) == NULL) {

        JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

              dlerror());

        return JNI_FALSE;

    }

    if ((nio_sctp_getpaddrs = (sctp_getpaddrs_func*)

            dlsym(RTLD_DEFAULT, "sctp_getpaddrs")) == NULL) {

        JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

              dlerror());

        return JNI_FALSE;

    }

    if ((nio_sctp_freepaddrs = (sctp_freepaddrs_func*)

            dlsym(RTLD_DEFAULT, "sctp_freepaddrs")) == NULL) {

        JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

              dlerror());

        return JNI_FALSE;

    }

    if ((nio_sctp_bindx = (sctp_bindx_func*)

            dlsym(RTLD_DEFAULT, "sctp_bindx")) == NULL) {

        JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

              dlerror());

        return JNI_FALSE;

    }

    if ((nio_sctp_peeloff = (sctp_peeloff_func*)

            dlsym(RTLD_DEFAULT, "sctp_peeloff")) == NULL) {

        JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

              dlerror());

        return JNI_FALSE;

    }

    funcsLoaded = JNI_TRUE;

    return JNI_TRUE;

}

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;

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    init

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_sun_nio_ch_SctpNet_init

  (JNIEnv *env, jclass cl) {

    int sp[2];

    if (socketpair(PF_UNIX, SOCK_STREAM, 0, sp) < 0) {

        JNU_ThrowIOExceptionWithLastError(env, "socketpair failed");

        return;

    }

    preCloseFD = sp[0];

    close(sp[1]);

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    socket0

 * Signature: (Z)I

 */

JNIEXPORT jint JNICALL Java_sun_nio_ch_SctpNet_socket0

  (JNIEnv *env, jclass klass, jboolean oneToOne) {

    int fd;

    struct sctp_event_subscribe event;

#ifdef AF_INET6

    int domain = ipv6_available() ? AF_INET6 : AF_INET;

#else

    int domain = AF_INET;

#endif

    /* Try to load the socket API extension functions */

    if (!funcsLoaded && !loadSocketExtensionFuncs(env)) {

        return 0;

    }

    fd = socket(domain, (oneToOne ? SOCK_STREAM : SOCK_SEQPACKET), IPPROTO_SCTP);

    if (fd < 0) {

        return handleSocketError(env, errno);

    }

    /* Enable events */

    memset(&event, 0, sizeof(event));

    event.sctp_data_io_event = 1;

    event.sctp_association_event = 1;

    event.sctp_address_event = 1;

    event.sctp_send_failure_event = 1;

    //event.sctp_peer_error_event = 1;

    event.sctp_shutdown_event = 1;

    //event.sctp_partial_delivery_event = 1;

    //event.sctp_adaptation_layer_event = 1;

    if (setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(event)) != 0) {

       handleSocketError(env, errno);

    }

    return fd;

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    bindx

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

 */

JNIEXPORT void JNICALL Java_sun_nio_ch_SctpNet_bindx

  (JNIEnv *env, jclass klass, jint fd, jobjectArray addrs, jint port,

   jint addrsLength, jboolean add, jboolean preferIPv6) {

    SOCKADDR *sap, *tmpSap;

    int i, sa_len = sizeof(SOCKADDR);

    jobject ia;

    if (addrsLength < 1)

        return;

    if ((sap = calloc(addrsLength,  sa_len)) == NULL) {

          JNU_ThrowOutOfMemoryError(env, "heap allocation failure");

        return;

    }

    tmpSap = sap;

    for (i=0; i<addrsLength; i++) {

        ia = (*env)->GetObjectArrayElement(env, addrs, i);

        if (NET_InetAddressToSockaddr(env, ia, port, (struct sockaddr*)tmpSap,

                                      &sa_len, preferIPv6) != 0) {

            free(sap);

            return;

        }

        tmpSap++;

    }

    if (nio_sctp_bindx(fd, (void*)sap, addrsLength, add ? SCTP_BINDX_ADD_ADDR :

                       SCTP_BINDX_REM_ADDR) != 0) {

        handleSocketError(env, errno);

    }

    free(sap);

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    listen0

 * Signature: (II)V

 */

JNIEXPORT void JNICALL

Java_sun_nio_ch_SctpNet_listen0

  (JNIEnv *env, jclass cl, jint fd, jint backlog) {

    if (listen(fd, backlog) < 0)

        handleSocketError(env, errno);

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    connect0

 * Signature: (ILjava/net/InetAddress;I)I

 */

JNIEXPORT jint JNICALL

Java_sun_nio_ch_SctpNet_connect0

  (JNIEnv *env, jclass clazz, int fd, jobject iao, jint port) {

    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;

    }

    rv = connect(fd, (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;

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    close0

 * Signature: (I)V

 */

JNIEXPORT void JNICALL

Java_sun_nio_ch_SctpNet_close0

  (JNIEnv *env, jclass clazz, jint fd) {

    if (fd != -1) {

        int rv = close(fd);

        if (rv < 0)

            JNU_ThrowIOExceptionWithLastError(env, "Close failed");

    }

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    preClose0

 * Signature: (I)V

 */

JNIEXPORT void JNICALL

Java_sun_nio_ch_SctpNet_preClose0

  (JNIEnv *env, jclass clazz, jint fd) {

    if (preCloseFD >= 0) {

        if (dup2(preCloseFD, fd) < 0)

            JNU_ThrowIOExceptionWithLastError(env, "dup2 failed");

    }

}

void initializeISA

  (JNIEnv* env) {

    if (isaCls == 0) {

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

        CHECK_NULL(c);

        isaCls = (*env)->NewGlobalRef(env, c);

        CHECK_NULL(isaCls);

        (*env)->DeleteLocalRef(env, c);

        isaCtrID = (*env)->GetMethodID(env, isaCls, "<init>",

                                     "(Ljava/net/InetAddress;I)V");

    }

}

jobject SockAddrToInetSocketAddress

  (JNIEnv *env, struct sockaddr* sap) {

    int port = 0;

    jobject ia = NET_SockaddrToInetAddress(env, sap, &port);

    if (ia == NULL)

        return NULL;

    if (isaCls == 0) {

        initializeISA(env);

        CHECK_NULL_RETURN(isaCls, NULL);

    }

    return (*env)->NewObject(env, isaCls, isaCtrID, ia, port);

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    getLocalAddresses0

 * Signature: (I)[Ljava/net/SocketAddress;

 */

JNIEXPORT jobjectArray JNICALL Java_sun_nio_ch_SctpNet_getLocalAddresses0

  (JNIEnv *env, jclass klass, jint fd) {

    void *addr_buf, *laddr;

    struct sockaddr* sap;

    int i, addrCount;

    jobjectArray isaa;

#ifdef __solaris__

    if ((addrCount = nio_sctp_getladdrs(fd, 0, (void **)&addr_buf)) == -1) {

#else /* __linux__ */

    if ((addrCount = nio_sctp_getladdrs(fd, 0, (struct sockaddr **)&addr_buf)) == -1) {

#endif

        handleSocketError(env, errno);

        return NULL;

    }

    if (addrCount < 1)

        return NULL;

    if (isaCls == 0) {

        initializeISA(env);

        CHECK_NULL_RETURN(isaCls, NULL);

    }

    isaa = (*env)->NewObjectArray(env, addrCount, isaCls, NULL);

    if (isaa == NULL) {

        nio_sctp_freeladdrs(addr_buf);

        return NULL;

    }

    laddr = addr_buf;

    for (i=0; i<addrCount; i++) {

        int port = 0;

        jobject isa = NULL, ia;

        sap = (struct sockaddr*)addr_buf;

        ia = NET_SockaddrToInetAddress(env, sap, &port);

        if (ia != NULL)

            isa = (*env)->NewObject(env, isaCls, isaCtrID, ia, port);

        if (isa != NULL)

            (*env)->SetObjectArrayElement(env, isaa, i, isa);

        if (sap->sa_family == AF_INET)

            addr_buf = ((struct sockaddr_in*)addr_buf) + 1;

        else

            addr_buf = ((struct sockaddr_in6*)addr_buf) + 1;

    }

    nio_sctp_freeladdrs(laddr);

    return isaa;

}

jobjectArray getRemoteAddresses

  (JNIEnv *env, jint fd, sctp_assoc_t id) {

    void *addr_buf, *paddr;

    struct sockaddr* sap;

    int i, addrCount;

    jobjectArray isaa;

#if __solaris__

    if ((addrCount = nio_sctp_getpaddrs(fd, id, (void **)&addr_buf)) == -1) {

#else /* __linux__ */

    if ((addrCount = nio_sctp_getpaddrs(fd, id, (struct sockaddr**)&addr_buf)) == -1) {

#endif

        handleSocketError(env, errno);

        return NULL;

    }

    if (addrCount < 1)

        return NULL;

    if (isaCls == 0) {

        initializeISA(env);

        CHECK_NULL_RETURN(isaCls, NULL);

    }

    isaa = (*env)->NewObjectArray(env, addrCount, isaCls, NULL);

    if (isaa == NULL) {

        nio_sctp_freepaddrs(addr_buf);

        return NULL;

    }

    paddr = addr_buf;

    for (i=0; i<addrCount; i++) {

        jobject ia, isa = NULL;

        int port;

        sap = (struct sockaddr*)addr_buf;

        ia = NET_SockaddrToInetAddress(env, sap, &port);

        if (ia != NULL)

            isa = (*env)->NewObject(env, isaCls, isaCtrID, ia, port);

        if (isa != NULL)

            (*env)->SetObjectArrayElement(env, isaa, i, isa);

        if (sap->sa_family == AF_INET)

            addr_buf = ((struct sockaddr_in*)addr_buf) + 1;

        else

            addr_buf = ((struct sockaddr_in6*)addr_buf) + 1;

    }

    nio_sctp_freepaddrs(paddr);

    return isaa;

}

 /*

 * Class:     sun_nio_ch_SctpNet

 * Method:    getRemoteAddresses0

 * Signature: (II)[Ljava/net/SocketAddress;

 */

JNIEXPORT jobjectArray JNICALL Java_sun_nio_ch_SctpNet_getRemoteAddresses0

  (JNIEnv *env, jclass klass, jint fd, jint assocId) {

    return getRemoteAddresses(env, fd, assocId);

}

/* Map the Java level option to the native level */

int mapSocketOption

  (jint cmd, int *level, int *optname) {

    static struct {

        jint cmd;

        int level;

        int optname;

    } const opts[] = {

        { sun_nio_ch_SctpStdSocketOption_SCTP_DISABLE_FRAGMENTS,   IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS },

        { sun_nio_ch_SctpStdSocketOption_SCTP_EXPLICIT_COMPLETE,   IPPROTO_SCTP, SCTP_EXPLICIT_EOR },

        { sun_nio_ch_SctpStdSocketOption_SCTP_FRAGMENT_INTERLEAVE, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE },

        { sun_nio_ch_SctpStdSocketOption_SCTP_NODELAY,             IPPROTO_SCTP, SCTP_NODELAY },

        { sun_nio_ch_SctpStdSocketOption_SO_SNDBUF,                SOL_SOCKET,   SO_SNDBUF },

        { sun_nio_ch_SctpStdSocketOption_SO_RCVBUF,                SOL_SOCKET,   SO_RCVBUF },

        { sun_nio_ch_SctpStdSocketOption_SO_LINGER,                SOL_SOCKET,   SO_LINGER } };

    int i;

    for (i=0; i<(int)(sizeof(opts) / sizeof(opts[0])); i++) {

        if (cmd == opts[i].cmd) {

            *level = opts[i].level;

            *optname = opts[i].optname;

            return 0;

        }

    }

    /* not found */

    return -1;

}

/*

 * Class:     sun_nio_ch_SctpNet

 * Method:    setIntOption0

 * Signature: (III)V

 */

JNIEXPORT void JNICALL Java_sun_nio_ch_SctpNet_setIntOption0

  (JNIEnv *env, jclass klass, jint fd, jint opt, int arg) {

    int klevel, kopt;

    int result;

    struct linger linger;

    void *parg;

    int arglen;

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

        JNU_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",

                                     "Unsupported socket option");

        return;

    }

    if (opt == sun_nio_ch_SctpStdSocketOption_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 {