/*

 * Copyright (c) 1997, 2019, 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

#if defined(MACOSX)

#include <sys/sysctl.h>

#endif

#include "jvm.h"

#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

#define RESTARTABLE(_cmd, _result) do { \

    do { \

        _result = _cmd; \

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

} while(0)

int NET_SocketAvailable(int s, int *pbytes) {

    int result;

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

    return result;

}

#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

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

}

jint  IPv4_supported()

{

    int fd = socket(AF_INET, SOCK_STREAM, 0) ;

    if (fd < 0) {

        return JNI_FALSE;

    }

    close(fd);

    return JNI_TRUE;

}

#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 may have 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_INET) {

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

    }

}

#if defined(_AIX)

/* Initialize stubs for blocking I/O workarounds (see src/solaris/native/java/net/linux_close.c) */

extern void aix_close_init();

void platformInit () {

    aix_close_init();

}

#else

void platformInit () {}

#endif

void parseExclusiveBindProperty(JNIEnv *env) {

#ifdef __solaris__

    jstring s, flagSet;

    jclass iCls;

    jmethodID mid;

    s = (*env)->NewStringUTF(env, "sun.net.useExclusiveBind");

    CHECK_NULL(s);

    iCls = (*env)->FindClass(env, "java/lang/System");

    CHECK_NULL(iCls);

    mid = (*env)->GetStaticMethodID(env, iCls, "getProperty",

                "(Ljava/lang/String;)Ljava/lang/String;");

    CHECK_NULL(mid);

    flagSet = (*env)->CallStaticObjectMethod(env, iCls, mid, s);

    if (flagSet != NULL) {

        useExclBind = 1;

    }

#endif

}

JNIEXPORT jint JNICALL

NET_EnableFastTcpLoopback(int fd) {

    return 0;

}

/**

 * See net_util.h for documentation

 */

JNIEXPORT int JNICALL

NET_InetAddressToSockaddr(JNIEnv *env, jobject iaObj, int port,

                          SOCKETADDRESS *sa, int *len,

                          jboolean v4MappedAddress)

{

    jint family = getInetAddress_family(env, iaObj);

    JNU_CHECK_EXCEPTION_RETURN(env, -1);

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

    if (ipv6_available() &&

        !(family == java_net_InetAddress_IPv4 &&

          v4MappedAddress == JNI_FALSE))

    {

        jbyte caddr[16];

        jint address;

        if (family == java_net_InetAddress_IPv4) {

            // convert to IPv4-mapped address

            memset((char *)caddr, 0, 16);

            address = getInetAddress_addr(env, iaObj);

            JNU_CHECK_EXCEPTION_RETURN(env, -1);

            if (address == INADDR_ANY) {

                /* we would always prefer IPv6 wildcard address

                 * caddr[10] = 0xff;

                 * caddr[11] = 0xff; */

            } else {

                caddr[10] = 0xff;

                caddr[11] = 0xff;

                caddr[12] = ((address >> 24) & 0xff);

                caddr[13] = ((address >> 16) & 0xff);

                caddr[14] = ((address >> 8) & 0xff);

                caddr[15] = (address & 0xff);

            }

        } else {

            getInet6Address_ipaddress(env, iaObj, (char *)caddr);

        }

        sa->sa6.sin6_port = htons(port);

        memcpy((void *)&sa->sa6.sin6_addr, caddr, sizeof(struct in6_addr));

        sa->sa6.sin6_family = AF_INET6;

        if (len != NULL) {

            *len = sizeof(struct sockaddr_in6);

        }

        /* handle scope_id */

        if (family != java_net_InetAddress_IPv4) {

            if (ia6_scopeidID) {

                sa->sa6.sin6_scope_id = getInet6Address_scopeid(env, iaObj);

            }

        }

    } else {

        jint address;

        if (family != java_net_InetAddress_IPv4) {

            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Protocol family unavailable");

            return -1;

        }

        address = getInetAddress_addr(env, iaObj);

        JNU_CHECK_EXCEPTION_RETURN(env, -1);

        sa->sa4.sin_port = htons(port);

        sa->sa4.sin_addr.s_addr = htonl(address);

        sa->sa4.sin_family = AF_INET;

        if (len != NULL) {

            *len = sizeof(struct sockaddr_in);

        }

    }

    return 0;

}

void

NET_SetTrafficClass(SOCKETADDRESS *sa, int trafficClass) {