/*

 * 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 <errno.h>

#include <sys/time.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <ifaddrs.h>

#include <net/if.h>

#endif

#include "net_util.h"

#include "java_net_Inet4AddressImpl.h"

#include "java_net_Inet6AddressImpl.h"

#include "java_net_InetAddress.h"

/* the initial size of our hostent buffers */

#ifndef NI_MAXHOST

#define NI_MAXHOST 1025

#endif

/************************************************************************

 * Inet6AddressImpl

 */

/*

 * Class:     java_net_Inet6AddressImpl

 * Method:    getLocalHostName

 * Signature: ()Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL

Java_java_net_Inet6AddressImpl_getLocalHostName(JNIEnv *env, jobject this) {

    int ret;

    char hostname[NI_MAXHOST+1];

    hostname[0] = '\0';

    ret = gethostname(hostname, NI_MAXHOST);

    if (ret == -1) {

        /* Something went wrong, maybe networking is not setup? */

        strcpy(hostname, "localhost");

    } else {

        // ensure null-terminated

        hostname[NI_MAXHOST] = '\0';

    }

#if defined(__solaris__) && defined(AF_INET6)

    if (ret == 0) {

        /* Solaris doesn't want to give us a fully qualified domain name.

         * We do a reverse lookup to try and get one.  This works

         * if DNS occurs before NIS in /etc/resolv.conf, but fails

         * if NIS comes first (it still gets only a partial name).

         * We use thread-safe system calls.

         */

        struct addrinfo  hints, *res;

        int error;

        memset(&hints, 0, sizeof(hints));

        hints.ai_flags = AI_CANONNAME;

        hints.ai_family = AF_UNSPEC;

        error = getaddrinfo(hostname, NULL, &hints, &res);

        if (error == 0) {

            /* host is known to name service */

            error = getnameinfo(res->ai_addr,

                                res->ai_addrlen,

                                hostname,

                                NI_MAXHOST,

                                NULL,

                                0,

                                NI_NAMEREQD);

            /* if getnameinfo fails hostname is still the value

               from gethostname */

            freeaddrinfo(res);

        }

    }

#endif

    return (*env)->NewStringUTF(env, hostname);

}

#ifdef MACOSX

/* also called from Inet4AddressImpl.c */

__private_extern__ jobjectArray

lookupIfLocalhost(JNIEnv *env, const char *hostname, jboolean includeV6)

{

    jobjectArray result = NULL;

    char myhostname[NI_MAXHOST+1];

    struct ifaddrs *ifa = NULL;

    int familyOrder = 0;

    int count = 0, i, j;

    int addrs4 = 0, addrs6 = 0, numV4Loopbacks = 0, numV6Loopbacks = 0;

    jboolean includeLoopback = JNI_FALSE;

    jobject name;

    initInetAddressIDs(env);

    JNU_CHECK_EXCEPTION_RETURN(env, NULL);

    /* If the requested name matches this host's hostname, return IP addresses

     * from all attached interfaces. (#2844683 et al) This prevents undesired

     * PPP dialup, but may return addresses that don't actually correspond to

     * the name (if the name actually matches something in DNS etc.

     */

    myhostname[0] = '\0';

    if (gethostname(myhostname, NI_MAXHOST) == -1) {

        /* Something went wrong, maybe networking is not setup? */

        return NULL;

    }

    myhostname[NI_MAXHOST] = '\0';

    if (strcmp(myhostname, hostname) != 0) {

        // Non-self lookup

        return NULL;

    }

    if (getifaddrs(&ifa) != 0) {

        NET_ThrowNew(env, errno, "Can't get local interface addresses");

        return NULL;

    }

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

    if (name == NULL) {

        freeifaddrs(ifa);

        return NULL;

    }

    /* Iterate over the interfaces, and total up the number of IPv4 and IPv6

     * addresses we have. Also keep a count of loopback addresses. We need to

     * exclude them in the normal case, but return them if we don't get an IP

     * address.

     */

    struct ifaddrs *iter = ifa;

    while (iter) {

        int family = iter->ifa_addr->sa_family;

        if (iter->ifa_name[0] != '\0'  &&  iter->ifa_addr)

        {

            jboolean isLoopback = iter->ifa_flags & IFF_LOOPBACK;

            if (family == AF_INET) {

                addrs4++;

                if (isLoopback) numV4Loopbacks++;

            } else if (family == AF_INET6 && includeV6) {

                addrs6++;

                if (isLoopback) numV6Loopbacks++;

            } else {

                /* We don't care e.g. AF_LINK */

            }

        }

        iter = iter->ifa_next;

    }

    if (addrs4 == numV4Loopbacks && addrs6 == numV6Loopbacks) {

        // We don't have a real IP address, just loopback. We need to include

        // loopback in our results.

        includeLoopback = JNI_TRUE;

    }

    /* Create and fill the Java array. */

    int arraySize = addrs4 + addrs6 -

        (includeLoopback ? 0 : (numV4Loopbacks + numV6Loopbacks));

    result = (*env)->NewObjectArray(env, arraySize, ia_class, NULL);

    if (!result) goto done;

    if ((*env)->GetStaticBooleanField(env, ia_class, ia_preferIPv6AddressID)) {

        i = includeLoopback ? addrs6 : (addrs6 - numV6Loopbacks);

        j = 0;

    } else {

        i = 0;

        j = includeLoopback ? addrs4 : (addrs4 - numV4Loopbacks);

    }

    // Now loop around the ifaddrs

    iter = ifa;

    while (iter != NULL) {

        jboolean isLoopback = iter->ifa_flags & IFF_LOOPBACK;

        int family = iter->ifa_addr->sa_family;

        if (iter->ifa_name[0] != '\0'  &&  iter->ifa_addr

            && (family == AF_INET || (family == AF_INET6 && includeV6))

            && (!isLoopback || includeLoopback))

        {

            int port;

            int index = (family == AF_INET) ? i++ : j++;

            jobject o = NET_SockaddrToInetAddress(env, iter->ifa_addr, &port);

            if (!o) {

                freeifaddrs(ifa);

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

                    JNU_ThrowOutOfMemoryError(env, "Object allocation failed");

                return NULL;

            }

            setInetAddress_hostName(env, o, name);

            (*env)->SetObjectArrayElement(env, result, index, o);

            (*env)->DeleteLocalRef(env, o);

        }

        iter = iter->ifa_next;

    }

  done:

    freeifaddrs(ifa);

    return result;

}

#endif

/*

 * Find an internet address for a given hostname.  Note that this

 * code only works for addresses of type INET. The translation

 * of %d.%d.%d.%d to an address (int) occurs in java now, so the

 * String "host" shouldn't *ever* be a %d.%d.%d.%d string

 *

 * Class:     java_net_Inet6AddressImpl

 * Method:    lookupAllHostAddr

 * Signature: (Ljava/lang/String;)[[B

 */

JNIEXPORT jobjectArray JNICALL

Java_java_net_Inet6AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this,

                                                jstring host) {

    const char *hostname;

    jobjectArray ret = 0;

    int retLen = 0;

    int getaddrinfo_error=0;

#ifdef AF_INET6

    struct addrinfo hints, *res, *resNew = NULL;

#endif /* AF_INET6 */

    initInetAddressIDs(env);

    JNU_CHECK_EXCEPTION_RETURN(env, NULL);

    if (IS_NULL(host)) {

        JNU_ThrowNullPointerException(env, "host is null");

        return 0;

    }

    hostname = JNU_GetStringPlatformChars(env, host, JNI_FALSE);

    CHECK_NULL_RETURN(hostname, NULL);

#ifdef AF_INET6

    /* Try once, with our static buffer. */

    memset(&hints, 0, sizeof(hints));

    hints.ai_flags = AI_CANONNAME;

    hints.ai_family = AF_UNSPEC;

#ifdef __solaris__

    /*

     * Workaround for Solaris bug 4160367 - if a hostname contains a

     * white space then 0.0.0.0 is returned

     */

    if (isspace((unsigned char)hostname[0])) {

        JNU_ThrowByName(env, JNU_JAVANETPKG "UnknownHostException",

                        hostname);

        JNU_ReleaseStringPlatformChars(env, host, hostname);

        return NULL;

    }

#endif

    getaddrinfo_error = getaddrinfo(hostname, NULL, &hints, &res);

#ifdef MACOSX

    if (getaddrinfo_error) {

        /*

         * If getaddrinfo fails looking up the local machine, attempt to get the

         * address from getifaddrs. This ensures we get an IPv6 address for the

         * local machine.

         */

        ret = lookupIfLocalhost(env, hostname, JNI_TRUE);

        if (ret != NULL || (*env)->ExceptionCheck(env)) {

            JNU_ReleaseStringPlatformChars(env, host, hostname);

            return ret;

        }

    }

#endif

    if (getaddrinfo_error) {

        /* report error */

        NET_ThrowUnknownHostExceptionWithGaiError(

            env, hostname, getaddrinfo_error);

        JNU_ReleaseStringPlatformChars(env, host, hostname);

        return NULL;

    } else {

        int i = 0, addressPreference = -1;

        int inetCount = 0, inet6Count = 0, inetIndex = 0, inet6Index = 0, originalIndex = 0;

        struct addrinfo *itr, *last = NULL, *iterator = res;

        while (iterator != NULL) {

            int skip = 0;

            itr = resNew;

            while (itr != NULL) {

                if (iterator->ai_family == itr->ai_family &&

                    iterator->ai_addrlen == itr->ai_addrlen) {

                    if (itr->ai_family == AF_INET) { /* AF_INET */

                        struct sockaddr_in *addr1, *addr2;

                        addr1 = (struct sockaddr_in *)iterator->ai_addr;

                        addr2 = (struct sockaddr_in *)itr->ai_addr;

                        if (addr1->sin_addr.s_addr ==

                            addr2->sin_addr.s_addr) {

                            skip = 1;

                            break;

                        }

                    } else {

                        int t;

                        struct sockaddr_in6 *addr1, *addr2;

                        addr1 = (struct sockaddr_in6 *)iterator->ai_addr;

                        addr2 = (struct sockaddr_in6 *)itr->ai_addr;

                        for (t = 0; t < 16; t++) {

                            if (addr1->sin6_addr.s6_addr[t] !=

                                addr2->sin6_addr.s6_addr[t]) {

                                break;

                            }

                        }

                        if (t < 16) {

                            itr = itr->ai_next;

                            continue;

                        } else {

                            skip = 1;

                            break;

                        }

                    }

                } else if (iterator->ai_family != AF_INET &&

                           iterator->ai_family != AF_INET6) {

                    /* we can't handle other family types */

                    skip = 1;

                    break;

                }

                itr = itr->ai_next;

            }

            if (!skip) {

                struct addrinfo *next

                    = (struct addrinfo*) malloc(sizeof(struct addrinfo));

                if (!next) {

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

                    ret = NULL;

                    goto cleanupAndReturn;

                }

                memcpy(next, iterator, sizeof(struct addrinfo));

                next->ai_next = NULL;

                if (resNew == NULL) {

                    resNew = next;

                } else {

                    last->ai_next = next;

                }

                last = next;

                i++;

                if (iterator->ai_family == AF_INET) {

                    inetCount ++;

                } else if (iterator->ai_family == AF_INET6) {

                    inet6Count ++;

                }

            }

            iterator = iterator->ai_next;

        }

        retLen = i;

        iterator = resNew;

        ret = (*env)->NewObjectArray(env, retLen, ia_class, NULL);

        if (IS_NULL(ret)) {

            /* we may have memory to free at the end of this */

            goto cleanupAndReturn;

        }

        addressPreference = (*env)->GetStaticIntField(env, ia_class, ia_preferIPv6AddressID);

        if (addressPreference == java_net_InetAddress_PREFER_IPV6_VALUE) {

            /* AF_INET addresses will be offset by inet6Count */

            inetIndex = inet6Count;

            inet6Index = 0;

        } else if (addressPreference == java_net_InetAddress_PREFER_IPV4_VALUE) {

            /* AF_INET6 addresses will be offset by inetCount */

            inetIndex = 0;

            inet6Index = inetCount;

        } else if (addressPreference == java_net_InetAddress_PREFER_SYSTEM_VALUE) {

            inetIndex = inet6Index = originalIndex = 0;

        }

        while (iterator != NULL) {

            jboolean ret1;

            if (iterator->ai_family == AF_INET) {

                jobject iaObj = (*env)->NewObject(env, ia4_class, ia4_ctrID);

                if (IS_NULL(iaObj)) {

                    ret = NULL;

                    goto cleanupAndReturn;

                }

                setInetAddress_addr(env, iaObj, ntohl(((struct sockaddr_in*)iterator->ai_addr)->sin_addr.s_addr));

                setInetAddress_hostName(env, iaObj, host);

                (*env)->SetObjectArrayElement(env, ret, (inetIndex | originalIndex), iaObj);

                inetIndex++;

            } else if (iterator->ai_family == AF_INET6) {

                jint scope = 0;

                jobject iaObj = (*env)->NewObject(env, ia6_class, ia6_ctrID);

                if (IS_NULL(iaObj)) {

                    ret = NULL;

                    goto cleanupAndReturn;

                }

                ret1 = setInet6Address_ipaddress(env, iaObj, (char *)&(((struct sockaddr_in6*)iterator->ai_addr)->sin6_addr));

                if (ret1 == JNI_FALSE) {

                    ret = NULL;

                    goto cleanupAndReturn;

                }

                scope = ((struct sockaddr_in6*)iterator->ai_addr)->sin6_scope_id;

                if (scope != 0) { /* zero is default value, no need to set */

                    setInet6Address_scopeid(env, iaObj, scope);

                }

                setInetAddress_hostName(env, iaObj, host);

                (*env)->SetObjectArrayElement(env, ret, (inet6Index | originalIndex), iaObj);

                inet6Index++;

            }

            if (addressPreference == java_net_InetAddress_PREFER_SYSTEM_VALUE) {

                originalIndex++;

                inetIndex = inet6Index = 0;

            }

            iterator = iterator->ai_next;

        }

    }

 cleanupAndReturn:

    {

      struct addrinfo *iterator, *tmp;

        iterator = resNew;

        while (iterator != NULL) {

            tmp = iterator;

            iterator = iterator->ai_next;

            free(tmp);

        }

        JNU_ReleaseStringPlatformChars(env, host, hostname);

    }

    freeaddrinfo(res);

#endif /* AF_INET6 */

    return ret;

}

/*

 * Class:     java_net_Inet6AddressImpl

 * Method:    getHostByAddr

 * Signature: (I)Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL

Java_java_net_Inet6AddressImpl_getHostByAddr(JNIEnv *env, jobject this,

                                            jbyteArray addrArray) {

    jstring ret = NULL;

#ifdef AF_INET6

    char host[NI_MAXHOST+1];

    int error = 0;

    int len = 0;

    jbyte caddr[16];

    struct sockaddr_in him4;

    struct sockaddr_in6 him6;

    struct sockaddr *sa;

    /*

     * For IPv4 addresses construct a sockaddr_in structure.

     */

    if ((*env)->GetArrayLength(env, addrArray) == 4) {

        jint addr;

        (*env)->GetByteArrayRegion(env, addrArray, 0, 4, caddr);

        addr = ((caddr[0]<<24) & 0xff000000);

        addr |= ((caddr[1] <<16) & 0xff0000);

        addr |= ((caddr[2] <<8) & 0xff00);

        addr |= (caddr[3] & 0xff);