/*

 * 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 "net_util.h"

#include "NetworkInterface.h"

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

    if(tableP == NULL)

        return NULL;

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

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

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

        if (newTableP == NULL) {

            free(tableP);

            return NULL;

        }

        tableP = newTableP;

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

    }

    if (count != NO_ERROR) {

        free(tableP);

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

            if (ret == NULL) {

                free(tableP);

                return NULL;

            }

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

    if (tableP == NULL) {

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

        return -1;

    }

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

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

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

        if (newTableP == NULL) {

            free(tableP);

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

            return -1;

        }

        tableP = newTableP;

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

    }

    if (ret != NO_ERROR) {

        free(tableP);

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

                "IP Helper Library GetIfTable function failed");

        // this different error code is to handle the case when we call

        // GetIpAddrTable in pure IPv6 environment

        return -2;

    }

    /*

     * 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+1)*sizeof(wchar_t));

            }

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

                free(curr);

                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 {

                ((wchar_t *)curr->displayName)[wlen] = L'\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

     */

        free(tableP);

    }

    *netifPP = netifP;

    return count;

}

/*

 */

{

    MIB_IPADDRTABLE *tableP;

    ULONG size;

    DWORD ret;

    /*

     * Use GetIpAddrTable to enumerate the IP Addresses

     */

    size = sizeof(MIB_IPADDRTABLE);

    tableP = (MIB_IPADDRTABLE *)malloc(size);

    if (tableP == NULL) {

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

        return -1;

    }

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

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

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

        if (newTableP == NULL) {

            free(tableP);

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

            return -1;

        }

        tableP = newTableP;

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

    }

    if (ret != NO_ERROR) {

            free(tableP);

        }

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

                "IP Helper Library GetIpAddrTable function failed");

        // this different error code is to handle the case when we call

        // GetIpAddrTable in pure IPv6 environment

        return -2;

    }

    /*

     * Iterate through the table to find the addresses with the

     * matching dwIndex. Ignore 0.0.0.0 addresses.

     */

    count = 0;

    netaddrP = NULL;

    i = 0;

        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.sa4.sin_family = AF_INET;

            curr->addr.sa4.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:

            case MIB_IF_TYPE_PPP:

            case MIB_IF_TYPE_SLIP:

            default:

            }

            curr->next = netaddrP;

            netaddrP = curr;

            count++;

        }

        i++;

    }

    *netaddrPP = netaddrP;

    free(tableP);

    return count;

}