NetworkPage.hpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0
 */
 
#pragma once
 
#include <gtkmm.h>
#include <shumate/shumate.h>
 
#include <chrono>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../ipc/UIServer.hpp"
#include "../util/GeoResolver.hpp"
 
/**
 * Pagina Rete.
 *
 * Mostra una mappa reale basata su libshumate/OpenStreetMap con un marker per
 * ogni IP contattato. La geolocalizzazione arriva da GeoResolver, mentre il
 * rendering geografico e l'allineamento li gestisce libshumate.
 */
class NetworkPage : public Gtk::Box
{
public:
    NetworkPage();
    ~NetworkPage() override;
 
    /** Registra una connessione per la mappa. */
    void noteConnection(const ConnectionInfo& info);
 
    /** Pulisci la visualizzazione. */
    void clear();
 
    /** Salva i pin su disco per retention 7 giorni. */
    void saveLog() const;
 
    /** Carica i pin da disco, scartando quelli piu' vecchi di 7 giorni. */
    void loadLog();
 
    /** Path del file persistente (JSONL). */
    static std::string logPath();
 
    /**
     * Disegna gli archi attivi dalla posizione locale verso ogni pin
     * attualmente aperto, piu' il puntino lampeggiante sul marker
     * destinazione. Chiamato dall'overlay DrawingArea — pubblico perche'
     * deve essere invocabile da una free function C-callback.
     */
    void drawConnectionArcs(cairo_t* cr, int width, int height);
 
private:
    struct Pin {
        std::string ip;
        std::string host;
        std::string app_name;
        std::string country_code;
        std::string country_name;
        std::string city;
        std::string isp;
        double lat{0.0};
        double lon{0.0};
        uint32_t hits{0};
        // Timestamp monotono: usato per animazioni/decisioni runtime
        std::chrono::steady_clock::time_point last_seen;
        // Epoch assoluto: usato per la retention 7 giorni e la persistenza
        int64_t last_seen_epoch{0};
        bool geo_resolved{false};
    };
 
    struct Columns : public Gtk::TreeModel::ColumnRecord {
        Columns()
        {
            add(col_country);
            add(col_city);
            add(col_ip);
            add(col_host);
            add(col_app);
            add(col_isp);
            add(col_hits);
        }
 
        Gtk::TreeModelColumn<Glib::ustring> col_country;
        Gtk::TreeModelColumn<Glib::ustring> col_city;
        Gtk::TreeModelColumn<Glib::ustring> col_ip;
        Gtk::TreeModelColumn<Glib::ustring> col_host;
        Gtk::TreeModelColumn<Glib::ustring> col_app;
        Gtk::TreeModelColumn<Glib::ustring> col_isp;
        Gtk::TreeModelColumn<uint32_t> col_hits;
    };
 
    Columns m_columns;
    Glib::RefPtr<Gtk::ListStore> m_store;
    Gtk::TreeView m_treeView;
    Gtk::ScrolledWindow m_scroll;
    Gtk::Box m_mapHost{Gtk::Orientation::VERTICAL, 0};
    Gtk::Label m_headerLabel;
    Gtk::Label m_summaryLabel;
    Gtk::Button m_clearBtn;
 
    // libshumate (C API) integrato dentro gtkmm
    GtkWidget* m_simpleMap{nullptr};
    ShumateViewport* m_viewport{nullptr};
    ShumateMarkerLayer* m_markerLayer{nullptr};
 
    // overlay e card hover
    GtkWidget* m_mapOverlay{nullptr};
    GtkWidget* m_hoverCard{nullptr};
    GtkWidget* m_hoverCardTitle{nullptr};
    GtkWidget* m_hoverCardBody{nullptr};
    guint m_hoverHideSource{0};
    std::chrono::steady_clock::time_point m_lastUserViewportInteraction{};
 
    // ── Origine PC locale + archi di connessione (stile Little Snitch) ──
    // m_selfLat/m_selfLon: posizione geografica del PC stesso, risolta
    // tramite GeoResolver::resolve_self() (chiamata ip-api senza IP).
    // Viene mostrata come marker blu fisso sulla mappa. Le linee sulla
    // overlay drawing area partono da qui verso ogni pin attivo.
    double m_selfLat{0.0};
    double m_selfLon{0.0};
    bool   m_selfResolved{false};
    GtkWidget* m_mapFxArea{nullptr};   // drawing area overlay usata per gli archi
 
    // Timer di animazione (pulse dei marker destinazione + redraw archi).
    // 60 Hz e' troppo per questo uso — 15 Hz (66 ms) e' piacevole e leggero.
    guint m_pulseTimerId{0};
    int   m_pulseFrame{0};
 
    // Retention log: pin piu' vecchi di 7 giorni vengono scartati al
    // loadLog(). Runtime: accumuliamo senza mai scartare pin "freschi".
    //
    // NOTA: niente piu' finestra "connessioni aperte": l'utente ha
    // chiesto di tenere TUTTI i pin visibili sulla mappa (non solo
    // quelli degli ultimi N secondi). Lo storico sparisce solo quando
    // davvero vecchio.
    static constexpr int64_t kRetentionSeconds = 7 * 24 * 3600;   // 7 giorni
 
    // Chiave = IP: pin aggregato
    mutable std::mutex m_mu;
    std::unordered_map<std::string, Pin> m_pins;
    std::unordered_map<std::string, Gtk::TreeModel::iterator> m_rows;
 
    // Dispatcher per callback geo resolve (worker -> UI thread)
    Glib::Dispatcher m_geoDispatcher;
    std::mutex m_pendingMu;
    std::vector<std::pair<std::string, bsc::ui_util::GeoEntry>> m_pendingGeo;
 
    void buildUI();
    void buildMapWidget();
    void rebuildMapMarkers();
    GtkWidget* createMarkerWidget(const Pin& pin);
    GtkWidget* createSelfMarkerWidget();
    GtkWidget* createHoverCard();
    void showHoverCard(const std::string& country_code,
                       const std::string& country_name,
                       const std::string& city,
                       const std::string& ip,
                       const std::string& host,
                       const std::string& app_name,
                       const std::string& isp,
                       uint32_t hits);
    void hideHoverCard();
    void maybeRecenterMap(const std::vector<Pin>& pins);
    void onGeoResolved();
    void updateSummary();
    void updateRow(const Pin& pin);
    void noteUserViewportInteraction();
    bool shouldHoldUserViewport() const;
 
    // Kicks off la risoluzione della posizione del PC locale (lazy,
    // non blocca). Al completamento rebuilda i marker per aggiungere
    // il punto blu di origine.
    void requestSelfLocation();
 
    // Redraw dell'overlay archi (chiamato dal pulse timer ~15 Hz).
    void triggerFxRedraw();
};