/*

 * Copyright (c) 2000, 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 <arpa/inet.h>

#include <errno.h>

#include <net/if.h>

#include <net/if_arp.h>

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>

#if defined(_AIX)

#include <netinet/in6_var.h>

#include <sys/ndd_var.h>

#include <sys/kinfo.h>

#endif

#if defined(__solaris__)

#include <stropts.h>

#include <sys/dlpi.h>

#include <sys/sockio.h>

#endif

#if defined(_ALLBSD_SOURCE)

#include <net/ethernet.h>

#include <net/if_dl.h>

#include <ifaddrs.h>

#endif

#include "net_util.h"

#include "java_net_InetAddress.h"

#if defined(__linux__)

    #define _PATH_PROCNET_IFINET6 "/proc/net/if_inet6"

#elif defined(__solaris__)

    #ifndef SIOCGLIFHWADDR

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

    #endif

    #define DEV_PREFIX "/dev/"

#endif

#ifdef LIFNAMSIZ

    #define IFNAMESIZE LIFNAMSIZ

#else

    #define IFNAMESIZE IFNAMSIZ

#endif

#define CHECKED_MALLOC3(_pointer, _type, _size) \

    do { \

        _pointer = (_type)malloc(_size); \

        if (_pointer == NULL) { \

            JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); \

            return ifs; /* return untouched list */ \

        } \

    } while(0)

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;

jfieldID ni_defaultIndexID;

jmethodID ni_ctrID;

static jclass ni_ibcls;

static jmethodID ni_ibctrID;

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

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

static netif  *addif(JNIEnv *env, int sock, const char *if_name, netif *ifs,

                     struct sockaddr *ifr_addrP,

                     struct sockaddr *ifr_broadaddrP,

                     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 short   translateIPv4AddressToPrefix(struct sockaddr_in *addr);

static short   translateIPv6AddressToPrefix(struct sockaddr_in6 *addr);

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

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

static int     getMacAddress(JNIEnv *env, const char *ifname,

                             const struct in_addr *addr, unsigned char *buf);

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

#if defined(__solaris__)

static int     getMacFromDevice(JNIEnv *env, const char *ifname,

                                unsigned char *retbuf);

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

    CHECK_NULL(ni_class);

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

    CHECK_NULL(ni_class);

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

    CHECK_NULL(ni_nameID);

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

    CHECK_NULL(ni_indexID);

    ni_addrsID = (*env)->GetFieldID(env, ni_class, "addrs",

                                    "[Ljava/net/InetAddress;");

    CHECK_NULL(ni_addrsID);

    ni_bindsID = (*env)->GetFieldID(env, ni_class, "bindings",

                                    "[Ljava/net/InterfaceAddress;");

    CHECK_NULL(ni_bindsID);

    ni_descID = (*env)->GetFieldID(env, ni_class, "displayName",

                                   "Ljava/lang/String;");

    CHECK_NULL(ni_descID);

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

    CHECK_NULL(ni_virutalID);

    ni_childsID = (*env)->GetFieldID(env, ni_class, "childs",

                                     "[Ljava/net/NetworkInterface;");

    CHECK_NULL(ni_childsID);

    ni_parentID = (*env)->GetFieldID(env, ni_class, "parent",

                                     "Ljava/net/NetworkInterface;");

    CHECK_NULL(ni_parentID);

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

    CHECK_NULL(ni_ctrID);

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

    CHECK_NULL(ni_ibcls);

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

    CHECK_NULL(ni_ibcls);

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

    CHECK_NULL(ni_ibctrID);

    ni_ibaddressID = (*env)->GetFieldID(env, ni_ibcls, "address",

                                        "Ljava/net/InetAddress;");

    CHECK_NULL(ni_ibaddressID);

    ni_ib4broadcastID = (*env)->GetFieldID(env, ni_ibcls, "broadcast",

                                           "Ljava/net/Inet4Address;");

    CHECK_NULL(ni_ib4broadcastID);

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

    CHECK_NULL(ni_ib4maskID);

    ni_defaultIndexID = (*env)->GetStaticFieldID(env, ni_class, "defaultIndex",

                                                 "I");

    CHECK_NULL(ni_defaultIndexID);

    initInetAddressIDs(env);

}

/*

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

    if (name != NULL) {

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

    } else {

        JNU_ThrowNullPointerException(env, "network interface name is NULL");

        return NULL;

    }

    if (name_utf == NULL) {

        if (!(*env)->ExceptionCheck(env))

            JNU_ThrowOutOfMemoryError(env, NULL);

        return NULL;

    }

    ifs = enumInterfaces(env);

    if (ifs == NULL) {

        return NULL;

    }

    curr = ifs;

    while (curr != NULL) {

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

    }

    // release the interface list

    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;

    int family = (getInetAddress_family(env, iaObj) == java_net_InetAddress_IPv4) ?

        AF_INET : AF_INET6;

    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 = getInetAddress_addr(env, iaObj);

                    if (address1 == address2) {

                        match = JNI_TRUE;

                        break;

                    }

                } else if (family == AF_INET6) {

                    jbyte *bytes = (jbyte *)&(

                        ((struct sockaddr_in6*)addrP->addr)->sin6_addr);

                    jbyte caddr[16];

                    int i;

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

                    i = 0;

                    while (i < 16) {

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

                            break;

                        }

                        i++;

                    }

                    if (i >= 16) {

                        match = JNI_TRUE;

                        break;

                    }

                }

            }

            if (match) {

                break;

            }

            addrP = addrP->next;

        }

        if (match) {

            break;

        }

        curr = curr->next;

    }

    // if found create a NetworkInterface

    if (match) {

        obj = createNetworkInterface(env, curr);

    }

    // release the interface list

    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 interfaces

    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;

    }

    // release the interface list

    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)

{