AsyncDNSResolver Class Reference

#include <async_dns_resolver.hpp>

Classes
struct	Entry

Public Member Functions
std::future< std::string >	resolve_async (const std::string &host)
std::string	resolve_cached (const std::string &host)

Static Public Member Functions
static AsyncDNSResolver &	instance ()

Private Member Functions
	AsyncDNSResolver ()=default

Static Private Member Functions
static uint64_t	now_ms ()

Private Attributes
std::unordered_map< std::string, Entry >	cache_
std::unordered_map< std::string, std::shared_ptr< std::promise< std::string > > >	pending_
std::mutex	mutex_

Static Private Attributes
static constexpr uint64_t	TTL_MS = 5 * 60 * 1000

Detailed Description

Definition at line 31 of file async_dns_resolver.hpp.

Constructor & Destructor Documentation

AsyncDNSResolver()

AsyncDNSResolver::AsyncDNSResolver ( )

privatedefault

Referenced by instance().

Member Function Documentation

instance()

AsyncDNSResolver & AsyncDNSResolver::instance ( )

inlinestatic

Definition at line 33 of file async_dns_resolver.hpp.

                                        {
        static AsyncDNSResolver inst;
        return inst;
    }

References AsyncDNSResolver().

Referenced by WebProbe::check_url().

now_ms()

uint64_t AsyncDNSResolver::now_ms ( )

inlinestaticprivate

Definition at line 99 of file async_dns_resolver.hpp.

                             {
        using namespace std::chrono;
        return duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
    }

Referenced by resolve_async(), and resolve_cached().

resolve_async()

std::future< std::string > AsyncDNSResolver::resolve_async ( const std::string & host )

inline

Definition at line 38 of file async_dns_resolver.hpp.

                                                              {
        {
            std::lock_guard<std::mutex> lk(mutex_);
            auto itc = cache_.find(host);
            if (itc != cache_.end() && now_ms() < itc->second.expires) {
                std::promise<std::string> p;
                p.set_value(itc->second.ip);
                return p.get_future();
            }
            auto itp = pending_.find(host);
            if (itp != pending_.end()) {
                return itp->second->get_future();
            }
        }
 
        auto prom = std::make_shared<std::promise<std::string>>();
        {
            std::lock_guard<std::mutex> lk(mutex_);
            pending_[host] = prom;
        }
 
        std::thread([this, host, prom]() {
            std::string ip;
            struct addrinfo hints{}, *res = nullptr;
            hints.ai_family = AF_INET;
            hints.ai_socktype = SOCK_STREAM;
            int rc = getaddrinfo(host.c_str(), nullptr, &hints, &res);
            if (rc == 0 && res) {
                char buf[INET_ADDRSTRLEN] = {0};
                if (res->ai_family == AF_INET) {
                    auto *a = reinterpret_cast<struct sockaddr_in*>(res->ai_addr);
                    inet_ntop(AF_INET, &a->sin_addr, buf, sizeof(buf));
                    ip = buf;
                }
                freeaddrinfo(res);
            }
            {
                std::lock_guard<std::mutex> lk(mutex_);
                cache_[host] = { ip, now_ms() + TTL_MS };
                pending_.erase(host);
            }
            prom->set_value(ip);
        }).detach();
 
        return prom->get_future();
    }

References AF_INET, cache_, mutex_, now_ms(), pending_, and TTL_MS.

resolve_cached()

std::string AsyncDNSResolver::resolve_cached ( const std::string & host )

inline

Definition at line 85 of file async_dns_resolver.hpp.

                                                    {
        std::lock_guard<std::mutex> lk(mutex_);
        auto it = cache_.find(host);
        if (it != cache_.end() && now_ms() < it->second.expires) return it->second.ip;
        return {};
    }

References cache_, mutex_, and now_ms().

Referenced by WebProbe::check_url().

Member Data Documentation

cache_

std::unordered_map<std::string, Entry> AsyncDNSResolver::cache_

private

Definition at line 95 of file async_dns_resolver.hpp.

Referenced by resolve_async(), and resolve_cached().

mutex_

std::mutex AsyncDNSResolver::mutex_

private

Definition at line 97 of file async_dns_resolver.hpp.

Referenced by resolve_async(), and resolve_cached().

pending_

std::unordered_map<std::string, std::shared_ptr<std::promise<std::string> > > AsyncDNSResolver::pending_

private

Definition at line 96 of file async_dns_resolver.hpp.

Referenced by resolve_async().

TTL_MS

uint64_t AsyncDNSResolver::TTL_MS = 5 * 60 * 1000

staticconstexprprivate

Definition at line 94 of file async_dns_resolver.hpp.

Referenced by resolve_async().

---

The documentation for this class was generated from the following file:

• BastionGuard/src/phishing/async_dns_resolver.hpp