/*

 * Copyright (c) 1997, 2016, 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 <dlfcn.h>

#include <errno.h>

#include <net/if.h>

#include <netinet/tcp.h> // defines TCP_NODELAY

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>

#include <sys/time.h>

#if defined(__linux__)

#include <arpa/inet.h>

#include <net/route.h>

#include <sys/utsname.h>

#endif

#if defined(__solaris__)

#include <inet/nd.h>

#include <limits.h>

#include <stropts.h>

#include <sys/filio.h>

#include <sys/sockio.h>

#endif

#include "net_util.h"

#include "java_net_SocketOptions.h"

#include "java_net_InetAddress.h"

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

#define IPV6_FLOWINFO_SEND      33

#endif

#if defined(__solaris__) && !defined(MAXINT)

#define MAXINT INT_MAX

#endif

/*

 * EXCLBIND socket options only on Solaris

 */

#if defined(__solaris__) && !defined(TCP_EXCLBIND)

#define TCP_EXCLBIND            0x21

#endif

#if defined(__solaris__) && !defined(UDP_EXCLBIND)

#define UDP_EXCLBIND            0x0101

#endif

void setDefaultScopeID(JNIEnv *env, struct sockaddr *him)

{

#ifdef MACOSX

    static jclass ni_class = NULL;

    static jfieldID ni_defaultIndexID;

    if (ni_class == NULL) {

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

        CHECK_NULL(c);

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

        CHECK_NULL(c);

        ni_defaultIndexID = (*env)->GetStaticFieldID(env, c, "defaultIndex", "I");

        CHECK_NULL(ni_defaultIndexID);

        ni_class = c;

    }

    int defaultIndex;

    struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)him;

    if (sin6->sin6_family == AF_INET6 && (sin6->sin6_scope_id == 0)) {

        defaultIndex = (*env)->GetStaticIntField(env, ni_class,

                                                 ni_defaultIndexID);

        sin6->sin6_scope_id = defaultIndex;

    }

#endif

}

int getDefaultScopeID(JNIEnv *env) {

    int defaultIndex = 0;

    static jclass ni_class = NULL;

    static jfieldID ni_defaultIndexID;

    if (ni_class == NULL) {

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

        CHECK_NULL_RETURN(c, 0);

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

        CHECK_NULL_RETURN(c, 0);

        ni_defaultIndexID = (*env)->GetStaticFieldID(env, c, "defaultIndex", "I");

        CHECK_NULL_RETURN(ni_defaultIndexID, 0);

        ni_class = c;

    }

    defaultIndex = (*env)->GetStaticIntField(env, ni_class,

                                             ni_defaultIndexID);

    return defaultIndex;

}

#define RESTARTABLE(_cmd, _result) do { \

    do { \

        _result = _cmd; \

    } while((_result == -1) && (errno == EINTR)); \

} while(0)

int NET_SocketAvailable(int s, jint *pbytes) {

    int result;

    RESTARTABLE(ioctl(s, FIONREAD, pbytes), result);

    // note: ioctl can return 0 when successful, NET_SocketAvailable

    // is expected to return 0 on failure and 1 on success.

    return (result == -1) ? 0 : 1;

}

#ifdef __solaris__

static int init_tcp_max_buf, init_udp_max_buf;

static int tcp_max_buf;

static int udp_max_buf;

static int useExclBind = 0;

/*

 * Get the specified parameter from the specified driver. The value

 * of the parameter is assumed to be an 'int'. If the parameter

 * cannot be obtained return -1

 */

int net_getParam(char *driver, char *param)

{

    struct strioctl stri;

    char buf [64];

    int s;

    int value;

    s = open (driver, O_RDWR);

    if (s < 0) {

        return -1;

    }

    strncpy (buf, param, sizeof(buf));

    stri.ic_cmd = ND_GET;

    stri.ic_timout = 0;

    stri.ic_dp = buf;

    stri.ic_len = sizeof(buf);

    if (ioctl (s, I_STR, &stri) < 0) {

        value = -1;

    } else {

        value = atoi(buf);

    }

    close (s);

    return value;

}

/*

 * Iterative way to find the max value that SO_SNDBUF or SO_RCVBUF

 * for Solaris versions that do not support the ioctl() in net_getParam().

 * Ugly, but only called once (for each sotype).

 *

 * As an optimization, we make a guess using the default values for Solaris

 * assuming they haven't been modified with ndd.

 */

#define MAX_TCP_GUESS 1024 * 1024

#define MAX_UDP_GUESS 2 * 1024 * 1024

#define FAIL_IF_NOT_ENOBUFS if (errno != ENOBUFS) return -1

static int findMaxBuf(int fd, int opt, int sotype) {

    int a = 0;

    int b = MAXINT;

    int initial_guess;

    int limit = -1;

    if (sotype == SOCK_DGRAM) {

        initial_guess = MAX_UDP_GUESS;

    } else {

        initial_guess = MAX_TCP_GUESS;

    }

    if (setsockopt(fd, SOL_SOCKET, opt, &initial_guess, sizeof(int)) == 0) {

        initial_guess++;

        if (setsockopt(fd, SOL_SOCKET, opt, &initial_guess,sizeof(int)) < 0) {

            FAIL_IF_NOT_ENOBUFS;

            return initial_guess - 1;

        }

        a = initial_guess;

    } else {

        FAIL_IF_NOT_ENOBUFS;

        b = initial_guess - 1;

    }

    do {

        int mid = a + (b-a)/2;

        if (setsockopt(fd, SOL_SOCKET, opt, &mid, sizeof(int)) == 0) {

            limit = mid;

            a = mid + 1;

        } else {

            FAIL_IF_NOT_ENOBUFS;

            b = mid - 1;

        }

    } while (b >= a);

    return limit;

}

#endif

#ifdef __linux__

static int vinit = 0;

static int kernelV24 = 0;

static int vinit24 = 0;

int kernelIsV24 () {

    if (!vinit24) {

        struct utsname sysinfo;

        if (uname(&sysinfo) == 0) {

            sysinfo.release[3] = '\0';

            if (strcmp(sysinfo.release, "2.4") == 0) {

                kernelV24 = JNI_TRUE;

            }

        }

        vinit24 = 1;

    }

    return kernelV24;

}

int getScopeID (struct sockaddr *him) {

    struct sockaddr_in6 *hext = (struct sockaddr_in6 *)him;

    return hext->sin6_scope_id;

}

int cmpScopeID (unsigned int scope, struct sockaddr *him) {

    struct sockaddr_in6 *hext = (struct sockaddr_in6 *)him;

    return hext->sin6_scope_id == scope;

}

#else

int getScopeID (struct sockaddr *him) {

    struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)him;

    return him6->sin6_scope_id;

}

int cmpScopeID (unsigned int scope, struct sockaddr *him) {

    struct sockaddr_in6 *him6 = (struct sockaddr_in6 *)him;

    return him6->sin6_scope_id == scope;

}

#endif

void

NET_ThrowByNameWithLastError(JNIEnv *env, const char *name,

                   const char *defaultDetail) {

    JNU_ThrowByNameWithMessageAndLastError(env, name, defaultDetail);

}

void

NET_ThrowCurrent(JNIEnv *env, char *msg) {

    NET_ThrowNew(env, errno, msg);

}

void

NET_ThrowNew(JNIEnv *env, int errorNumber, char *msg) {

    char fullMsg[512];

    if (!msg) {

        msg = "no further information";

    }

    switch(errorNumber) {

    case EBADF:

        jio_snprintf(fullMsg, sizeof(fullMsg), "socket closed: %s", msg);

        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", fullMsg);

        break;

    case EINTR:

        JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException", msg);

        break;

    default:

        errno = errorNumber;

        JNU_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException", msg);

        break;

    }

}

jfieldID

NET_GetFileDescriptorID(JNIEnv *env)

{

    jclass cls = (*env)->FindClass(env, "java/io/FileDescriptor");

    CHECK_NULL_RETURN(cls, NULL);

    return (*env)->GetFieldID(env, cls, "fd", "I");

}

#if defined(DONT_ENABLE_IPV6)

jint  IPv6_supported()

{

    return JNI_FALSE;

}

#else /* !DONT_ENABLE_IPV6 */

jint  IPv6_supported()

{

    int fd;

    void *ipv6_fn;

    SOCKETADDRESS sa;

    socklen_t sa_len = sizeof(SOCKETADDRESS);

    fd = socket(AF_INET6, SOCK_STREAM, 0) ;

    if (fd < 0) {

        /*

         *  TODO: We really cant tell since it may be an unrelated error

         *  for now we will assume that AF_INET6 is not available

         */

        return JNI_FALSE;

    }

    /*

     * If fd 0 is a socket it means we've been launched from inetd or

     * xinetd. If it's a socket then check the family - if it's an

     * IPv4 socket then we need to disable IPv6.

     */

    if (getsockname(0, &sa.sa, &sa_len) == 0) {

        if (sa.sa.sa_family != AF_INET6) {

            close(fd);

            return JNI_FALSE;

        }

    }

    /**

     * Linux - check if any interface has an IPv6 address.

     * Don't need to parse the line - we just need an indication.

     */

#ifdef __linux__

    {

        FILE *fP = fopen("/proc/net/if_inet6", "r");

        char buf[255];

        char *bufP;

        if (fP == NULL) {

            close(fd);

            return JNI_FALSE;

        }

        bufP = fgets(buf, sizeof(buf), fP);

        fclose(fP);

        if (bufP == NULL) {

            close(fd);

            return JNI_FALSE;

        }

    }

#endif

    /**

     * On Solaris 8 it's possible to create INET6 sockets even

     * though IPv6 is not enabled on all interfaces. Thus we

     * query the number of IPv6 addresses to verify that IPv6

     * has been configured on at least one interface.

     *

     * On Linux it doesn't matter - if IPv6 is built-in the

     * kernel then IPv6 addresses will be bound automatically

     * to all interfaces.

     */

#ifdef __solaris__

#ifdef SIOCGLIFNUM

    {

        struct lifnum numifs;

        numifs.lifn_family = AF_INET6;

        numifs.lifn_flags = 0;

        if (ioctl(fd, SIOCGLIFNUM, (char *)&numifs) < 0) {

            /**

             * SIOCGLIFNUM failed - assume IPv6 not configured

             */

            close(fd);

            return JNI_FALSE;

        }

        /**

         * If no IPv6 addresses then return false. If count > 0

         * it's possible that all IPv6 addresses are "down" but

         * that's okay as they may be brought "up" while the

         * VM is running.

         */

        if (numifs.lifn_count == 0) {

            close(fd);

            return JNI_FALSE;

        }

    }

#else

    /* SIOCGLIFNUM not defined in build environment ??? */

    close(fd);

    return JNI_FALSE;

#endif

#endif /* __solaris */

    /*

     *  OK we may have the stack available in the kernel,

     *  we should also check if the APIs are available.

     */

    ipv6_fn = JVM_FindLibraryEntry(RTLD_DEFAULT, "inet_pton");

    close(fd);

    if (ipv6_fn == NULL ) {

        return JNI_FALSE;

    } else {

        return JNI_TRUE;

    }

}

#endif /* DONT_ENABLE_IPV6 */

jint reuseport_supported()

{

    /* Do a simple dummy call, and try to figure out from that */

    int one = 1;

    int rv, s;

    s = socket(PF_INET, SOCK_STREAM, 0);

    if (s < 0) {

        return JNI_FALSE;

    }

    rv = setsockopt(s, SOL_SOCKET, SO_REUSEPORT, (void *)&one, sizeof(one));

    if (rv != 0) {

        rv = JNI_FALSE;

    } else {

        rv = JNI_TRUE;

    }

    close(s);

    return rv;

}

void NET_ThrowUnknownHostExceptionWithGaiError(JNIEnv *env,

                                               const char* hostname,

                                               int gai_error)

{

    int size;

    char *buf;

    const char *format = "%s: %s";

    const char *error_string = gai_strerror(gai_error);

    if (error_string == NULL)

        error_string = "unknown error";

    size = strlen(format) + strlen(hostname) + strlen(error_string) + 2;

    buf = (char *) malloc(size);

    if (buf) {

        jstring s;

        sprintf(buf, format, hostname, error_string);

        s = JNU_NewStringPlatform(env, buf);

        if (s != NULL) {

            jobject x = JNU_NewObjectByName(env,

                                            "java/net/UnknownHostException",

                                            "(Ljava/lang/String;)V", s);

            if (x != NULL)

                (*env)->Throw(env, x);

        }

        free(buf);

    }

}

/* following code creates a list of addresses from the kernel

 * routing table that are routed via the loopback address.

 * We check all destination addresses against this table

 * and override the scope_id field to use the relevant value for "lo"

 * in order to work-around the Linux bug that prevents packets destined

 * for certain local addresses from being sent via a physical interface.

 */

struct loopback_route {

    struct in6_addr addr; /* destination address */

    int plen; /* prefix length */

};

static struct loopback_route *loRoutes = 0;

static int nRoutes = 0; /* number of routes */

static int loRoutes_size = 16; /* initial size */

static int lo_scope_id = 0;

static void initLoopbackRoutes();

void printAddr (struct in6_addr *addr) {

    int i;

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

        printf ("%02x", addr->s6_addr[i]);

    }

    printf ("\n");

}

static jboolean needsLoopbackRoute (struct in6_addr* dest_addr) {

    int byte_count;

    int extra_bits, i;

    struct loopback_route *ptr;

    if (loRoutes == 0) {

        initLoopbackRoutes();

    }

    for (ptr = loRoutes, i=0; i<nRoutes; i++, ptr++) {

        struct in6_addr *target_addr=&ptr->addr;

        int dest_plen = ptr->plen;

        byte_count = dest_plen >> 3;

        extra_bits = dest_plen & 0x3;

        if (byte_count > 0) {