/*

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

#include <windows.h>

#include <winsock2.h>           /* needed for htonl */

#include <iprtrmib.h>

#include <assert.h>

#include "java_net_NetworkInterface.h"

#include "jni_util.h"

#include "NetworkInterface.h"

/*

 * Windows implementation of the java.net.NetworkInterface native methods.

 * This module provides the implementations of getAll, getByName, getByIndex,

 * and getByAddress.

 *

 * Interfaces and addresses are enumerated using the IP helper routines

 * GetIfTable, GetIfAddrTable resp. These routines are available on Windows

 * 98, NT SP+4, 2000, and XP. They are also available on Windows 95 if

 * IE is upgraded to 5.x.

 *

 * Windows does not have any standard for device names so we are forced

 * to use our own convention which is based on the normal Unix naming

 * convention ("lo" for the loopback, eth0, eth1, .. for ethernet devices,

 * tr0, tr1, .. for token ring, and so on). This convention gives us

 * consistency across multiple Windows editions and also consistency with

 * Solaris/Linux device names. Note that we always enumerate in index

 * order and this ensures consistent device number across invocations.

 */

/* various JNI ids */

jclass ni_class;            /* NetworkInterface */

jmethodID ni_ctor;          /* NetworkInterface() */

jfieldID ni_indexID;        /* NetworkInterface.index */

jfieldID ni_addrsID;        /* NetworkInterface.addrs */

jfieldID ni_bindsID;        /* NetworkInterface.bindings */

jfieldID ni_nameID;         /* NetworkInterface.name */

jfieldID ni_displayNameID;  /* NetworkInterface.displayName */

jfieldID ni_childsID;       /* NetworkInterface.childs */

jclass ni_iacls;            /* InetAddress */

jclass ni_ia4cls;           /* Inet4Address */

jmethodID ni_ia4Ctor;       /* Inet4Address() */

jclass ni_ia6cls;           /* Inet6Address */

jmethodID ni_ia6ctrID;      /* Inet6Address() */

jfieldID ni_ia6ipaddressID;

jfieldID ni_ia6ipaddressID;

jclass ni_ibcls;            /* InterfaceAddress */

jmethodID ni_ibctrID;       /* InterfaceAddress() */

jfieldID ni_ibaddressID;        /* InterfaceAddress.address */

jfieldID ni_ibbroadcastID;      /* InterfaceAddress.broadcast */

jfieldID ni_ibmaskID;           /* InterfaceAddress.maskLength */

/*

 * Support routines to free netif and netaddr lists

 */

void free_netif(netif *netifP) {

    netif *curr = netifP;

    while (curr != NULL) {

        if (curr->name != NULL)

            free(curr->name);

        if (curr->displayName != NULL)

            free(curr->displayName);

        if (curr->addrs != NULL)

            free_netaddr (curr->addrs);

        netifP = netifP->next;

        free(curr);

        curr = netifP;

    }

}

void free_netaddr(netaddr *netaddrP) {

    netaddr *curr = netaddrP;

    while (curr != NULL) {

        netaddrP = netaddrP->next;

        free(curr);

        curr = netaddrP;

    }

}

/*

 * Returns the interface structure from the table with the matching index.

 */

MIB_IFROW *getIF(jint index) {

    MIB_IFTABLE *tableP;

    MIB_IFROW *ifrowP, *ret = NULL;

    ULONG size;

    DWORD i, count;

    jint ifindex;

    /*

     * Ask the IP Helper library to enumerate the adapters

     */

    size = sizeof(MIB_IFTABLE);

    tableP = (MIB_IFTABLE *)malloc(size);

    count = GetIfTable(tableP, &size, TRUE);

    if (count == ERROR_INSUFFICIENT_BUFFER || count == ERROR_BUFFER_OVERFLOW) {

        tableP = (MIB_IFTABLE *)realloc(tableP, size);

        count = GetIfTable(tableP, &size, TRUE);

    }

    if (count != NO_ERROR) {

        if (tableP != NULL)

            free(tableP);

        return NULL;

    }

    if (tableP != NULL) {

      ifrowP = tableP->table;

      for (i=0; i<tableP->dwNumEntries; i++) {

        /*

         * Warning the real index is obtained by GetFriendlyIfIndex()

         */

        ifindex = GetFriendlyIfIndex(ifrowP->dwIndex);

        if (ifindex == index) {

          /*

           * Create a copy of the entry so that we can free the table.

           */

          ret = (MIB_IFROW *) malloc(sizeof(MIB_IFROW));

          memcpy(ret, ifrowP, sizeof(MIB_IFROW));

          break;

        }

        /* onto the next interface */

        ifrowP++;

      }

      free(tableP);

    }

    return ret;

}

/*

 * Enumerate network interfaces using IP Helper Library routine GetIfTable.

 * We use GetIfTable rather than other IP helper routines because it's

 * available on 98 & NT SP4+.

 *

 * Returns the number of interfaces found or -1 if error. If no error

 * occurs then netifPP be returned as list of netif structures or NULL

 * if no interfaces are found.

 */

int enumInterfaces(JNIEnv *env, netif **netifPP)

{

    MIB_IFTABLE *tableP;

    MIB_IFROW *ifrowP;

    ULONG size;

    DWORD ret;

    int count;

    netif *netifP;

    DWORD i;

    int lo=0, eth=0, tr=0, fddi=0, ppp=0, sl=0, wlan=0, net=0, wlen=0;

    /*

     * Ask the IP Helper library to enumerate the adapters

     */

    size = sizeof(MIB_IFTABLE);

    tableP = (MIB_IFTABLE *)malloc(size);

    ret = GetIfTable(tableP, &size, TRUE);

    if (ret == ERROR_INSUFFICIENT_BUFFER || ret == ERROR_BUFFER_OVERFLOW) {

        tableP = (MIB_IFTABLE *)realloc(tableP, size);

        ret = GetIfTable(tableP, &size, TRUE);

    }

    if (ret != NO_ERROR) {

        if (tableP != NULL)

            free(tableP);

        JNU_ThrowByName(env, "java/lang/Error",

                "IP Helper Library GetIfTable function failed");

        return -1;

    }

    /*

     * Iterate through the list of adapters

     */

    count = 0;

    netifP = NULL;

    ifrowP = tableP->table;

    for (i=0; i<tableP->dwNumEntries; i++) {

        char dev_name[8];

        netif *curr;

        /*

         * Generate a name for the device as Windows doesn't have any

         * real concept of a device name.

         */

        switch (ifrowP->dwType) {

            case MIB_IF_TYPE_ETHERNET:

                _snprintf_s(dev_name, 8, _TRUNCATE, "eth%d", eth++);

                break;

            case MIB_IF_TYPE_TOKENRING:

                _snprintf_s(dev_name, 8, _TRUNCATE, "tr%d", tr++);

                break;

            case MIB_IF_TYPE_FDDI:

                _snprintf_s(dev_name, 8, _TRUNCATE, "fddi%d", fddi++);

                break;

            case MIB_IF_TYPE_LOOPBACK:

                /* There should only be only IPv4 loopback address */

                if (lo > 0) {

                    continue;

                }

                strncpy_s(dev_name, 8, "lo", _TRUNCATE);

                lo++;

                break;

            case MIB_IF_TYPE_PPP:

                _snprintf_s(dev_name, 8, _TRUNCATE, "ppp%d", ppp++);

                break;

            case MIB_IF_TYPE_SLIP:

                _snprintf_s(dev_name, 8, _TRUNCATE, "sl%d", sl++);

                break;

            case IF_TYPE_IEEE80211:

                _snprintf_s(dev_name, 8, _TRUNCATE, "wlan%d", wlan++);

                break;

            default:

                _snprintf_s(dev_name, 8, _TRUNCATE, "net%d", net++);

        }

        /*

         * Allocate a netif structure and space for the name and

         * display name (description in this case).

         */

        curr = (netif *)calloc(1, sizeof(netif));

        if (curr != NULL) {

            wlen = MultiByteToWideChar(CP_OEMCP, 0, ifrowP->bDescr,

                       ifrowP->dwDescrLen, NULL, 0);

            if(wlen == 0) {

                // MultiByteToWideChar should not fail

                // But in rare case it fails, we allow 'char' to be displayed

                curr->displayName = (char *)malloc(ifrowP->dwDescrLen + 1);

            } else {

                curr->displayName = (wchar_t *)malloc(wlen*(sizeof(wchar_t))+1);

            }

            curr->name = (char *)malloc(strlen(dev_name) + 1);

            if (curr->name == NULL || curr->displayName == NULL) {

                if (curr->name) free(curr->name);

                if (curr->displayName) free(curr->displayName);

                curr = NULL;

            }

        }

        if (curr == NULL) {

            JNU_ThrowOutOfMemoryError(env, "Native heap allocation failure");

            free_netif(netifP);

            free(tableP);

            return -1;

        }

        /*

         * Populate the interface. Note that we need to convert the

         * index into its "friendly" value as otherwise we will expose

         * 32-bit numbers as index values.

         */

        strcpy(curr->name, dev_name);

        if (wlen == 0) {

            // display char type in case of MultiByteToWideChar failure

            strncpy(curr->displayName, ifrowP->bDescr, ifrowP->dwDescrLen);

            curr->displayName[ifrowP->dwDescrLen] = '\0';

        } else {

            // call MultiByteToWideChar again to fill curr->displayName

            // it should not fail, because we have called it once before

            if (MultiByteToWideChar(CP_OEMCP, 0, ifrowP->bDescr,

                   ifrowP->dwDescrLen, curr->displayName, wlen) == 0) {

                JNU_ThrowByName(env, "java/lang/Error",

                       "Cannot get multibyte char for interface display name");

                free_netif(netifP);

                free(tableP);

                free(curr->name);

                free(curr->displayName);

                free(curr);

                return -1;

            } else {

                curr->displayName[wlen*(sizeof(wchar_t))] = '\0';

                curr->dNameIsUnicode = TRUE;

            }

        }

        curr->dwIndex = ifrowP->dwIndex;

        curr->ifType = ifrowP->dwType;

        curr->index = GetFriendlyIfIndex(ifrowP->dwIndex);

        /*

         * Put the interface at tail of list as GetIfTable(,,TRUE) is

         * returning the interfaces in index order.

         */

        count++;

        if (netifP == NULL) {

            netifP = curr;

        } else {

            netif *tail = netifP;

            while (tail->next != NULL) {

                tail = tail->next;

            }

            tail->next = curr;

        }

        /* onto the next interface */

        ifrowP++;

    }

    /*

     * Free the interface table and return the interface list

     */

    if (tableP) {

        free(tableP);

    }

    *netifPP = netifP;

    return count;

}

/*

 * Enumerate the IP addresses on an interface using the IP helper library

 * routine GetIfAddrTable and matching based on the index name. There are

 * more efficient routines but we use GetIfAddrTable because it's avaliable

 * on 98 and NT.

 *

 * Returns the count of addresses, or -1 if error. If no error occurs then

 * netaddrPP will return a list of netaddr structures with the IP addresses.

 */

int enumAddresses_win(JNIEnv *env, netif *netifP, netaddr **netaddrPP)

{

    MIB_IPADDRTABLE *tableP;

    ULONG size;

    DWORD ret;

    DWORD i;

    netaddr *netaddrP;

    int count = 0;

    unsigned long mask;

    /*

     * Use GetIpAddrTable to enumerate the IP Addresses

     */

    size = sizeof(MIB_IPADDRTABLE);

    tableP = (MIB_IPADDRTABLE *)malloc(size);

    ret = GetIpAddrTable(tableP, &size, FALSE);

    if (ret == ERROR_INSUFFICIENT_BUFFER || ret == ERROR_BUFFER_OVERFLOW) {

        tableP = (MIB_IPADDRTABLE *)realloc(tableP, size);

        ret = GetIpAddrTable(tableP, &size, FALSE);

    }

    if (ret != NO_ERROR) {

        if (tableP) {

            free(tableP);

        }

        JNU_ThrowByName(env, "java/lang/Error",

                "IP Helper Library GetIpAddrTable function failed");

        return -1;

    }

    /*

     * Iterate through the table to find the addresses with the

     * matching dwIndex. Ignore 0.0.0.0 addresses.

     */

    count = 0;

    netaddrP = NULL;

    i = 0;

    while (i<tableP->dwNumEntries) {

        if (tableP->table[i].dwIndex == netifP->dwIndex &&

            tableP->table[i].dwAddr != 0) {

            netaddr *curr = (netaddr *)malloc(sizeof(netaddr));

            if (curr == NULL) {

                JNU_ThrowOutOfMemoryError(env, "Native heap allocation failure");

                free_netaddr(netaddrP);

                free(tableP);

                return -1;

            }

            curr->addr.him4.sin_family = AF_INET;

            curr->addr.him4.sin_addr.s_addr = tableP->table[i].dwAddr;

            /*

             * Get netmask / broadcast address

             */

            switch (netifP->ifType) {

            case MIB_IF_TYPE_ETHERNET:

            case MIB_IF_TYPE_TOKENRING:

            case MIB_IF_TYPE_FDDI:

            case MIB_IF_TYPE_LOOPBACK:

            case IF_TYPE_IEEE80211:

              /**

               * Contrary to what it seems to indicate, dwBCastAddr doesn't

               * contain the broadcast address but 0 or 1 depending on whether

               * the broadcast address should set the bits of the host part

               * to 0 or 1.

               * Yes, I know it's stupid, but what can I say, it's MSFTs API.

               */

              curr->brdcast.him4.sin_family = AF_INET;

              if (tableP->table[i].dwBCastAddr == 1)

                curr->brdcast.him4.sin_addr.s_addr = (tableP->table[i].dwAddr & tableP->table[i].dwMask) | (0xffffffff ^ tableP->table[i].dwMask);

              else

                curr->brdcast.him4.sin_addr.s_addr = (tableP->table[i].dwAddr & tableP->table[i].dwMask);

              mask = ntohl(tableP->table[i].dwMask);

              curr->mask = 0;

              while (mask) {

                mask <<= 1;

                curr->mask++;

              }

              break;

            case MIB_IF_TYPE_PPP:

            case MIB_IF_TYPE_SLIP:

            default:

              /**

               * these don't have broadcast/subnet

               */

              curr->mask = -1;

                break;

            }

            curr->next = netaddrP;

            netaddrP = curr;

            count++;

        }

        i++;

    }

    *netaddrPP = netaddrP;

    free(tableP);

    return count;

}

/*

 * Class:     java_net_NetworkInterface

 * Method:    init

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_java_net_NetworkInterface_init(JNIEnv *env, jclass cls)

{

    /*

     * Get the various JNI ids that we require

     */

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

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

    ni_displayNameID = (*env)->GetFieldID(env, ni_class, "displayName", "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_childsID = (*env)->GetFieldID(env, ni_class, "childs", "[Ljava/net/NetworkInterface;");

    ni_ctor = (*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_ia4Ctor = (*env)->GetMethodID(env, ni_ia4cls, "<init>", "()V");

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

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

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

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

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

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

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

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

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

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

}

/*

 * Create a NetworkInterface object, populate the name and index, and

 * populate the InetAddress array based on the IP addresses for this

 * interface.

 */

jobject createNetworkInterface

    (JNIEnv *env, netif *ifs, int netaddrCount, netaddr *netaddrP)

{

    jobject netifObj;

    jobject name, displayName;

    jobjectArray addrArr, bindsArr, childArr;

    netaddr *addrs;

    jint addr_index;

    jint bind_index;

    /*

     * Create a NetworkInterface object and populate it

     */

    netifObj = (*env)->NewObject(env, ni_class, ni_ctor);

    name = (*env)->NewStringUTF(env, ifs->name);