async_dns_resolver.hpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program 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 for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#pragma once
#include <string>
#include <unordered_map>
#include <future>
#include <mutex>
#include <thread>
#include <chrono>
#include <netdb.h>
#include <arpa/inet.h>
 
class AsyncDNSResolver {
public:
    static AsyncDNSResolver& instance() {
        static AsyncDNSResolver inst;
        return inst;
    }
 
    std::future<std::string> resolve_async(const std::string& host) {
        {
            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();
    }
 
    std::string resolve_cached(const std::string& host) {
        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 {};
    }
 
private:
    struct Entry { std::string ip; uint64_t expires; };
    static constexpr uint64_t TTL_MS = 5 * 60 * 1000;
    std::unordered_map<std::string, Entry> cache_;
    std::unordered_map<std::string, std::shared_ptr<std::promise<std::string>>> pending_;
    std::mutex mutex_;
 
    static uint64_t now_ms() {
        using namespace std::chrono;
        return duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
    }
    AsyncDNSResolver() = default;
};