/*

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

#include <strings.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;

    char *colonP;

    char searchName[IFNAMESIZE];

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

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

        return NULL;

    }

    // search the list of interfaces based on name,

    // if it is virtual sub interface search with parent first.

    strncpy(searchName, name_utf, IFNAMESIZE);

    searchName[IFNAMESIZE - 1] = '\0';

    colonP = strchr(searchName, ':');

    if (colonP != NULL) {

        *colonP = '\0';

    }

    curr = ifs;

    while (curr != NULL) {

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

            break;

        }

        curr = curr->next;

    }

    // search the child list

    if (colonP != NULL && curr != NULL) {

        curr = curr->childs;

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

}

// Return the interface in ifs that iaObj is bound to, if any - otherwise NULL

static netif* find_bound_interface(JNIEnv *env, netif* ifs, jobject iaObj, int family) {

    netif* 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 ((*env)->ExceptionCheck(env)) {

                        return NULL;

                    }

                    if (address1 == address2) {

                        return curr;

                    }

                } else if (family == AF_INET6) {

                    jbyte *bytes = (jbyte *)&(

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

                    jbyte caddr[16];

                    int i;

                    unsigned int scopeid;

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

                    scopeid = (unsigned int)getInet6Address_scopeid(env, iaObj);

                    if (scopeid != 0 && scopeid != ((struct sockaddr_in6*)addrP->addr)->sin6_scope_id)

                        break;

                    i = 0;

                    while (i < 16) {

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

                            break;

                        }

                        i++;

                    }

                    if (i >= 16) {

                        return curr;

                    }

                }

            }

            addrP = addrP->next;

        }

        curr = curr->next;

    }

    return NULL;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    boundInetAddress0

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

 */

JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_boundInetAddress0

    (JNIEnv *env, jclass cls, jobject iaObj)

{

    netif *ifs = NULL;

    jboolean bound = JNI_FALSE;

    int sock;

    int family = getInetAddress_family(env, iaObj);

    JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE);

    if (family == java_net_InetAddress_IPv4) {

        family = AF_INET;

    } else if (family == java_net_InetAddress_IPv6) {

        family = AF_INET6;

    } else {

        return JNI_FALSE; // Invalid family

    }

    if (family == AF_INET) {

        sock = openSocket(env, AF_INET);

        if (sock < 0 && (*env)->ExceptionOccurred(env)) {

            return JNI_FALSE;

        }

        // enumerate IPv4 addresses

        if (sock >= 0) {

            ifs = enumIPv4Interfaces(env, sock, ifs);

            close(sock);

            if ((*env)->ExceptionOccurred(env)) {

                goto cleanup;

            }

        }

        if (find_bound_interface(env, ifs, iaObj, family) != NULL)

            bound = JNI_TRUE;

    } else if (ipv6_available()) {

        // If IPv6 is available then enumerate IPv6 addresses.

        // User can disable ipv6 explicitly by -Djava.net.preferIPv4Stack=true,

        // so we have to call ipv6_available()

        sock = openSocket(env, AF_INET6);

        if (sock < 0) {

            return JNI_FALSE;

        }

        ifs = enumIPv6Interfaces(env, sock, ifs);

        close(sock);

        if ((*env)->ExceptionOccurred(env)) {

            goto cleanup;

        }

        if (find_bound_interface(env, ifs, iaObj, family) != NULL)

            bound = JNI_TRUE;

    }

cleanup:

    freeif(ifs);

    return bound;

}

/*

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

    jobject obj = NULL;

    int family = getInetAddress_family(env, iaObj);

    JNU_CHECK_EXCEPTION_RETURN(env, NULL);

    if (family == java_net_InetAddress_IPv4) {

        family = AF_INET;

    } else if (family == java_net_InetAddress_IPv6) {

        family = AF_INET6;

    } else {

        return NULL; // Invalid family

    }

    ifs = enumInterfaces(env);

    if (ifs == NULL) {

        return NULL;

    }

    curr = find_bound_interface(env, ifs, iaObj, family);

    // 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:    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;