/*
 * Copyright 2010-2011, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2015-2017, Adrien Destugues, pulkomandy@pulkomandy.tk.
 * Distributed under the terms of the MIT License.
 */


#include <NetworkAddressResolver.h>

#include <errno.h>
#include <netdb.h>

#include <Autolock.h>
#include <NetworkAddress.h>


static bool
strip_port(BString& host, BString& port)
{
        int32 first = host.FindFirst(':');
        int32 separator = host.FindLast(':');
        if (separator != first
                        && (separator == 0 || host.ByteAt(separator - 1) != ']')) {
                return false;
        }

        if (separator != -1) {
                // looks like there is a port
                host.CopyInto(port, separator + 1, -1);
                host.Truncate(separator);

                return true;
        }

        return false;
}


// #pragma mark -


BNetworkAddressResolver::BNetworkAddressResolver()
        :
        BReferenceable(),
        fInfo(NULL),
        fStatus(B_NO_INIT)
{
}


BNetworkAddressResolver::BNetworkAddressResolver(const char* address,
        uint16 port, uint32 flags)
        :
        BReferenceable(),
        fInfo(NULL),
        fStatus(B_NO_INIT)
{
        SetTo(address, port, flags);
}

BNetworkAddressResolver::BNetworkAddressResolver(const char* address,
        const char* service, uint32 flags)
        :
        BReferenceable(),
        fInfo(NULL),
        fStatus(B_NO_INIT)
{
        SetTo(address, service, flags);
}


BNetworkAddressResolver::BNetworkAddressResolver(int family,
        const char* address, uint16 port, uint32 flags)
        :
        BReferenceable(),
        fInfo(NULL),
        fStatus(B_NO_INIT)
{
        SetTo(family, address, port, flags);
}


BNetworkAddressResolver::BNetworkAddressResolver(int family,
        const char* address, const char* service, uint32 flags)
        :
        BReferenceable(),
        fInfo(NULL),
        fStatus(B_NO_INIT)
{
        SetTo(family, address, service, flags);
}


BNetworkAddressResolver::~BNetworkAddressResolver()
{
        Unset();
}


status_t
BNetworkAddressResolver::InitCheck() const
{
        return fStatus;
}


void
BNetworkAddressResolver::Unset()
{
        if (fInfo != NULL) {
                freeaddrinfo(fInfo);
                fInfo = NULL;
        }
        fStatus = B_NO_INIT;
}


status_t
BNetworkAddressResolver::SetTo(const char* address, uint16 port, uint32 flags)
{
        return SetTo(AF_UNSPEC, address, port, flags);
}


status_t
BNetworkAddressResolver::SetTo(const char* address, const char* service,
        uint32 flags)
{
        return SetTo(AF_UNSPEC, address, service, flags);
}


status_t
BNetworkAddressResolver::SetTo(int family, const char* address, uint16 port,
        uint32 flags)
{
        BString service;
        service << port;

        return SetTo(family, address, port != 0 ? service.String() : NULL, flags);
}


status_t
BNetworkAddressResolver::SetTo(int family, const char* host,
        const char* service, uint32 flags)
{
        Unset();

        // Check if the address contains a port

        BString hostString(host);

        BString portString;
        if (!strip_port(hostString, portString) && service != NULL)
                portString = service;

        // Resolve address

        addrinfo hint = {0};
        hint.ai_family = family;
        if ((flags & B_NO_ADDRESS_RESOLUTION) != 0)
                hint.ai_flags |= AI_NUMERICHOST;
        else if ((flags & B_UNCONFIGURED_ADDRESS_FAMILIES) == 0)
                hint.ai_flags |= AI_ADDRCONFIG;

        if (host == NULL && portString.Length() == 0) {
                portString = "0";
                hint.ai_flags |= AI_PASSIVE;
        }

        int status = getaddrinfo(host != NULL ? hostString.String() : NULL,
                portString.Length() != 0 ? portString.String() : NULL, &hint, &fInfo);
        if (status == 0)
                return fStatus = B_OK;

        // Map errors
        // TODO: improve error reporting, maybe add specific error codes?

        switch (status) {
                case EAI_ADDRFAMILY:
                case EAI_BADFLAGS:
                case EAI_PROTOCOL:
                case EAI_BADHINTS:
                case EAI_SOCKTYPE:
                case EAI_SERVICE:
                case EAI_NONAME:
                case EAI_FAMILY:
                        fStatus = B_BAD_VALUE;
                        break;

                case EAI_SYSTEM:
                        fStatus = errno;
                        break;

                case EAI_OVERFLOW:
                case EAI_MEMORY:
                        fStatus = B_NO_MEMORY;
                        break;

                case EAI_AGAIN:
                        // TODO: better error code to denote temporary failure?
                        fStatus = B_TIMED_OUT;
                        break;

                default:
                        fStatus = B_ERROR;
                        break;
        }

        return fStatus;
}


status_t
BNetworkAddressResolver::GetNextAddress(uint32* cookie,
        BNetworkAddress& address) const
{
        if (fStatus != B_OK)
                return fStatus;

        // Skip previous info entries

        addrinfo* info = fInfo;
        int32 first = *cookie;
        for (int32 index = 0; index < first && info != NULL; index++) {
                info = info->ai_next;
        }

        if (info == NULL)
                return B_BAD_VALUE;

        // Return current

        address.SetTo(*info->ai_addr, info->ai_addrlen);
        (*cookie)++;

        return B_OK;
}


status_t
BNetworkAddressResolver::GetNextAddress(int family, uint32* cookie,
        BNetworkAddress& address) const
{
        if (fStatus != B_OK)
                return fStatus;

        // Skip previous info entries, and those that have a non-matching family

        addrinfo* info = fInfo;
        int32 first = *cookie;
        for (int32 index = 0; index < first && info != NULL; index++)
                info = info->ai_next;

        while (info != NULL && info->ai_family != family)
                info = info->ai_next;

        if (info == NULL)
                return B_BAD_VALUE;

        // Return current

        address.SetTo(*info->ai_addr, info->ai_addrlen);
        (*cookie)++;

        return B_OK;
}


/*static*/ BReference<const BNetworkAddressResolver>
BNetworkAddressResolver::Resolve(const char* address, const char* service,
        uint32 flags)
{
        return Resolve(AF_UNSPEC, address, service, flags);
}


/*static*/ BReference<const BNetworkAddressResolver>
BNetworkAddressResolver::Resolve(const char* address, uint16 port, uint32 flags)
{
        return Resolve(AF_UNSPEC, address, port, flags);
}


/*static*/ BReference<const BNetworkAddressResolver>
BNetworkAddressResolver::Resolve(int family, const char* address,
        uint16 port, uint32 flags)
{
        BString service;
        service << port;

        return Resolve(family, address, port == 0 ? NULL : service.String(), flags);
}


/*static*/ BReference<const BNetworkAddressResolver>
BNetworkAddressResolver::Resolve(int family, const char* address,
        const char* service, uint32 flags)
{
        BAutolock locker(&sCacheLock);

        // TODO it may be faster to use an hash map to have faster lookup of the
        // cache. However, we also need to access the cache by LRU, and for that
        // a doubly-linked list is better. We should have these two share the same
        // items, so it's easy to remove the LRU from the map, or insert a new
        // item in both structures.
        for (int i = 0; i < sCacheMap.CountItems(); i++) {
                CacheEntry* entry = sCacheMap.ItemAt(i);
                if (entry->Matches(family, address, service, flags)) {
                        // This entry is now the MRU, move to end of list.
                        // TODO if the item is old (more than 1 minute), it should be
                        // dropped and a new request made.
                        sCacheMap.MoveItem(i, sCacheMap.CountItems());
                        return entry->fResolver;
                }
        }

        // Cache miss! Unlock the cache while we perform the costly address
        // resolution
        locker.Unlock();

        BNetworkAddressResolver* resolver = new(std::nothrow)
                BNetworkAddressResolver(family, address, service, flags);

        if (resolver != NULL && resolver->InitCheck() == B_OK) {
                CacheEntry* entry = new(std::nothrow) CacheEntry(family, address,
                        service, flags, resolver);

                locker.Lock();
                // TODO adjust capacity. Chrome uses 256 entries with a timeout of
                // 1 minute, IE uses 1000 entries with a timeout of 30 seconds.
                if (sCacheMap.CountItems() > 255)
                        delete sCacheMap.RemoveItemAt(0);

                if (entry)
                        sCacheMap.AddItem(entry, sCacheMap.CountItems());
        }

        return BReference<const BNetworkAddressResolver>(resolver, true);
}

BLocker BNetworkAddressResolver::sCacheLock("DNS cache");
BObjectList<BNetworkAddressResolver::CacheEntry>
        BNetworkAddressResolver::sCacheMap;