/*
 * Copyright 2010-2017, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _NETWORK_ADDRESS_RESOLVER_H
#define _NETWORK_ADDRESS_RESOLVER_H


#include <Locker.h>
#include <ObjectList.h>
#include <Referenceable.h>
#include <String.h>
#include <SupportDefs.h>


class BNetworkAddress;
struct addrinfo;


// flags for name resolution
enum {
        B_NO_ADDRESS_RESOLUTION                 = 0x0001,
        B_UNCONFIGURED_ADDRESS_FAMILIES = 0x0002,
};


class BNetworkAddressResolver: public BReferenceable {
public:
                                                                BNetworkAddressResolver();
                                                                BNetworkAddressResolver(const char* address,
                                                                        uint16 port = 0, uint32 flags = 0);
                                                                BNetworkAddressResolver(const char* address,
                                                                        const char* service, uint32 flags = 0);
                                                                BNetworkAddressResolver(int family,
                                                                        const char* address, uint16 port = 0,
                                                                        uint32 flags = 0);
                                                                BNetworkAddressResolver(int family,
                                                                        const char* address, const char* service,
                                                                        uint32 flags = 0);
                                                                ~BNetworkAddressResolver();

                        status_t                        InitCheck() const;

                        void                            Unset();

                        status_t                        SetTo(const char* address, uint16 port = 0,
                                                                        uint32 flags = 0);
                        status_t                        SetTo(const char* address, const char* service,
                                                                        uint32 flags = 0);
                        status_t                        SetTo(int family, const char* address,
                                                                        uint16 port = 0, uint32 flags = 0);
                        status_t                        SetTo(int family, const char* address,
                                                                        const char* service, uint32 flags = 0);

                        status_t                        GetNextAddress(uint32* cookie,
                                                                        BNetworkAddress& address) const;
                        status_t                        GetNextAddress(int family, uint32* cookie,
                                                                        BNetworkAddress& address) const;

        // TODO all the ::Resolve variants are needed. Maybe the SetTo and
        // constructors could be removed as ::Resolve is the right way to get a
        // resolver (using the cache).
        static  BReference<const BNetworkAddressResolver> Resolve(
                                                                        const char* address, const char* service,
                                                                        uint32 flags = 0);
        static  BReference<const BNetworkAddressResolver> Resolve(
                                                                        const char* address, uint16 port = 0,
                                                                        uint32 flags = 0);
        static  BReference<const BNetworkAddressResolver> Resolve(int family,
                                                                        const char* address, const char* service,
                                                                        uint32 flags = 0);
        static  BReference<const BNetworkAddressResolver> Resolve(int family,
                                                                        const char* address, uint16 port = 0,
                                                                        uint32 flags = 0);

private:
                        addrinfo*                       fInfo;
                        status_t                        fStatus;


        struct CacheEntry {
                CacheEntry(int family, const char* address, const char* service,
                        uint32 flags, BNetworkAddressResolver* resolver)
                        :
                        fFamily(family),
                        fAddress(address),
                        fService(service),
                        fFlags(flags),
                        fResolver(resolver, false)
                {
                }

                bool Matches(int family, BString address, BString service, uint32 flags)
                {
                        return family == fFamily && flags == fFlags && address == fAddress
                                && service == fService;
                }

                int fFamily;
                BString fAddress;
                BString fService;
                uint32 fFlags;

                BReference<const BNetworkAddressResolver> fResolver;
        };

        static  BLocker                                 sCacheLock;
        static  BObjectList<CacheEntry> sCacheMap;
};


#endif  // _NETWORK_ADDRESS_RESOLVER_H