GeoResolver.cpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0
 */
 
#include "GeoResolver.hpp"
 
#include <arpa/inet.h>
#include <cstring>
#include <netdb.h>
#include <nlohmann/json.hpp>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
 
namespace bsc::ui_util {
namespace {
 
// Cache TTL: 24h. Gli hosting providers cambiano rete molto raramente.
constexpr auto kCacheTtl = std::chrono::hours(24);
 
// Rate: 40 richieste al minuto -> 1500ms tra una e l'altra per stare sicuri.
// ip-api.com free tier permette 45/min; se superiamo il limite ci blocca per
// 1 ora.
constexpr auto kMinInterval = std::chrono::milliseconds(1500);
 
// HTTP request minima senza dipendenze: socket TCP + GET
std::string http_get(const std::string& host, const std::string& path,
                     std::chrono::milliseconds timeout)
{
    struct addrinfo hints{};
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    struct addrinfo* res = nullptr;
    if (getaddrinfo(host.c_str(), "80", &hints, &res) != 0 || !res) return {};
 
    int fd = ::socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    if (fd < 0) { freeaddrinfo(res); return {}; }
 
    // Timeout su recv/send
    struct timeval tv{};
    tv.tv_sec = timeout.count() / 1000;
    tv.tv_usec = (timeout.count() % 1000) * 1000;
    ::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    ::setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
 
    if (::connect(fd, res->ai_addr, res->ai_addrlen) < 0) {
        ::close(fd); freeaddrinfo(res); return {};
    }
    freeaddrinfo(res);
 
    std::string req = "GET " + path + " HTTP/1.0\r\n";
    req += "Host: " + host + "\r\n";
    req += "User-Agent: BastionGuard-SC/1.0\r\n";
    req += "Connection: close\r\n\r\n";
    if (::send(fd, req.data(), req.size(), 0) < 0) { ::close(fd); return {}; }
 
    std::string response;
    char buf[4096];
    while (true) {
        ssize_t n = ::recv(fd, buf, sizeof(buf), 0);
        if (n <= 0) break;
        response.append(buf, static_cast<size_t>(n));
        if (response.size() > 64 * 1024) break;  // antipattern abuse guard
    }
    ::close(fd);
 
    // Separa body dalle headers (\r\n\r\n)
    const auto sep = response.find("\r\n\r\n");
    if (sep == std::string::npos) return {};
    return response.substr(sep + 4);
}
 
} // namespace
 
GeoResolver& GeoResolver::instance() {
    static GeoResolver inst;
    return inst;
}
 
GeoResolver::GeoResolver()
{
    worker_ = std::thread([this]() { worker_loop(); });
}
 
GeoResolver::~GeoResolver() { stop(); }
 
void GeoResolver::stop() {
    running_ = false;
    cv_.notify_all();
    if (worker_.joinable()) worker_.join();
}
 
bool GeoResolver::is_private_ip(const std::string& ip) {
    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;
}
 
std::optional<GeoEntry> GeoResolver::resolve(const std::string& ip) {
    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;
}
 
std::optional<GeoEntry> GeoResolver::resolve_self() {
    // 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;
}
 
void GeoResolver::on_resolved(ResolvedCallback cb) {
    std::lock_guard lk(mu_);
    callbacks_.push_back(std::move(cb));
}
 
std::optional<GeoEntry> GeoResolver::fetch_from_ipapi(const std::string& ip) {
    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;
    }
}
 
void GeoResolver::worker_loop() {
    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 (...) {}
            }
        }
    }
}
 
} // namespace bsc::ui_util