#include <GeoResolver.hpp>

Public Types
using	ResolvedCallback = std::function<void(const std::string& ip, const GeoEntry&)>

Public Member Functions
	GeoResolver (const GeoResolver &)=delete
GeoResolver &	operator= (const GeoResolver &)=delete
std::optional< GeoEntry >	resolve (const std::string &ip)
std::optional< GeoEntry >	resolve_self ()
void	on_resolved (ResolvedCallback cb)
void	stop ()

Static Public Member Functions
static GeoResolver &	instance ()

Private Member Functions
	GeoResolver ()
	~GeoResolver ()
void	worker_loop ()
std::optional< GeoEntry >	fetch_from_ipapi (const std::string &ip)

Static Private Member Functions
static bool	is_private_ip (const std::string &ip)

Private Attributes
std::mutex	mu_
std::condition_variable	cv_
std::atomic_bool	running_ {true}
std::queue< std::string >	queue_
std::unordered_set< std::string >	in_flight_
std::unordered_map< std::string, GeoEntry >	cache_
std::vector< ResolvedCallback >	callbacks_
std::thread	worker_
std::chrono::steady_clock::time_point	last_request_ {}

Detailed Description

Service singleton che risolve IP -> GeoEntry. Ha un worker thread che processa una coda di lookup; la UI si iscrive via on_resolved(callback) per ricevere i risultati mano mano che arrivano.

Definition at line 51 of file GeoResolver.hpp.

Member Typedef Documentation

◆ ResolvedCallback

using bsc::ui_util::GeoResolver::ResolvedCallback = std::function<void(const std::string& ip, const GeoEntry&)>

Definition at line 53 of file GeoResolver.hpp.

Constructor & Destructor Documentation

◆ GeoResolver() [1/2]

bsc::ui_util::GeoResolver::GeoResolver ( const GeoResolver & )

delete

References GeoResolver().

Referenced by GeoResolver(), instance(), and operator=().

◆ GeoResolver() [2/2]

bsc::ui_util::GeoResolver::GeoResolver ( )

private

Definition at line 82 of file GeoResolver.cpp.

{
    worker_ = std::thread([this]() { worker_loop(); });
}

References worker_, and worker_loop().

◆ ~GeoResolver()

bsc::ui_util::GeoResolver::~GeoResolver ( )

private

Definition at line 87 of file GeoResolver.cpp.

87{ stop(); }

bsc::ui_util::GeoResolver::stop

void stop()

Definition GeoResolver.cpp:89

References stop().

Member Function Documentation

◆ fetch_from_ipapi()

std::optional< GeoEntry > bsc::ui_util::GeoResolver::fetch_from_ipapi ( const std::string & ip )

private

Definition at line 174 of file GeoResolver.cpp.

                                                                       {
    using namespace std::chrono;
    // Rate-limit
    const auto now = steady_clock::now();
    const auto since = now - last_request_;
    if (since < kMinInterval) std::this_thread::sleep_for(kMinInterval - since);
    last_request_ = steady_clock::now();
 
    // ip-api.com REST API (http, no TLS per semplicita' e perche' il
    // free tier e' comunque solo http)
    // Fields mask: https://ip-api.com/docs/api:json
    const std::string path = "/json/" + ip +
        "?fields=status,countryCode,country,regionName,city,lat,lon,isp,as";
 
    const auto body = http_get("ip-api.com", path, milliseconds(2000));
    if (body.empty()) return std::nullopt;
 
    try {
        auto j = nlohmann::json::parse(body);
        if (j.value("status", std::string{}) != "success") return std::nullopt;
 
        GeoEntry e;
        e.country_code = j.value("countryCode", std::string{});
        e.country_name = j.value("country",     std::string{});
        e.region       = j.value("regionName",  std::string{});
        e.city         = j.value("city",        std::string{});
        e.isp          = j.value("isp",         std::string{});
        e.asn          = j.value("as",          std::string{});
        e.lat          = j.value("lat", 0.0);
        e.lon          = j.value("lon", 0.0);
        e.fetched_at   = steady_clock::now();
        return e;
    } catch (...) {
        return std::nullopt;
    }
}

References bsc::ui_util::GeoEntry::asn, bsc::ui_util::GeoEntry::city, bsc::ui_util::GeoEntry::country_code, bsc::ui_util::GeoEntry::country_name, bsc::ui_util::GeoEntry::fetched_at, bsc::ui_util::GeoEntry::isp, last_request_, bsc::ui_util::GeoEntry::lat, bsc::ui_util::GeoEntry::lon, and bsc::ui_util::GeoEntry::region.

Referenced by operator=(), and worker_loop().

◆ instance()

GeoResolver & bsc::ui_util::GeoResolver::instance ( )

static

Definition at line 77 of file GeoResolver.cpp.

                                   {
    static GeoResolver inst;
    return inst;
}

References GeoResolver().

Referenced by NetworkPage::NetworkPage(), NetworkPage::noteConnection(), and NetworkPage::requestSelfLocation().

◆ is_private_ip()

bool bsc::ui_util::GeoResolver::is_private_ip ( const std::string & ip )

staticprivate

Definition at line 95 of file GeoResolver.cpp.

                                                   {
    if (ip.empty()) return true;
    // IPv4 privati: 10/8, 172.16/12, 192.168/16, 127/8, 169.254/16
    in_addr a4{};
    if (inet_pton(AF_INET, ip.c_str(), &a4) == 1) {
        const std::uint32_t h = ntohl(a4.s_addr);
        if ((h & 0xFF000000) == 0x0A000000) return true;  // 10.0.0.0/8
        if ((h & 0xFFF00000) == 0xAC100000) return true;  // 172.16.0.0/12
        if ((h & 0xFFFF0000) == 0xC0A80000) return true;  // 192.168.0.0/16
        if ((h & 0xFF000000) == 0x7F000000) return true;  // 127.0.0.0/8
        if ((h & 0xFFFF0000) == 0xA9FE0000) return true;  // 169.254/16
        return false;
    }
    // IPv6: fe80::/10 link-local, fc00::/7 ULA, ::1 loopback
    in6_addr a6{};
    if (inet_pton(AF_INET6, ip.c_str(), &a6) == 1) {
        if ((a6.s6_addr[0] & 0xFE) == 0xFC) return true;  // fc00::/7
        if (a6.s6_addr[0] == 0xFE && (a6.s6_addr[1] & 0xC0) == 0x80) return true;
        bool is_loopback = (a6.s6_addr[15] == 1);
        for (int i = 0; i < 15 && is_loopback; ++i)
            if (a6.s6_addr[i] != 0) is_loopback = false;
        if (is_loopback) return true;
    }
    return false;
}

References AF_INET, and AF_INET6.

Referenced by operator=(), and resolve().

◆ on_resolved()

void bsc::ui_util::GeoResolver::on_resolved ( ResolvedCallback cb )

Registra un callback per i risultati asincroni. Thread-safe.

Definition at line 169 of file GeoResolver.cpp.

                                                 {
    std::lock_guard lk(mu_);
    callbacks_.push_back(std::move(cb));
}

References callbacks_, and mu_.

Referenced by NetworkPage::NetworkPage(), and operator=().

◆ operator=()

GeoResolver & bsc::ui_util::GeoResolver::operator= ( const GeoResolver & )

delete

References fetch_from_ipapi(), GeoResolver(), is_private_ip(), on_resolved(), resolve(), resolve_self(), stop(), and worker_loop().

◆ resolve()

std::optional< GeoEntry > bsc::ui_util::GeoResolver::resolve ( const std::string & ip )

Se l'IP e' gia' in cache ritorna subito la GeoEntry. Altrimenti ritorna nullopt e mette l'IP in coda: il callback registrato via on_resolved sara' chiamato quando il lookup completa.

Gli IP privati/loopback/link-local non vengono mai risolti (ritorno un GeoEntry "locale" con country_code = "" e lat/lon = 0).

Definition at line 121 of file GeoResolver.cpp.

                                                              {
    if (ip.empty() || is_private_ip(ip)) {
        GeoEntry local;
        local.country_code = "";
        local.country_name = "Locale";
        local.fetched_at = std::chrono::steady_clock::now();
        return local;
    }
 
    const auto now = std::chrono::steady_clock::now();
    {
        std::lock_guard lk(mu_);
        auto it = cache_.find(ip);
        if (it != cache_.end()) {
            if (now - it->second.fetched_at < kCacheTtl) return it->second;
            cache_.erase(it);
        }
        if (in_flight_.count(ip)) return std::nullopt;  // gia' in coda
        in_flight_.insert(ip);
        queue_.push(ip);
    }
    cv_.notify_one();
    return std::nullopt;
}

References cache_, bsc::ui_util::GeoEntry::country_code, bsc::ui_util::GeoEntry::country_name, cv_, bsc::ui_util::GeoEntry::fetched_at, in_flight_, is_private_ip(), mu_, and queue_.

Referenced by operator=().

◆ resolve_self()

std::optional< GeoEntry > bsc::ui_util::GeoResolver::resolve_self ( )

Risolve l'IP pubblico del PC locale e la sua geolocalizzazione. Chiamando ip-api.com senza IP, il servizio geolocalizza il chiamante. Il risultato viene cached come qualsiasi altro IP, sotto la chiave speciale "__self__".

Ritorna subito la cache se presente, altrimenti mette in coda e ritorna nullopt. Il callback on_resolved() sara' chiamato con ip == "__self__" quando la risoluzione completa.

Definition at line 146 of file GeoResolver.cpp.

                                                {
    // Chiave speciale per la posizione del PC locale. Il worker
    // vedendo "__self__" in coda chiama fetch_from_ipapi("") — ip-api
    // interpreta la richiesta senza IP come "geolocalizza il chiamante"
    // dall'IP pubblico dal quale arriva la connessione.
    const std::string kSelfKey = "__self__";
 
    const auto now = std::chrono::steady_clock::now();
    {
        std::lock_guard lk(mu_);
        auto it = cache_.find(kSelfKey);
        if (it != cache_.end()) {
            if (now - it->second.fetched_at < kCacheTtl) return it->second;
            cache_.erase(it);
        }
        if (in_flight_.count(kSelfKey)) return std::nullopt;
        in_flight_.insert(kSelfKey);
        queue_.push(kSelfKey);
    }
    cv_.notify_one();
    return std::nullopt;
}

References cache_, cv_, in_flight_, mu_, and queue_.

Referenced by operator=().

◆ stop()

void bsc::ui_util::GeoResolver::stop ( )

Shutdown ordinato del worker thread.

Definition at line 89 of file GeoResolver.cpp.

                       {
    running_ = false;
    cv_.notify_all();
    if (worker_.joinable()) worker_.join();
}

References cv_, running_, and worker_.

Referenced by operator=(), and ~GeoResolver().

◆ worker_loop()

void bsc::ui_util::GeoResolver::worker_loop ( )

private

Definition at line 211 of file GeoResolver.cpp.

                              {
    while (running_) {
        std::string ip;
        {
            std::unique_lock lk(mu_);
            cv_.wait(lk, [this]() { return !running_ || !queue_.empty(); });
            if (!running_) return;
            ip = queue_.front();
            queue_.pop();
        }
 
        // "__self__" = richiesta speciale per il PC locale: si chiama
        // ip-api.com senza specificare IP, il servizio geolocalizza il
        // chiamante dall'IP sorgente della richiesta HTTP.
        const bool is_self = (ip == "__self__");
        auto maybe = fetch_from_ipapi(is_self ? std::string{} : ip);
 
        std::vector<ResolvedCallback> cbs_snapshot;
        GeoEntry entry;
        bool have_entry = false;
 
        {
            std::lock_guard lk(mu_);
            in_flight_.erase(ip);
            if (maybe) {
                cache_[ip] = *maybe;
                entry = *maybe;
                have_entry = true;
            }
            cbs_snapshot = callbacks_;
        }
 
        if (have_entry) {
            for (auto& cb : cbs_snapshot) {
                try { cb(ip, entry); } catch (...) {}
            }
        }
    }
}

References cache_, callbacks_, cv_, fetch_from_ipapi(), in_flight_, mu_, queue_, and running_.

Referenced by GeoResolver(), and operator=().

Member Data Documentation

◆ cache_

std::unordered_map<std::string, GeoEntry> bsc::ui_util::GeoResolver::cache_

private

Definition at line 101 of file GeoResolver.hpp.

Referenced by resolve(), resolve_self(), and worker_loop().

◆ callbacks_

std::vector<ResolvedCallback> bsc::ui_util::GeoResolver::callbacks_

private

Definition at line 102 of file GeoResolver.hpp.

Referenced by on_resolved(), and worker_loop().

◆ cv_

std::condition_variable bsc::ui_util::GeoResolver::cv_

private

Definition at line 97 of file GeoResolver.hpp.

Referenced by resolve(), resolve_self(), stop(), and worker_loop().

◆ in_flight_

std::unordered_set<std::string> bsc::ui_util::GeoResolver::in_flight_

private

Definition at line 100 of file GeoResolver.hpp.

Referenced by resolve(), resolve_self(), and worker_loop().

◆ last_request_

std::chrono::steady_clock::time_point bsc::ui_util::GeoResolver::last_request_ {}

private

Definition at line 106 of file GeoResolver.hpp.

Referenced by fetch_from_ipapi().

◆ mu_

std::mutex bsc::ui_util::GeoResolver::mu_

private

Definition at line 96 of file GeoResolver.hpp.

Referenced by on_resolved(), resolve(), resolve_self(), and worker_loop().

◆ queue_

std::queue<std::string> bsc::ui_util::GeoResolver::queue_

private

Definition at line 99 of file GeoResolver.hpp.

Referenced by resolve(), resolve_self(), and worker_loop().

◆ running_

std::atomic_bool bsc::ui_util::GeoResolver::running_ {true}

private

Definition at line 98 of file GeoResolver.hpp.

Referenced by stop(), and worker_loop().

◆ worker_

std::thread bsc::ui_util::GeoResolver::worker_

private

Definition at line 103 of file GeoResolver.hpp.

Referenced by GeoResolver(), and stop().

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

BastionGuard/thirdparty/bastionguard-secure-connection/ui/src/util/GeoResolver.hpp
BastionGuard/thirdparty/bastionguard-secure-connection/ui/src/util/GeoResolver.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ResolvedCallback

Constructor & Destructor Documentation

◆ GeoResolver() [1/2]

◆ GeoResolver() [2/2]

◆ ~GeoResolver()

Member Function Documentation

◆ fetch_from_ipapi()

◆ instance()

◆ is_private_ip()

◆ on_resolved()

◆ operator=()

◆ resolve()

◆ resolve_self()

◆ stop()

◆ worker_loop()

Member Data Documentation

◆ cache_

◆ callbacks_

◆ cv_

◆ in_flight_

◆ last_request_

◆ mu_

◆ queue_

◆ running_

◆ worker_