/*

 * Copyright 2000-2005 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.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.

 */

/* IP helper library routines */

int (PASCAL FAR *GetIpAddrTable_fn)();

int (PASCAL FAR *GetIfTable_fn)();

int (PASCAL FAR *GetFriendlyIfIndex_fn)();

int (PASCAL FAR *GetAdaptersAddresses_fn)();

int (PASCAL FAR *GetAdaptersInfo_fn)();

int (PASCAL FAR *GetNumberOfInterfaces_fn)();

/* Enumeration routines */

typedef int (*EnumerateNetInterfaces)(JNIEnv *, netif **);

typedef int(*EnumerateNetAddresses)(JNIEnv *, netif *, netaddr **);

static EnumerateNetInterfaces enumInterfaces_fn;

static EnumerateNetAddresses enumAddresses_fn;

/* Windows 9x routines are external (not needed on 64-bit) */

#ifndef _WIN64

extern int enumInterfaces_win9x(JNIEnv *, netif **);

extern int enumAddresses_win9x(JNIEnv *, netif *, netaddr **);

extern int init_win9x(void);

#endif

/* Windows 95/98/ME running */

static jboolean isW9x;

/* Windows version supports */

static jboolean os_supports_ipv6;

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

jfieldID ni_iaAddr;         /* InetAddress.address */

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_fn)(tableP, &size, TRUE);

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

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

        count = (*GetIfTable_fn)(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_fn)(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_win(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, net=0;

    /*

     * Ask the IP Helper library to enumerate the adapters

     */

    size = sizeof(MIB_IFTABLE);

    tableP = (MIB_IFTABLE *)malloc(size);

    ret = (*GetIfTable_fn)(tableP, &size, TRUE);

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

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

        ret = (*GetIfTable_fn)(tableP, &size, TRUE);

    }

    if (ret != NO_ERROR) {

        if (tableP != NULL)

            free(tableP);

#ifndef _WIN64

        if (isW9x && ret == ERROR_NOT_SUPPORTED) {

            /*

             * If ERROR_NOT_SUPPORTED is returned on Windows 98 it means that

             * IE5.0 has been installed. In this case we revert to the Windows 95

             * approach and avoid using the IP Helper Library.

             * See: http://support.microsoft.com/support/kb/articles/q234/5/73.asp

             */

            enumInterfaces_fn = enumInterfaces_win9x;

            enumAddresses_fn = enumAddresses_win9x;

            init_win9x();

            return (*enumInterfaces_fn)(env, netifPP);

        }

#endif

        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:

                sprintf(dev_name, "eth%d", eth++);

                break;

            case MIB_IF_TYPE_TOKENRING:

                sprintf(dev_name, "tr%d", tr++);

                break;

            case MIB_IF_TYPE_FDDI:

                sprintf(dev_name, "fddi%d", fddi++);

                break;

            case MIB_IF_TYPE_LOOPBACK:

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

                if (lo > 0) {

                    continue;

                }

                strcpy(dev_name, "lo");

                lo++;

                break;

            case MIB_IF_TYPE_PPP:

                sprintf(dev_name, "ppp%d", ppp++);

                break;

            case MIB_IF_TYPE_SLIP:

                sprintf(dev_name, "sl%d", sl++);

                break;

            default:

                sprintf(dev_name, "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) {

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

            curr->displayName = (char *)malloc(ifrowP->dwDescrLen + 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, "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);

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

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

        curr->dwIndex = ifrowP->dwIndex;

        curr->ifType = ifrowP->dwType;

        curr->index = (*GetFriendlyIfIndex_fn)(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_fn)(&tableP, &size, FALSE);

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

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

        ret = (*GetIpAddrTable_fn)(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, "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:

              /**

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

{

    OSVERSIONINFO ver;

    HANDLE h;

    /*

     * First check if this is a Windows 9x machine.

     */

    ver.dwOSVersionInfoSize = sizeof(ver);

    GetVersionEx(&ver);

    if (ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && ver.dwMajorVersion == 4) {

        isW9x = JNI_TRUE;

    }

    /*

     * Try to load the IP Helper Library and obtain the entry points we

     * require. This will succeed on 98, NT SP4+, 2000 & XP. It will

     * fail on Windows 95 (if IE hasn't been updated) and old versions

     * of NT (IP helper library only appeared at SP4). If it fails on

     * Windows 9x we will use the registry approach, otherwise if it

     * fails we throw an Error indicating that we have an incompatible

     * IP helper library.

     */

    h = LoadLibrary("iphlpapi.dll");

    if (h != NULL) {

        GetIpAddrTable_fn =

            (int (PASCAL FAR *)())GetProcAddress(h, "GetIpAddrTable");

        GetIfTable_fn =

            (int (PASCAL FAR *)())GetProcAddress(h, "GetIfTable");

        GetFriendlyIfIndex_fn =

            (int (PASCAL FAR *)())GetProcAddress(h, "GetFriendlyIfIndex");

        GetNumberOfInterfaces_fn =

            (int (PASCAL FAR *)())GetProcAddress(h, "GetNumberOfInterfaces");

        GetAdaptersAddresses_fn =

            (int (PASCAL FAR *)())GetProcAddress(h, "GetAdaptersAddresses");

        GetAdaptersInfo_fn =

            (int (PASCAL FAR *)())GetProcAddress(h, "GetAdaptersInfo");

    }

    /* IPv6 is supported on Windows versions if the following APIs avail */

    os_supports_ipv6 = (GetAdaptersAddresses_fn != NULL) &&

                       (GetNumberOfInterfaces_fn != NULL) &&

                       (GetAdaptersInfo_fn != NULL);

    if (GetIpAddrTable_fn == NULL ||

        GetIfTable_fn == NULL ||

        GetFriendlyIfIndex_fn == NULL) {

#ifndef _WIN64

        if (isW9x) {