ConnectionsPage.hpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0 — BastionGuard™ is a trademark of Calogero Scarnà.
 */
 
#pragma once
#include <gtkmm.h>
#include <string>
#include <cstdint>
#include <vector>
#include <deque>
#include <unordered_map>
#include <chrono>
 
#include "../ipc/UIServer.hpp"
 
/*
 * ConnectionsPage v3 — vista stile Little Snitch
 * ================================================
 *
 * La pagina ha due stati navigabili, incapsulati in un Gtk::Stack:
 *
 *   [stato "apps"]    (default)
 *     Lista aggregata per applicazione. Una riga per app.
 *     Colonne: Applicazione | Connessioni | Dati stimati | Ultimo accesso
 *     Double-click o invio → passa allo stato "detail" filtrato su quell'app.
 *
 *   [stato "detail"]
 *     Lista dettagliata delle connessioni di UNA sola app.
 *     Pulsante ← Indietro in toolbar → torna a "apps".
 *     Stesse colonne della v2: Ora | Applicazione | Esito | # | PID | ...
 *
 * In basso, sempre visibile: sparkline del throughput STIMATO degli ultimi
 * 60 secondi. La stima si basa su un costo byte fisso per connessione
 * (kEstimatedBytesPerConn) — volutamente approssimativa, comunicata come
 * "stima" nell'etichetta del grafico.
 */
 
class ConnectionsPage : public Gtk::Box
{
public:
    explicit ConnectionsPage(UIServer& uiServer);
    ~ConnectionsPage() override;
 
    /** Aggiunge una riga con tutti i dati eBPF.
     *  Se esiste gia' una riga con stesso (app, host/ip, port, proto)
     *  incrementa il contatore invece di creare un duplicato.
     *  Aggiorna anche i contatori aggregati per-app e lo sparkline. */
    void onNewConnection(const ConnectionInfo& info, bool pending = true);
 
    /** Aggiorna il verdetto dell'ultima riga pending. */
    void setLastVerdict(const std::string& verdict);
 
    void saveLog() const;
    void loadLog();
    void clearLog();
    static std::string logPath();
 
    // Stima: ogni connessione pesa mediamente ~4 KB (handshake + piccolo
    // scambio dati tipico per web/DNS/metriche). E' volutamente conservativa:
    // i trasferimenti pesanti (video, download) sono l'eccezione e non
    // intendiamo stimarli qui — per i valori reali servirebbe eBPF
    // tcp_sendmsg/udp_sendmsg con accumulo byte, esplicitamente scartato
    // dall'utente (leggerezza > precisione).
    static constexpr uint64_t kEstimatedBytesPerConn = 4096;
 
private:
    // ── Colonne vista "Connessioni dettagliate" ────────────────────────
    struct DetailColumns : public Gtk::TreeModel::ColumnRecord {
        DetailColumns() {
            add(col_time);
            add(col_app);
            add(col_verdict);
            add(col_count);
            add(col_pid);
            add(col_protocol);
            add(col_src_ip);
            add(col_host);
            add(col_ip);
            add(col_port);
            add(col_args);
            add(col_pending);
            add(col_group_key);
        }
        Gtk::TreeModelColumn<Glib::ustring> col_time;
        Gtk::TreeModelColumn<Glib::ustring> col_app;
        Gtk::TreeModelColumn<Glib::ustring> col_verdict;
        Gtk::TreeModelColumn<uint32_t>      col_count;
        Gtk::TreeModelColumn<uint32_t>      col_pid;
        Gtk::TreeModelColumn<Glib::ustring> col_protocol;
        Gtk::TreeModelColumn<Glib::ustring> col_src_ip;
        Gtk::TreeModelColumn<Glib::ustring> col_host;
        Gtk::TreeModelColumn<Glib::ustring> col_ip;
        Gtk::TreeModelColumn<uint32_t>      col_port;
        Gtk::TreeModelColumn<Glib::ustring> col_args;
        Gtk::TreeModelColumn<bool>          col_pending;
        Gtk::TreeModelColumn<Glib::ustring> col_group_key;
    };
 
    // ── Colonne vista "App aggregate" ──────────────────────────────────
    struct AppColumns : public Gtk::TreeModel::ColumnRecord {
        AppColumns() {
            add(col_icon_name);   // icona da tema ("firefox", "application-x-executable")
            add(col_app);
            add(col_conn_count);
            add(col_bytes_str);   // "1.2 MB" formattato
            add(col_bytes_raw);   // byte grezzi per sort
            add(col_last_seen);
            add(col_last_ts);     // epoch sec per sort
        }
        Gtk::TreeModelColumn<Glib::ustring> col_icon_name;
        Gtk::TreeModelColumn<Glib::ustring> col_app;
        Gtk::TreeModelColumn<uint32_t>      col_conn_count;
        Gtk::TreeModelColumn<Glib::ustring> col_bytes_str;
        Gtk::TreeModelColumn<uint64_t>      col_bytes_raw;
        Gtk::TreeModelColumn<Glib::ustring> col_last_seen;
        Gtk::TreeModelColumn<int64_t>       col_last_ts;
    };
 
    struct ComboCol : public Gtk::TreeModel::ColumnRecord {
        ComboCol() { add(val); }
        Gtk::TreeModelColumn<Glib::ustring> val;
    };
 
    // ── Stato aggregato per-app ────────────────────────────────────────
    struct AppStats {
        uint32_t conn_count     = 0;
        uint64_t estimated_bytes = 0;
        int64_t  last_seen_epoch = 0;  // per sort / display
    };
 
    // ── Evento detail salvato nel ring buffer per-app ──────────────────
    // Usato per persistere gli ultimi 500 eventi detail per ciascuna app:
    // al secondo avvio, aprendo un'app si vede lo storico fino al limite
    // invece della lista vuota. Struttura pensata per essere serializzata
    // direttamente in JSONL.
    struct DetailEvent {
        std::string time;        // "HH:MM:SS" quando e' arrivato
        int64_t     ts_epoch{0}; // per retention 7 giorni
        uint32_t    pid{0};
        std::string protocol;
        std::string src_ip;
        std::string host;
        std::string ip;
        uint32_t    port{0};
        std::string args;
        std::string verdict;     // "✅ Consentito...", "❌ Negato..." o ""
        bool        pending{false};
        uint32_t    count{1};    // repetizioni dedup
    };
 
    static constexpr size_t kDetailRingMax = 500;
    // app_display → coda FIFO degli ultimi kDetailRingMax eventi.
    // Niente mutex: tutto nel main thread GTK.
    std::unordered_map<std::string, std::deque<DetailEvent>> m_detailRings;
 
    // Retention log: eventi/aggregati piu' vecchi di 7 giorni scartati
    // al loadLog(). Nessun cleanup periodico: se l'app sta aperta 10
    // giorni di fila il file semplicemente cresce — saveLog() lo
    // riscrive ogni volta, quindi ridimensiona naturalmente.
    static constexpr int64_t kRetentionSeconds = 7 * 24 * 3600;
 
    // ── Campione sparkline ─────────────────────────────────────────────
    //   Ogni tick (500 ms) salviamo un bucket con i byte stimati generati
    //   nell'intervallo. 120 bucket da 500ms = 60 secondi di storia.
    static constexpr int      kSparkBucketMs   = 500;
    static constexpr int      kSparkBucketsMax = 120;
    std::deque<uint64_t>      m_sparkBuckets;   // byte per bucket (piu' vecchio in front)
    uint64_t                  m_currentBucket = 0;
    sigc::connection          m_sparkTick;
 
    // ── UI ─────────────────────────────────────────────────────────────
    DetailColumns                    m_columns;
    AppColumns                       m_appColumns;
    ComboCol                         m_comboCol;
    Glib::RefPtr<Gtk::ListStore>     m_verdictModel;
    Glib::RefPtr<Gtk::ListStore>     m_store;         // detail
    Glib::RefPtr<Gtk::ListStore>     m_appStore;      // apps aggregate
    Gtk::TreeView                    m_treeView;      // detail
    Gtk::TreeView                    m_appTreeView;   // apps
    Gtk::ScrolledWindow              m_scroll;
    Gtk::ScrolledWindow              m_appScroll;
 
    // Stack: due pagine ("apps" / "detail")
    Gtk::Stack                       m_stack;
 
    // Toolbar superiore (filtro + pulsanti)
    Gtk::Box                         m_toolbar  { Gtk::Orientation::HORIZONTAL, 6 };
    Gtk::Button                      m_clearBtn;
    Gtk::Button                      m_backBtn;          // <- Indietro (visibile solo in detail)
    Gtk::Label                       m_detailTitle;      // "Connessioni di <app>"
    Gtk::SearchEntry                 m_search;
 
    // Sparkline area
    Gtk::Frame                       m_sparkFrame;
    Gtk::Box                         m_sparkBox { Gtk::Orientation::VERTICAL, 4 };
    Gtk::Label                       m_sparkLabel;
    Gtk::DrawingArea                 m_sparkArea;
 
    // Indice rapido chiave di gruppo → iteratore della riga detail.
    std::unordered_map<std::string, Gtk::TreeModel::iterator> m_groupIndex;
 
    // Indice app → statistiche aggregate + iteratore nella lista apps
    std::unordered_map<std::string, AppStats>                  m_appStats;
    std::unordered_map<std::string, Gtk::TreeModel::iterator>  m_appIndex;
 
    // Quando siamo nella vista "detail", teniamo traccia dell'app filtrata:
    // le connessioni di altre app NON vengono aggiunte al m_store corrente
    // (restano comunque contate negli aggregati e nello sparkline).
    std::string                      m_currentAppFilter;
 
    // Cache app_display → icon-name (evita di ricostruire il lookup ad
    // ogni connessione). Popolata da resolveIconName().
    std::unordered_map<std::string, std::string> m_iconCache;
 
    // Indice comm/exec lowercase → icon-name dal sistema. Popolato una
    // sola volta al primo bisogno (costruirlo richiede di scandire tutti
    // i .desktop installati — ~100 ms).
    std::unordered_map<std::string, std::string> m_desktopIndex;
    bool                                         m_desktopIndexBuilt = false;
 
    UIServer& m_uiServer;
 
    void buildVerdictModel();
    void buildToolbar();
    void buildAppTreeView();
    void buildDetailTreeView();
    void buildSparkline();
 
    // Naviga tra vista apps e vista detail
    void showAppsView();
    void showDetailView(const std::string& app);
 
    void onAppActivated(const Gtk::TreeModel::Path& path,
                        Gtk::TreeViewColumn* column);
    void onBackClicked();
    void onVerdictEdited(const Glib::ustring& pathStr, const Glib::ustring& newText);
    void onClear();
 
    // Inserisce o aggiorna la riga detail — solo se l'app matcha il
    // filtro corrente (in vista detail). Ritorna true se ha aggiunto/
    // aggiornato qualcosa, false se ha solo aggiornato il contatore.
    void addOrUpdateDetailRow(const ConnectionInfo& info,
                              const std::string& app_display,
                              const std::string& argsStr,
                              bool pending);
 
    // Aggiorna i contatori aggregati per-app (la tabella apps)
    void updateAppAggregate(const std::string& app_display);
 
    // Push di un evento detail nel ring buffer dell'app indicata.
    // Enforce kDetailRingMax: se pieno, evinciamo il piu' vecchio.
    void pushDetailEvent(const std::string& app_display,
                         const DetailEvent& ev);
 
    // Popola m_store leggendo gli eventi dal ring buffer di un'app.
    // Usato quando l'utente entra in vista detail di un'app che ha
    // storico persistito dal precedente avvio.
    void populateDetailFromRing(const std::string& app_display);
 
    // Sparkline: callback timer (ogni kSparkBucketMs ms)
    bool onSparkTick();
    void onSparkDraw(const Cairo::RefPtr<Cairo::Context>& cr,
                     int width, int height);
 
    // Risolve un nome di processo (comm/path) in un icon-name del tema
    // GTK. Prima cerca tra i .desktop installati (via DesktopAppInfo),
    // poi prova il nome stesso come icon-name (molti pacchetti
    // installano icone dal nome identico al binario), infine fallback a
    // "application-x-executable". Risultato cached in m_iconCache.
    std::string resolveIconName(const std::string& app_display);
 
    // Costruisce l'indice comm/exec → icon-name scorrendo una sola
    // volta tutti i .desktop registrati nel sistema. Chiamato al primo
    // bisogno (lazy).
    void buildDesktopIndex();
 
    std::string currentTime();
    ReplyAction parseReplyAction(const Glib::ustring& text) const;
 
    // Calcola la chiave di dedup per una connessione (detail dedup).
    static std::string groupKeyFor(const std::string& app,
                                   const std::string& protocol,
                                   const std::string& host,
                                   const std::string& ip,
                                   uint32_t port);
 
    // Formatta byte grezzi in stringa umana: "42 B", "1.2 KB", "3.4 MB"
    static std::string formatBytes(uint64_t n);
 
    // Formatta un epoch in "HH:MM:SS" per la colonna "Ultimo accesso"
    static std::string formatEpochTime(int64_t epoch);
 
    // Helper log JSON
    static std::string jsonEscapeStr(const std::string& s);
    static std::string jsonFieldStr(const std::string& json, const std::string& key);
    static uint32_t    jsonFieldUint(const std::string& json, const std::string& key);
    static bool        jsonFieldBool(const std::string& json, const std::string& key);
};