GeoResolver.hpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0
 *
 * Risolve IP -> {country_code, lat, lon, city, asn} usando ip-api.com.
 * Ha:
 *   - Cache in-memory (IP -> risultato) con scadenza 24h
 *   - Rate-limiter client-side (ip-api.com permette 45 req/min in free tier)
 *   - Fallback silent se no network (non blocca la UI)
 *
 * L'implementazione usa un worker thread dedicato per non bloccare la UI:
 * la UI chiama resolve() che ritorna subito l'entry cache o std::nullopt;
 * se nullopt, mette l'IP in una coda di lookup e notifica via callback
 * quando la risoluzione completa.
 */
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <optional>
#include <queue>
#include <string>
#include <thread>
#include <unordered_map>
#include <unordered_set>
 
namespace bsc::ui_util {
 
struct GeoEntry {
    std::string country_code;   // "IT", "US", "DE", ...
    std::string country_name;   // "Italy", "United States", ...
    std::string city;
    std::string region;
    std::string isp;            // ISP name (es. "Telecom Italia")
    std::string asn;            // "AS12345"
    double      lat{0.0};
    double      lon{0.0};
    std::chrono::steady_clock::time_point fetched_at;
};
 
/**
 * 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.
 */
class GeoResolver {
public:
    using ResolvedCallback = std::function<void(const std::string& ip, const GeoEntry&)>;
 
    static GeoResolver& instance();
 
    GeoResolver(const GeoResolver&) = delete;
    GeoResolver& operator=(const GeoResolver&) = delete;
 
    /**
     * 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).
     */
    std::optional<GeoEntry> resolve(const std::string& ip);
 
    /**
     * 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.
     */
    std::optional<GeoEntry> resolve_self();
 
    /** Registra un callback per i risultati asincroni. Thread-safe. */
    void on_resolved(ResolvedCallback cb);
 
    /** Shutdown ordinato del worker thread. */
    void stop();
 
private:
    GeoResolver();
    ~GeoResolver();
 
    void worker_loop();
    std::optional<GeoEntry> fetch_from_ipapi(const std::string& ip);
    static bool is_private_ip(const std::string& ip);
 
    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_;
 
    // Rate limiter: max 40 req/min per stare sotto il limite di 45
    std::chrono::steady_clock::time_point        last_request_{};
};
 
} // namespace bsc::ui_util