/*

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

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/tcp.h>        /* Defines TCP_NODELAY, needed for 2.6 */

#include <netinet/in.h>

#include <net/if.h>

#include <netdb.h>

#include <stdlib.h>

#include <dlfcn.h>

#ifdef __solaris__

#include <sys/sockio.h>

#include <stropts.h>

#include <inet/nd.h>

#endif

#ifdef __linux__

#include <arpa/inet.h>

#include <net/route.h>

#include <sys/utsname.h>

#ifndef IPV6_FLOWINFO_SEND

#define IPV6_FLOWINFO_SEND      33

#endif

#endif

#include "jni_util.h"

#include "jvm.h"

#include "net_util.h"

#include "java_net_SocketOptions.h"

/* needed from libsocket on Solaris 8 */

getaddrinfo_f getaddrinfo_ptr = NULL;

freeaddrinfo_f freeaddrinfo_ptr = NULL;

gai_strerror_f gai_strerror_ptr = NULL;

getnameinfo_f getnameinfo_ptr = NULL;

/*

 * EXCLBIND socket options only on Solaris 8 & 9.

 */

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

#define TCP_EXCLBIND            0x21

#endif

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

#define UDP_EXCLBIND            0x0101

#endif

#ifdef __solaris__

static int tcp_max_buf;

static int udp_max_buf;

/*

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

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

 */

static int

{

    struct strioctl stri;

    char buf [64];

    int s;

    int value;

    s = open (driver, O_RDWR);

    if (s < 0) {

    }

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

    } else {

        value = atoi(buf);

    }

    close (s);

    return value;

}

#endif

#ifdef __linux__

static int kernelV22 = 0;

static int vinit = 0;

int kernelIsV22 () {

    if (!vinit) {

        struct utsname sysinfo;

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

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

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

                kernelV22 = JNI_TRUE;

            }

        }

        vinit = 1;

    }

    return kernelV22;

}

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;

    if (kernelIsV22()) {

        return 0;

    }

    return hext->sin6_scope_id;

}

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

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

    if (kernelIsV22()) {

        return 1;       /* scope is ignored for comparison in 2.2 kernel */

    }

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

    char errmsg[255];

    sprintf(errmsg, "errno: %d, error: %s\n", errno, defaultDetail);

    JNU_ThrowByNameWithLastError(env, name, errmsg);

}

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  IPv6_supported()

{

#ifndef AF_INET6

    return JNI_FALSE;

#endif

#ifdef AF_INET6

    int fd;

    void *ipv6_fn;

    SOCKADDR sa;

    socklen_t sa_len = sizeof(sa);

    fd = JVM_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, (struct sockaddr *)&sa, &sa_len) == 0) {

        struct sockaddr *saP = (struct sockaddr *)&sa;

        if (saP->sa_family != AF_INET6) {

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

    if (ipv6_fn == NULL ) {

        close(fd);

        return JNI_FALSE;

    }

    /*

     * We've got the library, let's get the pointers to some

     * IPV6 specific functions. We have to do that because, at least

     * on Solaris we may build on a system without IPV6 networking

     * libraries, therefore we can't have a hard link to these

     * functions.

     */

    getaddrinfo_ptr = (getaddrinfo_f)

        JVM_FindLibraryEntry(RTLD_DEFAULT, "getaddrinfo");

    freeaddrinfo_ptr = (freeaddrinfo_f)

        JVM_FindLibraryEntry(RTLD_DEFAULT, "freeaddrinfo");

    gai_strerror_ptr = (gai_strerror_f)

        JVM_FindLibraryEntry(RTLD_DEFAULT, "gai_strerror");

    getnameinfo_ptr = (getnameinfo_f)

        JVM_FindLibraryEntry(RTLD_DEFAULT, "getnameinfo");

    if (freeaddrinfo_ptr == NULL || getnameinfo_ptr == NULL) {

        /* We need all 3 of them */

        getaddrinfo_ptr = NULL;

    }

    close(fd);

    return JNI_TRUE;

#endif /* AF_INET6 */

}

void ThrowUnknownHostExceptionWithGaiError(JNIEnv *env,

                                           const char* hostname,

                                           int gai_error)

{

    int size;

    char *buf;

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

    const char *error_string =

        (gai_strerror_ptr == NULL) ? NULL : (*gai_strerror_ptr)(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);

    }

}

void

NET_AllocSockaddr(struct sockaddr **him, int *len) {

#ifdef AF_INET6

    if (ipv6_available()) {

        struct sockaddr_in6 *him6 = (struct sockaddr_in6*)malloc(sizeof(struct sockaddr_in6));

        *him = (struct sockaddr*)him6;

        *len = sizeof(struct sockaddr_in6);

    } else

#endif /* AF_INET6 */

        {

            struct sockaddr_in *him4 = (struct sockaddr_in*)malloc(sizeof(struct sockaddr_in));

            *him = (struct sockaddr*)him4;

            *len = sizeof(struct sockaddr_in);

        }

}

#if defined(__linux__) && defined(AF_INET6)

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

            if (memcmp(target_addr, dest_addr, byte_count)) {

                continue;  /* no match */

            }

        }

        if (extra_bits > 0) {

            unsigned char c1 = ((unsigned char *)target_addr)[byte_count];

            unsigned char c2 = ((unsigned char *)&dest_addr)[byte_count];

            unsigned char mask = 0xff << (8 - extra_bits);

            if ((c1 & mask) != (c2 & mask)) {

                continue;

            }

        }

        return JNI_TRUE;