/*

 * Copyright (c) 2000, 2011, 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 <strings.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <net/if.h>

#include <net/if_arp.h>

#ifdef __solaris__

#include <sys/dlpi.h>

#include <fcntl.h>

#include <stropts.h>

#include <sys/sockio.h>

#endif

#ifdef __linux__

#include <sys/ioctl.h>

#include <bits/ioctls.h>

#include <sys/utsname.h>

#include <stdio.h>

#endif

#ifdef __linux__

#define _PATH_PROCNET_IFINET6           "/proc/net/if_inet6"

#endif

#include "jvm.h"

#include "jni_util.h"

#include "net_util.h"

typedef struct _netaddr  {

    struct sockaddr *addr;

    struct sockaddr *brdcast;

    short mask;

    int family; /* to make searches simple */

    struct _netaddr *next;

} netaddr;

typedef struct _netif {

    char *name;

    int index;

    char virtual;

    netaddr *addr;

    struct _netif *childs;

    struct _netif *next;

} netif;

/************************************************************************

 * NetworkInterface

 */

#include "java_net_NetworkInterface.h"

/************************************************************************

 * NetworkInterface

 */

jclass ni_class;

jfieldID ni_nameID;

jfieldID ni_indexID;

jfieldID ni_descID;

jfieldID ni_addrsID;

jfieldID ni_bindsID;

jfieldID ni_virutalID;

jfieldID ni_childsID;

jfieldID ni_parentID;

jmethodID ni_ctrID;

static jclass ni_iacls;

static jclass ni_ia4cls;

static jclass ni_ia6cls;

static jclass ni_ibcls;

static jmethodID ni_ia4ctrID;

static jmethodID ni_ia6ctrID;

static jmethodID ni_ibctrID;

static jfieldID ni_iaaddressID;

static jfieldID ni_iafamilyID;

static jfieldID ni_ia6ipaddressID;

static jfieldID ni_ibaddressID;

static jfieldID ni_ib4broadcastID;

static jfieldID ni_ib4maskID;

/** Private methods declarations **/

static jobject createNetworkInterface(JNIEnv *env, netif *ifs);

static int     getFlags0(JNIEnv *env, jstring  ifname);

static netif  *enumInterfaces(JNIEnv *env);

static netif  *enumIPv4Interfaces(JNIEnv *env, int sock, netif *ifs);

#ifdef AF_INET6

static netif  *enumIPv6Interfaces(JNIEnv *env, int sock, netif *ifs);

#endif

static netif  *addif(JNIEnv *env, int sock, const char * if_name, netif *ifs, struct sockaddr* ifr_addrP, int family, short prefix);

static void    freeif(netif *ifs);

static int     openSocket(JNIEnv *env, int proto);

static int     openSocketWithFallback(JNIEnv *env, const char *ifname);

static struct  sockaddr *getBroadcast(JNIEnv *env, int sock, const char *name, struct sockaddr *brdcast_store);

static short   getSubnet(JNIEnv *env, int sock, const char *ifname);

static int     getIndex(int sock, const char *ifname);

static int     getFlags(int sock, const char *ifname);

static int     getMacAddress(JNIEnv *env, int sock,  const char* ifname, const struct in_addr* addr, unsigned char *buf);

static int     getMTU(JNIEnv *env, int sock, const char *ifname);

#ifdef __solaris__

static netif *enumIPvXInterfaces(JNIEnv *env, int sock, netif *ifs, int family);

static int    getMacFromDevice(JNIEnv *env, const char* ifname, unsigned char* retbuf);

#ifndef SIOCGLIFHWADDR

#define SIOCGLIFHWADDR  _IOWR('i', 192, struct lifreq)

#endif

#endif

/******************* Java entry points *****************************/

/*

 * Class:     java_net_NetworkInterface

 * Method:    init

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_java_net_NetworkInterface_init(JNIEnv *env, jclass cls) {

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

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

    ni_nameID = (*env)->GetFieldID(env, ni_class,"name", "Ljava/lang/String;");

    ni_indexID = (*env)->GetFieldID(env, ni_class, "index", "I");

    ni_addrsID = (*env)->GetFieldID(env, ni_class, "addrs", "[Ljava/net/InetAddress;");

    ni_bindsID = (*env)->GetFieldID(env, ni_class, "bindings", "[Ljava/net/InterfaceAddress;");

    ni_descID = (*env)->GetFieldID(env, ni_class, "displayName", "Ljava/lang/String;");

    ni_virutalID = (*env)->GetFieldID(env, ni_class, "virtual", "Z");

    ni_childsID = (*env)->GetFieldID(env, ni_class, "childs", "[Ljava/net/NetworkInterface;");

    ni_parentID = (*env)->GetFieldID(env, ni_class, "parent", "Ljava/net/NetworkInterface;");

    ni_ctrID = (*env)->GetMethodID(env, ni_class, "<init>", "()V");

    ni_iacls = (*env)->FindClass(env, "java/net/InetAddress");

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

    ni_ia4cls = (*env)->FindClass(env, "java/net/Inet4Address");

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

    ni_ia6cls = (*env)->FindClass(env, "java/net/Inet6Address");

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

    ni_ibcls = (*env)->FindClass(env, "java/net/InterfaceAddress");

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

    ni_ia4ctrID = (*env)->GetMethodID(env, ni_ia4cls, "<init>", "()V");

    ni_ia6ctrID = (*env)->GetMethodID(env, ni_ia6cls, "<init>", "()V");

    ni_ibctrID = (*env)->GetMethodID(env, ni_ibcls, "<init>", "()V");

    ni_iaaddressID = (*env)->GetFieldID(env, ni_iacls, "address", "I");

    ni_iafamilyID = (*env)->GetFieldID(env, ni_iacls, "family", "I");

    ni_ia6ipaddressID = (*env)->GetFieldID(env, ni_ia6cls, "ipaddress", "[B");

    ni_ibaddressID = (*env)->GetFieldID(env, ni_ibcls, "address", "Ljava/net/InetAddress;");

    ni_ib4broadcastID = (*env)->GetFieldID(env, ni_ibcls, "broadcast", "Ljava/net/Inet4Address;");

    ni_ib4maskID = (*env)->GetFieldID(env, ni_ibcls, "maskLength", "S");

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    getByName0

 * Signature: (Ljava/lang/String;)Ljava/net/NetworkInterface;

 */

JNIEXPORT jobject JNICALL Java_java_net_NetworkInterface_getByName0

    (JNIEnv *env, jclass cls, jstring name) {

    netif *ifs, *curr;

    jboolean isCopy;

    const char* name_utf;

    jobject obj = NULL;

    ifs = enumInterfaces(env);

    if (ifs == NULL) {

        return NULL;

    }

    name_utf = (*env)->GetStringUTFChars(env, name, &isCopy);

    /*

     * Search the list of interface based on name

     */

    curr = ifs;

    while (curr != NULL) {

        if (strcmp(name_utf, curr->name) == 0) {

            break;

        }

        curr = curr->next;

    }

    /* if found create a NetworkInterface */

    if (curr != NULL) {;

        obj = createNetworkInterface(env, curr);

    }

    /* release the UTF string and interface list */

    (*env)->ReleaseStringUTFChars(env, name, name_utf);

    freeif(ifs);

    return obj;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    getByIndex0

 * Signature: (Ljava/lang/String;)Ljava/net/NetworkInterface;

 */

JNIEXPORT jobject JNICALL Java_java_net_NetworkInterface_getByIndex0

    (JNIEnv *env, jclass cls, jint index) {

    netif *ifs, *curr;

    jobject obj = NULL;

    if (index <= 0) {

        return NULL;

    }

    ifs = enumInterfaces(env);

    if (ifs == NULL) {

        return NULL;

    }

    /*

     * Search the list of interface based on index

     */

    curr = ifs;

    while (curr != NULL) {

        if (index == curr->index) {

            break;

        }

        curr = curr->next;

    }

    /* if found create a NetworkInterface */

    if (curr != NULL) {;

        obj = createNetworkInterface(env, curr);

    }

    freeif(ifs);

    return obj;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    getByInetAddress0

 * Signature: (Ljava/net/InetAddress;)Ljava/net/NetworkInterface;

 */

JNIEXPORT jobject JNICALL Java_java_net_NetworkInterface_getByInetAddress0

    (JNIEnv *env, jclass cls, jobject iaObj) {

    netif *ifs, *curr;

#ifdef AF_INET6

    int family = (  (*env)->GetIntField(env, iaObj, ni_iafamilyID) == IPv4 ) ? AF_INET : AF_INET6;

#else

    int family =  AF_INET;

#endif

    jobject obj = NULL;

    jboolean match = JNI_FALSE;

    ifs = enumInterfaces(env);

    if (ifs == NULL) {

        return NULL;

    }

    curr = ifs;

    while (curr != NULL) {

        netaddr *addrP = curr->addr;

        /*

         * Iterate through each address on the interface

         */

        while (addrP != NULL) {

            if (family == addrP->family) {

                if (family == AF_INET) {

                    int address1 = htonl(((struct sockaddr_in*)addrP->addr)->sin_addr.s_addr);

                    int address2 = (*env)->GetIntField(env, iaObj, ni_iaaddressID);

                    if (address1 == address2) {

                        match = JNI_TRUE;

                        break;

                    }

                }

#ifdef AF_INET6

                if (family == AF_INET6) {

                    jbyte *bytes = (jbyte *)&(((struct sockaddr_in6*)addrP->addr)->sin6_addr);

                    jbyteArray ipaddress = (*env)->GetObjectField(env, iaObj, ni_ia6ipaddressID);

                    jbyte caddr[16];

                    int i;

                    (*env)->GetByteArrayRegion(env, ipaddress, 0, 16, caddr);

                    i = 0;

                    while (i < 16) {

                        if (caddr[i] != bytes[i]) {

                            break;

                        }

                        i++;

                    }

                    if (i >= 16) {

                        match = JNI_TRUE;

                        break;

                    }

                }

#endif

            }

            if (match) {

                break;

            }

            addrP = addrP->next;

        }

        if (match) {

            break;

        }

        curr = curr->next;

    }

    /* if found create a NetworkInterface */

    if (match) {;

        obj = createNetworkInterface(env, curr);

    }

    freeif(ifs);

    return obj;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    getAll

 * Signature: ()[Ljava/net/NetworkInterface;

 */

JNIEXPORT jobjectArray JNICALL Java_java_net_NetworkInterface_getAll

    (JNIEnv *env, jclass cls) {

    netif *ifs, *curr;

    jobjectArray netIFArr;

    jint arr_index, ifCount;

    ifs = enumInterfaces(env);

    if (ifs == NULL) {

        return NULL;

    }

    /* count the interface */

    ifCount = 0;

    curr = ifs;

    while (curr != NULL) {

        ifCount++;

        curr = curr->next;

    }

    /* allocate a NetworkInterface array */

    netIFArr = (*env)->NewObjectArray(env, ifCount, cls, NULL);

    if (netIFArr == NULL) {

        freeif(ifs);

        return NULL;

    }

    /*

     * Iterate through the interfaces, create a NetworkInterface instance

     * for each array element and populate the object.

     */

    curr = ifs;

    arr_index = 0;

    while (curr != NULL) {

        jobject netifObj;

        netifObj = createNetworkInterface(env, curr);

        if (netifObj == NULL) {

            freeif(ifs);

            return NULL;

        }

        /* put the NetworkInterface into the array */

        (*env)->SetObjectArrayElement(env, netIFArr, arr_index++, netifObj);

        curr = curr->next;

    }

    freeif(ifs);

    return netIFArr;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    isUp0

 * Signature: (Ljava/lang/String;I)Z

 */

JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isUp0(JNIEnv *env, jclass cls, jstring name, jint index) {

    int ret = getFlags0(env, name);

    return ((ret & IFF_UP) && (ret & IFF_RUNNING)) ? JNI_TRUE :  JNI_FALSE;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    isP2P0

 * Signature: (Ljava/lang/String;I)Z

 */

JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isP2P0(JNIEnv *env, jclass cls, jstring name, jint index) {

    int ret = getFlags0(env, name);

    return (ret & IFF_POINTOPOINT) ? JNI_TRUE :  JNI_FALSE;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    isLoopback0

 * Signature: (Ljava/lang/String;I)Z

 */

JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isLoopback0(JNIEnv *env, jclass cls, jstring name, jint index) {

    int ret = getFlags0(env, name);

    return (ret & IFF_LOOPBACK) ? JNI_TRUE :  JNI_FALSE;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    supportsMulticast0

 * Signature: (Ljava/lang/String;I)Z

 */

JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_supportsMulticast0(JNIEnv *env, jclass cls, jstring name, jint index) {

    int ret = getFlags0(env, name);

    return (ret & IFF_MULTICAST) ? JNI_TRUE :  JNI_FALSE;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    getMacAddr0

 * Signature: ([bLjava/lang/String;I)[b

 */

JNIEXPORT jbyteArray JNICALL Java_java_net_NetworkInterface_getMacAddr0(JNIEnv *env, jclass class, jbyteArray addrArray, jstring name, jint index) {

    jint addr;

    jbyte caddr[4];

    struct in_addr iaddr;

    jbyteArray ret = NULL;

    unsigned char mac[16];

    int len;

    int sock;

    jboolean isCopy;

    const char* name_utf;

    name_utf = (*env)->GetStringUTFChars(env, name, &isCopy);

    if ((sock =openSocketWithFallback(env, name_utf)) < 0) {

       (*env)->ReleaseStringUTFChars(env, name, name_utf);

       return JNI_FALSE;

    }

    if (!IS_NULL(addrArray)) {

       (*env)->GetByteArrayRegion(env, addrArray, 0, 4, caddr);

       addr = ((caddr[0]<<24) & 0xff000000);

       addr |= ((caddr[1] <<16) & 0xff0000);

       addr |= ((caddr[2] <<8) & 0xff00);

       addr |= (caddr[3] & 0xff);

       iaddr.s_addr = htonl(addr);

       len = getMacAddress(env, sock, name_utf, &iaddr, mac);

    } else {

       len = getMacAddress(env, sock, name_utf,NULL, mac);

    }

    if (len > 0) {

       ret = (*env)->NewByteArray(env, len);

       if (IS_NULL(ret)) {

          /* we may have memory to free at the end of this */

          goto fexit;

       }

       (*env)->SetByteArrayRegion(env, ret, 0, len, (jbyte *) (mac));

    }

 fexit:

   /* release the UTF string and interface list */

   (*env)->ReleaseStringUTFChars(env, name, name_utf);

   close(sock);

   return ret;

}

/*

 * Class:       java_net_NetworkInterface

 * Method:      getMTU0