/*

 * Copyright 1997-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 <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;

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

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

 * cannot be obtained return the specified default value.

 */

static int

getParam(char *driver, char *param, int dflt)

{

    struct strioctl stri;

    char buf [64];

    int s;

    int value;

    s = open (driver, O_RDWR);

    if (s < 0) {

        return dflt;

    }

    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 = dflt;

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

    int 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 */

#endif /* AF_INET6 */

    /*

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

    getnameinfo_ptr = (getnameinfo_f)

        JVM_FindLibraryEntry(RTLD_DEFAULT, "getnameinfo");

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

        /* Wee need all 3 of them */

        getaddrinfo_ptr = NULL;

    }

    close(fd);

    return JNI_TRUE;

}

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;

    }

    return JNI_FALSE;

}

static void initLoopbackRoutes() {

    FILE *f;

    char srcp[8][5];

    char hopp[8][5];

    int dest_plen, src_plen, use, refcnt, metric;

    unsigned long flags;

    char dest_str[40];

    struct in6_addr dest_addr;

    char device[16];

    jboolean match = JNI_FALSE;

    if (loRoutes != 0) {

        free (loRoutes);

    }

    loRoutes = calloc (loRoutes_size, sizeof(struct loopback_route));

    if (loRoutes == 0) {

        return;

    }

    /*

     * Scan /proc/net/ipv6_route looking for a matching

     * route.

     */

    if ((f = fopen("/proc/net/ipv6_route", "r")) == NULL) {

        return ;

    }

    while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

                     "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

                     "%4s%4s%4s%4s%4s%4s%4s%4s "

                     "%08x %08x %08x %08lx %8s",

                     dest_str, &dest_str[5], &dest_str[10], &dest_str[15],

                     &dest_str[20], &dest_str[25], &dest_str[30], &dest_str[35],

                     &dest_plen,

                     srcp[0], srcp[1], srcp[2], srcp[3],

                     srcp[4], srcp[5], srcp[6], srcp[7],

                     &src_plen,

                     hopp[0], hopp[1], hopp[2], hopp[3],

                     hopp[4], hopp[5], hopp[6], hopp[7],

                     &metric, &use, &refcnt, &flags, device) == 31) {

        /*

         * Some routes should be ignored

         */

        if ( (dest_plen < 0 || dest_plen > 128)  ||

             (src_plen != 0) ||

             (flags & (RTF_POLICY | RTF_FLOW)) ||

             ((flags & RTF_REJECT) && dest_plen == 0) ) {

            continue;

        }

        /*

         * Convert the destination address

         */

        dest_str[4] = ':';

        dest_str[9] = ':';

        dest_str[14] = ':';

        dest_str[19] = ':';

        dest_str[24] = ':';

        dest_str[29] = ':';

        dest_str[34] = ':';

        dest_str[39] = '\0';

        if (inet_pton(AF_INET6, dest_str, &dest_addr) < 0) {

            /* not an Ipv6 address */

            continue;

        }

        if (strcmp(device, "lo") != 0) {

            /* Not a loopback route */

            continue;

        } else {

            if (nRoutes == loRoutes_size) {

                loRoutes = realloc (loRoutes, loRoutes_size *

                                sizeof (struct loopback_route) * 2);

                if (loRoutes == 0) {

                    return ;

                }

                loRoutes_size *= 2;

            }

            memcpy (&loRoutes[nRoutes].addr,&dest_addr,sizeof(struct in6_addr));

            loRoutes[nRoutes].plen = dest_plen;

            nRoutes ++;

        }

    }

    fclose (f);

    {

        /* now find the scope_id for "lo" */

        char addr6[40], devname[20];

        char addr6p[8][5];