ConnectionsPage.cpp

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à.
 */
 
#include "ConnectionsPage.hpp"
#include "../util/AppResolver.hpp"
#include <glibmm/i18n.h>
#include <glibmm/datetime.h>
#include <gtkmm/cellrenderercombo.h>
#include <gtkmm/cellrendererpixbuf.h>
#include <gtkmm/cellrenderertext.h>
#include <giomm/appinfo.h>
#include <giomm/desktopappinfo.h>
#include <giomm/themedicon.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <filesystem>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#include <cctype>
#include <algorithm>
#include <unistd.h>
 
static const char* kVerdictOptions[] = {
    "allow once", "allow always", "deny once", "deny always", nullptr
};
 
// ---------------------------------------------------------------------------
// Costruttore
// ---------------------------------------------------------------------------
 
ConnectionsPage::ConnectionsPage(UIServer& uiServer)
: Gtk::Box(Gtk::Orientation::VERTICAL, 0)
, m_uiServer(uiServer)
{
    buildVerdictModel();
    buildToolbar();
    buildAppTreeView();
    buildDetailTreeView();
    buildSparkline();
 
    // Stack con due pagine. Default: apps.
    m_appScroll.set_child(m_appTreeView);
    m_appScroll.set_vexpand(true);
    m_scroll.set_child(m_treeView);
    m_scroll.set_vexpand(true);
 
    m_stack.add(m_appScroll, "apps",   _("Applicazioni"));
    m_stack.add(m_scroll,    "detail", _("Dettagli connessioni"));
    m_stack.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
    m_stack.set_transition_duration(220);
    m_stack.set_vexpand(true);
    m_stack.set_visible_child("apps");
 
    append(m_toolbar);
    append(m_stack);
    append(m_sparkFrame);
 
    // Al primo avvio siamo in apps → backBtn nascosto, detailTitle nascosto.
    showAppsView();
 
    // Avvia il timer dello sparkline
    m_sparkTick = Glib::signal_timeout().connect(
        sigc::mem_fun(*this, &ConnectionsPage::onSparkTick),
                                                 kSparkBucketMs);
}
 
ConnectionsPage::~ConnectionsPage()
{
    // Disconnetti il timer prima della distruzione: Glib::signal_timeout()
    // e' un source globale; se la pagina viene distrutta (es. cambio
    // finestra principale) il callback risulterebbe in use-after-free.
    m_sparkTick.disconnect();
}
 
void ConnectionsPage::buildVerdictModel()
{
    m_verdictModel = Gtk::ListStore::create(m_comboCol);
    for (int i = 0; kVerdictOptions[i]; ++i) {
        auto row = *m_verdictModel->append();
        row[m_comboCol.val] = kVerdictOptions[i];
    }
}
 
// ---------------------------------------------------------------------------
// Toolbar
// ---------------------------------------------------------------------------
 
void ConnectionsPage::buildToolbar()
{
    m_toolbar.set_margin_top(8);
    m_toolbar.set_margin_bottom(8);
    m_toolbar.set_margin_start(8);
    m_toolbar.set_margin_end(8);
 
    // Pulsante "Indietro" — visibile solo in vista detail
    m_backBtn.set_label("←");
    m_backBtn.set_tooltip_text(_("Torna all'elenco applicazioni"));
    m_backBtn.signal_clicked().connect(
        sigc::mem_fun(*this, &ConnectionsPage::onBackClicked));
    m_toolbar.append(m_backBtn);
 
    // Titolo centrale (visibile solo in detail)
    m_detailTitle.set_halign(Gtk::Align::START);
    m_detailTitle.set_valign(Gtk::Align::CENTER);
    m_detailTitle.get_style_context()->add_class("heading");
    m_toolbar.append(m_detailTitle);
 
    m_search.set_placeholder_text(_("Filtra per app o host..."));
    m_search.set_hexpand(true);
    m_toolbar.append(m_search);
 
    m_clearBtn.set_label(_("🗑 Pulisci"));
    m_clearBtn.signal_clicked().connect(
        sigc::mem_fun(*this, &ConnectionsPage::onClear));
    m_toolbar.append(m_clearBtn);
}
 
// ---------------------------------------------------------------------------
// Vista APP aggregata (stato default "apps")
// Colonne: Applicazione | Connessioni | Dati stimati | Ultimo accesso
// ---------------------------------------------------------------------------
 
void ConnectionsPage::buildAppTreeView()
{
    m_appStore = Gtk::ListStore::create(m_appColumns);
    m_appTreeView.set_model(m_appStore);
    m_appTreeView.get_style_context()->add_class("bsc-treeview");
    m_appTreeView.set_grid_lines(Gtk::TreeView::GridLines::HORIZONTAL);
 
    // ── Colonna "Applicazione": icona + testo ─────────────────────────
    // Composta da due renderer affiancati: CellRendererPixbuf (icona dal
    // tema) + CellRendererText (nome processo). Lookup dell'icona via
    // DesktopAppInfo — vedi resolveIconName().
    {
        auto* col      = Gtk::make_managed<Gtk::TreeViewColumn>(_("Applicazione"));
        auto* iconCell = Gtk::make_managed<Gtk::CellRendererPixbuf>();
        auto* textCell = Gtk::make_managed<Gtk::CellRendererText>();
 
        // Icona 24×24 — stessa scala usata da Nautilus/Files in lista.
        iconCell->property_icon_size() = Gtk::IconSize::NORMAL;
        iconCell->set_padding(2, 0);
        textCell->set_padding(4, 0);
 
        col->pack_start(*iconCell, /*expand=*/false);
        col->pack_start(*textCell, /*expand=*/true);
        col->add_attribute(iconCell->property_icon_name(), m_appColumns.col_icon_name);
        col->add_attribute(textCell->property_text(),      m_appColumns.col_app);
        col->set_sort_column(m_appColumns.col_app);
        m_appTreeView.append_column(*col);
    }
 
    m_appTreeView.append_column(_("Connessioni"),    m_appColumns.col_conn_count);
    m_appTreeView.append_column(_("Dati stimati"),   m_appColumns.col_bytes_str);
    m_appTreeView.append_column(_("Ultimo accesso"), m_appColumns.col_last_seen);
 
    // Larghezze minime
    const int minW[] = { 260, 110, 130, 130 };
    for (int i = 0; i < 4; ++i) {
        if (auto* c = m_appTreeView.get_column(i)) {
            c->set_min_width(minW[i]);
            c->set_resizable(true);
        }
    }
 
    // Rendi le colonne ordinabili con lo stesso campo "grezzo" quando serve.
    // Colonna "Connessioni": ordina direttamente sul uint32.
    if (auto* c = m_appTreeView.get_column(1)) {
        c->set_sort_column(m_appColumns.col_conn_count);
    }
    // Colonna "Dati stimati": ordina sul valore raw byte, non sulla stringa
    // formattata (altrimenti "900 KB" > "1.2 MB" perche' confronto lessicale).
    if (auto* c = m_appTreeView.get_column(2)) {
        c->set_sort_column(m_appColumns.col_bytes_raw);
    }
    // Colonna "Ultimo accesso": ordina su epoch, non su stringa HH:MM:SS.
    if (auto* c = m_appTreeView.get_column(3)) {
        c->set_sort_column(m_appColumns.col_last_ts);
    }
    // Sort iniziale: piu' recenti in cima.
    m_appStore->set_sort_column(m_appColumns.col_last_ts,
                                Gtk::SortType::DESCENDING);
 
    // Doppio click sull'app → entra nella vista detail filtrata.
    m_appTreeView.signal_row_activated().connect(
        sigc::mem_fun(*this, &ConnectionsPage::onAppActivated));
}
 
// ---------------------------------------------------------------------------
// Vista DETAIL — lista completa connessioni di UNA app
// Ordine colonne (v2): Ora | Applicazione | Esito | # | PID | Protocollo |
//                      IP Sorgente | Host | IP Dest. | Porta | Argomenti
// ---------------------------------------------------------------------------
 
void ConnectionsPage::buildDetailTreeView()
{
    m_store = Gtk::ListStore::create(m_columns);
    m_treeView.set_model(m_store);
    m_treeView.get_style_context()->add_class("bsc-treeview");
    m_treeView.set_grid_lines(Gtk::TreeView::GridLines::HORIZONTAL);
 
    m_treeView.append_column(_("Ora"),           m_columns.col_time);
    m_treeView.append_column(_("Applicazione"),  m_columns.col_app);
 
    // Colonna Esito — CellRendererCombo (subito dopo Applicazione)
    {
        auto* col  = Gtk::make_managed<Gtk::TreeViewColumn>(_("Esito"));
        auto* cell = Gtk::make_managed<Gtk::CellRendererCombo>();
        cell->property_model()       = m_verdictModel;
        cell->property_text_column() = 0;
        cell->property_editable()    = true;
        cell->property_has_entry()   = false;
        cell->signal_edited().connect(
            sigc::mem_fun(*this, &ConnectionsPage::onVerdictEdited));
        col->pack_start(*cell, true);
        col->add_attribute(cell->property_text(), m_columns.col_verdict);
 
        col->set_cell_data_func(*cell,
                                [this](Gtk::CellRenderer* cr, const Gtk::TreeModel::const_iterator& it) {
                                    auto* c = static_cast<Gtk::CellRendererCombo*>(cr);
                                    bool pending = (*it)[m_columns.col_pending];
                                    c->property_foreground() = pending ? "#f0c040" : "";
                                    c->property_weight() = pending
                                    ? static_cast<int>(Pango::Weight::BOLD)
                                    : static_cast<int>(Pango::Weight::NORMAL);
                                });
 
        m_treeView.append_column(*col);
    }
 
    m_treeView.append_column(_("#"),             m_columns.col_count);
    m_treeView.append_column(_("PID"),           m_columns.col_pid);
    m_treeView.append_column(_("Protocollo"),    m_columns.col_protocol);
    m_treeView.append_column(_("IP Sorgente"),   m_columns.col_src_ip);
    m_treeView.append_column(_("Host"),          m_columns.col_host);
    m_treeView.append_column(_("IP Dest."),      m_columns.col_ip);
    m_treeView.append_column(_("Porta"),         m_columns.col_port);
    m_treeView.append_column(_("Argomenti"),     m_columns.col_args);
 
    const int minW[] = { 75, 180, 140, 40, 55, 75, 110, 160, 110, 55, 180 };
    for (int i = 0; i < 11; ++i) {
        if (auto* c = m_treeView.get_column(i)) {
            c->set_min_width(minW[i]);
            c->set_resizable(true);
        }
    }
}
 
// ---------------------------------------------------------------------------
// Sparkline throughput stimato (60 s)
// ---------------------------------------------------------------------------
 
void ConnectionsPage::buildSparkline()
{
    m_sparkFrame.set_margin_top(4);
    m_sparkFrame.set_margin_bottom(4);
    m_sparkFrame.set_margin_start(8);
    m_sparkFrame.set_margin_end(8);
 
    m_sparkLabel.set_markup(
        _("<b>Throughput stimato</b>  <small>(ultimi 60 s — stima basata sul numero di connessioni)</small>"));
    m_sparkLabel.set_halign(Gtk::Align::START);
    m_sparkLabel.set_margin_start(8);
    m_sparkLabel.set_margin_top(4);
 
    m_sparkArea.set_content_height(72);
    m_sparkArea.set_hexpand(true);
    m_sparkArea.set_draw_func(
        sigc::mem_fun(*this, &ConnectionsPage::onSparkDraw));
 
    m_sparkBox.append(m_sparkLabel);
    m_sparkBox.append(m_sparkArea);
    m_sparkFrame.set_child(m_sparkBox);
 
    // Prealloca 120 bucket a zero: evita saltelli all'avvio della UI.
    for (int i = 0; i < kSparkBucketsMax; ++i) m_sparkBuckets.push_back(0);
}
 
// ---------------------------------------------------------------------------
// Navigazione: apps  ↔  detail
// ---------------------------------------------------------------------------
 
void ConnectionsPage::showAppsView()
{
    m_stack.set_visible_child("apps");
    m_backBtn.set_visible(false);
    m_detailTitle.set_visible(false);
    m_currentAppFilter.clear();
    // Svuota il modello detail per liberare memoria: verra' ripopolato
    // quando l'utente rientra in una specifica app (filtrando le connessioni
    // arrivate nel frattempo dal log / dagli aggregati).
    //
    // NOTA: NON tocchiamo m_appStats / m_appIndex (servono agli aggregati).
    m_store->clear();
    m_groupIndex.clear();
}
 
void ConnectionsPage::showDetailView(const std::string& app)
{
    m_currentAppFilter = app;
    m_detailTitle.set_text(Glib::ustring::compose(
        _("Connessioni di %1"), app));
    m_detailTitle.set_visible(true);
    m_backBtn.set_visible(true);
    m_stack.set_visible_child("detail");
 
    // Popola dalla history persistita per questa app (ring buffer di
    // 500 eventi max). Cosi' rientrando in un'app che era gia' stata
    // attiva vedi lo storico invece di una schermata vuota —
    // continuando ad aggiungere in cima i nuovi eventi live.
    //
    // PERF: stacchiamo il modello PRIMA di clear() + append, cosi'
    // evitiamo sia il burst di row-deleted (se passiamo da detail-X
    // a detail-Y senza tornare indietro: m_store puo' avere fino a
    // 500 righe) sia il burst di row-inserted (ring buffer della
    // nuova app). populateDetailFromRing ha gia' il suo
    // unset/set_model, ma se lo chiamiamo qui con il modello gia'
    // staccato, il suo set_model finale si occupa di riattaccare.
    m_treeView.unset_model();
    m_store->clear();
    m_groupIndex.clear();
    populateDetailFromRing(app);
    // Safety net: populateDetailFromRing esce subito se il ring e'
    // vuoto, senza riattaccare il modello. Garantiamo qui che la
    // view torni sempre associata a m_store.
    if (m_treeView.get_model() != m_store) {
        m_treeView.set_model(m_store);
    }
}
 
void ConnectionsPage::onBackClicked()
{
    showAppsView();
}
 
void ConnectionsPage::onAppActivated(const Gtk::TreeModel::Path& path,
                                     Gtk::TreeViewColumn* /*column*/)
{
    auto it = m_appStore->get_iter(path);
    if (!it) return;
    const Glib::ustring app = (*it)[m_appColumns.col_app];
    showDetailView(app.raw());
}
 
// ---------------------------------------------------------------------------
// Risoluzione icone app — via DesktopAppInfo + fallback
// ---------------------------------------------------------------------------
 
void ConnectionsPage::buildDesktopIndex()
{
    if (m_desktopIndexBuilt) return;
    m_desktopIndexBuilt = true;
 
    // Scansione di tutti i .desktop visibili nel sistema. Per ciascuno
    // estraiamo il nome del binario (executable basename) e lo usiamo
    // come chiave lowercase. Es: /usr/share/applications/firefox.desktop
    // con Exec="firefox %u" → mappa "firefox" → "firefox" (icon name).
    //
    // Questo copre la stragrande maggioranza delle applicazioni GUI.
    // I daemon di sistema (dnsmasq, avahi-daemon, irq handlers) non
    // hanno .desktop, quindi cadono sul fallback generico.
    auto apps = Gio::AppInfo::get_all();
    for (const auto& ai : apps) {
        auto dai = std::dynamic_pointer_cast<Gio::DesktopAppInfo>(ai);
        if (!dai) continue;
 
        // Icon name: il nome canonico dell'icona nel tema
        Glib::ustring icon_name;
        auto icon = dai->get_icon();
        if (icon) {
            auto themed = std::dynamic_pointer_cast<Gio::ThemedIcon>(icon);
            if (themed) {
                const auto names = themed->get_names();
                if (!names.empty()) icon_name = names[0];
            }
        }
        if (icon_name.empty()) continue;
 
        // Exec line: prendiamo il primo token (path) e il basename.
        const std::string exec = dai->get_commandline();
        if (exec.empty()) continue;
        // Primo token (fino a spazio)
        auto sp = exec.find(' ');
        std::string first = (sp == std::string::npos) ? exec : exec.substr(0, sp);
        // Basename
        auto sl = first.rfind('/');
        std::string base = (sl == std::string::npos) ? first : first.substr(sl + 1);
        // Lowercase per lookup case-insensitive
        for (auto& c : base) c = std::tolower(static_cast<unsigned char>(c));
        if (base.empty()) continue;
 
        // Non sovrascrivere: se esistono piu' .desktop con stesso exec
        // (es. "firefox" + "firefox-esr" entrambi con Exec=firefox) il
        // primo vince. Ordine deterministico non garantito ma in
        // pratica va bene.
        m_desktopIndex.emplace(base, icon_name.raw());
 
        // Indicizza anche il nome "StartupWMClass" se presente — alcune
        // app (Discord, Slack) usano questo come identificatore.
        const std::string wm = dai->get_startup_wm_class();
        if (!wm.empty()) {
            std::string wmlc = wm;
            for (auto& c : wmlc) c = std::tolower(static_cast<unsigned char>(c));
            m_desktopIndex.emplace(wmlc, icon_name.raw());
        }
    }
}
 
std::string ConnectionsPage::resolveIconName(const std::string& app_display)
{
    if (app_display == bsc::ui_util::safe_local_process_label()) {
        return bsc::ui_util::safe_local_process_icon_name();
    }
    return bsc::ui_util::best_app_icon_name(app_display, app_display);
}
 
// ---------------------------------------------------------------------------
// Chiave di raggruppamento — app + proto + host|ip + port
// ---------------------------------------------------------------------------
 
std::string ConnectionsPage::groupKeyFor(const std::string& app,
                                         const std::string& protocol,
                                         const std::string& host,
                                         const std::string& ip,
                                         uint32_t port)
{
    if (app.empty()) return std::string{};
    const std::string h = !host.empty() ? host : ip;
    return app + "|" + protocol + "|" + h + "|" + std::to_string(port);
}
 
// ---------------------------------------------------------------------------
// Formattazione byte e tempo
// ---------------------------------------------------------------------------
 
std::string ConnectionsPage::formatBytes(uint64_t n)
{
    char buf[32];
    if (n < 1024ULL) {
        std::snprintf(buf, sizeof(buf), "%lu B", (unsigned long)n);
    } else if (n < 1024ULL * 1024ULL) {
        std::snprintf(buf, sizeof(buf), "%.1f KB", n / 1024.0);
    } else if (n < 1024ULL * 1024ULL * 1024ULL) {
        std::snprintf(buf, sizeof(buf), "%.1f MB", n / (1024.0 * 1024.0));
    } else {
        std::snprintf(buf, sizeof(buf), "%.2f GB",
                      n / (1024.0 * 1024.0 * 1024.0));
    }
    return std::string(buf);
}
 
std::string ConnectionsPage::formatEpochTime(int64_t epoch)
{
    if (epoch <= 0) return "";
    std::time_t t = static_cast<std::time_t>(epoch);
    std::tm tmv{};
    localtime_r(&t, &tmv);
    char buf[16];
    std::strftime(buf, sizeof(buf), "%H:%M:%S", &tmv);
    return std::string(buf);
}
 
// ---------------------------------------------------------------------------
// onNewConnection: orchestra aggiornamento apps + detail + sparkline
// ---------------------------------------------------------------------------
 
void ConnectionsPage::onNewConnection(const ConnectionInfo& info, bool pending)
{
    // Nome applicazione risolto da .desktop quando possibile
    const std::string app_display = bsc::ui_util::best_connection_display_name(
        info.app_comm, info.app_path, info.app_args, info.dest_ip, info.src_ip);
 
    // Argomenti come stringa
    std::string argsStr;
    for (size_t i = 0; i < info.app_args.size(); ++i) {
        if (i > 0) argsStr += ' ';
        argsStr += info.app_args[i];
    }
 
    // 1) Sparkline: aggiungi al bucket corrente (gli eventi pending contano
    //    comunque come traffico intenzionale — l'utente potrebbe anche
    //    negarli, ma nel frattempo il socket e' stato aperto).
    m_currentBucket += kEstimatedBytesPerConn;
 
    // 2) Aggregati per-app (lista principale)
    if (!app_display.empty()) {
        updateAppAggregate(app_display);
    }
 
    // 3) Ring buffer per-app: persistiamo ogni evento detail (non solo
    //    se siamo in vista detail). Cosi' entrando in un'app al prossimo
    //    avvio (o semplicemente nella stessa sessione) vediamo lo storico
    //    anche se non era mai stata aperta la sua detail view.
    if (!app_display.empty()) {
        DetailEvent e;
        e.ts_epoch = static_cast<int64_t>(std::time(nullptr));
        e.time     = currentTime();
        e.pid      = info.pid;
        e.protocol = info.protocol;
        e.src_ip   = info.src_ip;
        e.host     = info.dest_host;
        e.ip       = info.dest_ip;
        e.port     = info.dest_port;
        e.args     = argsStr;
        // verdict resta "" — lo popoliamo alla risoluzione (vedi
        // setLastVerdict sotto). pending=true se era un popup in volo.
        e.verdict  = pending ? "" : "";
        e.pending  = pending;
        e.count    = 1;
        pushDetailEvent(app_display, e);
    }
 
    // 4) Vista detail: solo se siamo in detail e l'app matcha il filtro.
    //    Altrimenti la riga non viene aggiunta al m_store (il filtro live
    //    previene di sporcare la vista con app non pertinenti).
    const bool in_detail_view = (m_stack.get_visible_child_name() == "detail");
    if (in_detail_view && !m_currentAppFilter.empty()
        && app_display == m_currentAppFilter) {
        addOrUpdateDetailRow(info, app_display, argsStr, pending);
        }
}
 
// ---------------------------------------------------------------------------
// Aggregati per-app
// ---------------------------------------------------------------------------
 
void ConnectionsPage::updateAppAggregate(const std::string& app_display)
{
    const int64_t now_epoch = static_cast<int64_t>(std::time(nullptr));
    auto& stats = m_appStats[app_display];
    stats.conn_count      += 1;
    stats.estimated_bytes += kEstimatedBytesPerConn;
    stats.last_seen_epoch  = now_epoch;
 
    auto idx_it = m_appIndex.find(app_display);
    if (idx_it != m_appIndex.end()
        && idx_it->second
        && m_appStore->iter_is_valid(idx_it->second))
    {
        auto row = *(idx_it->second);
        row[m_appColumns.col_conn_count] = stats.conn_count;
        row[m_appColumns.col_bytes_raw]  = stats.estimated_bytes;
        row[m_appColumns.col_bytes_str]  = formatBytes(stats.estimated_bytes);
        row[m_appColumns.col_last_seen]  = formatEpochTime(now_epoch);
        row[m_appColumns.col_last_ts]    = now_epoch;
    } else {
        auto it = m_appStore->append();
        auto row = *it;
        row[m_appColumns.col_icon_name]  = resolveIconName(app_display);
        row[m_appColumns.col_app]        = app_display;
        row[m_appColumns.col_conn_count] = stats.conn_count;
        row[m_appColumns.col_bytes_raw]  = stats.estimated_bytes;
        row[m_appColumns.col_bytes_str]  = formatBytes(stats.estimated_bytes);
        row[m_appColumns.col_last_seen]  = formatEpochTime(now_epoch);
        row[m_appColumns.col_last_ts]    = now_epoch;
        m_appIndex[app_display] = it;
    }
}
 
// ---------------------------------------------------------------------------
// Ring buffer per-app degli ultimi 500 eventi detail (persistenza)
// ---------------------------------------------------------------------------
 
void ConnectionsPage::pushDetailEvent(const std::string& app_display,
                                      const DetailEvent& ev)
{
    auto& ring = m_detailRings[app_display];
    ring.push_back(ev);
    // Enforce max size con eviction FIFO: se superiamo, scartiamo il
    // piu' vecchio (front). Alternativa sarebbe ignorare il nuovo, ma
    // gli eventi piu' recenti sono in genere quelli che interessano di
    // piu' all'utente.
    while (ring.size() > kDetailRingMax) {
        ring.pop_front();
    }
}
 
void ConnectionsPage::populateDetailFromRing(const std::string& app_display)
{
    auto it = m_detailRings.find(app_display);
    if (it == m_detailRings.end()) return;
 
    const auto& ring = it->second;
    if (ring.empty()) return;
 
    // PERF: stacchiamo il modello dalla TreeView prima dell'inserimento
    // massivo. Con il modello ancora attaccato, GTK emette row-inserted
    // e ridisegna per OGNI append — con fino a kDetailRingMax (500)
    // eventi nel ring buffer, il click su un'app per aprirne il detail
    // risultava percepibilmente lento (decine/centinaia di ms di lag
    // prima che la vista comparisse). Staccando il modello facciamo un
    // unico redraw alla fine, riportando il tempo a sostanzialmente
    // istantaneo anche con la history piena. Stesso pattern usato da
    // file manager / log viewer GTK per liste lunghe.
    m_treeView.unset_model();
 
    // Iteriamo dal piu' recente al piu' vecchio e prependiamo, cosi' il
    // display ha lo stesso ordine live (piu' recente in cima).
    for (auto r_it = ring.rbegin(); r_it != ring.rend(); ++r_it) {
        const auto& e = *r_it;
        auto row_it = m_store->append();   // append, non prepend: iteriamo reverse
        auto row = *row_it;
        row[m_columns.col_time]      = e.time;
        row[m_columns.col_app]       = app_display;
        row[m_columns.col_verdict]   = e.verdict;
        row[m_columns.col_count]     = e.count;
        row[m_columns.col_pid]       = e.pid;
        row[m_columns.col_protocol]  = e.protocol;
        row[m_columns.col_src_ip]    = e.src_ip;
        row[m_columns.col_host]      = e.host;
        row[m_columns.col_ip]        = e.ip;
        row[m_columns.col_port]      = e.port;
        row[m_columns.col_args]      = e.args;
        row[m_columns.col_pending]   = e.pending;
        // group_key vuoto: non popoliamo m_groupIndex con righe storiche
        // per evitare che il dedup online colleghi pin fresco a riga
        // ricostruita da log.
        row[m_columns.col_group_key] = "";
    }
 
    // Ricolleghiamo il modello: un unico redraw per tutte le righe.
    m_treeView.set_model(m_store);
}
 
// ---------------------------------------------------------------------------
// Riga vista detail — con dedup per-gruppo come nella v2
// ---------------------------------------------------------------------------
 
void ConnectionsPage::addOrUpdateDetailRow(const ConnectionInfo& info,
                                           const std::string& app_display,
                                           const std::string& argsStr,
                                           bool pending)
{
    const std::string key = groupKeyFor(app_display, info.protocol,
                                        info.dest_host, info.dest_ip,
                                        info.dest_port);
 
    // Dedup solo per righe non-pending
    if (!key.empty() && !pending) {
        auto it_idx = m_groupIndex.find(key);
        if (it_idx != m_groupIndex.end()) {
            auto it = it_idx->second;
            if (it && m_store->iter_is_valid(it)) {
                const bool row_pending = (*it)[m_columns.col_pending];
                if (!row_pending) {
                    const uint32_t      new_count = static_cast<uint32_t>((*it)[m_columns.col_count]) + 1;
                    const Glib::ustring v_app     = (*it)[m_columns.col_app];
                    const Glib::ustring v_verdict = (*it)[m_columns.col_verdict];
                    const Glib::ustring v_proto   = (*it)[m_columns.col_protocol];
                    const Glib::ustring v_src_ip  = (*it)[m_columns.col_src_ip];
                    const Glib::ustring v_host    = (*it)[m_columns.col_host];
                    const Glib::ustring v_ip      = (*it)[m_columns.col_ip];
                    const uint32_t      v_port    = (*it)[m_columns.col_port];
                    const Glib::ustring v_args    = (*it)[m_columns.col_args];
                    const Glib::ustring v_gkey    = (*it)[m_columns.col_group_key];
 
                    m_store->erase(it);
 
                    auto newIt = m_store->prepend();
                    auto newRow = *newIt;
                    newRow[m_columns.col_time]      = currentTime();
                    newRow[m_columns.col_app]       = v_app;
                    newRow[m_columns.col_verdict]   = v_verdict;
                    newRow[m_columns.col_count]     = new_count;
                    newRow[m_columns.col_pid]       = info.pid;
                    newRow[m_columns.col_protocol]  = v_proto;
                    newRow[m_columns.col_src_ip]    = v_src_ip;
                    newRow[m_columns.col_host]      = v_host;
                    newRow[m_columns.col_ip]        = v_ip;
                    newRow[m_columns.col_port]      = v_port;
                    newRow[m_columns.col_args]      = v_args;
                    newRow[m_columns.col_pending]   = false;
                    newRow[m_columns.col_group_key] = v_gkey;
 
                    m_groupIndex[key] = newIt;
                    return;
                }
            } else {
                m_groupIndex.erase(it_idx);
            }
        }
    }
 
    // Nuova riga
    auto it = m_store->prepend();
    auto row = *it;
    row[m_columns.col_time]      = currentTime();
    row[m_columns.col_app]       = app_display;
    row[m_columns.col_verdict]   = pending ? _("In attesa...") : "";
    row[m_columns.col_count]     = 1u;
    row[m_columns.col_pid]       = info.pid;
    row[m_columns.col_protocol]  = info.protocol;
    row[m_columns.col_src_ip]    = info.src_ip;
    row[m_columns.col_host]      = info.dest_host;
    row[m_columns.col_ip]        = info.dest_ip;
    row[m_columns.col_port]      = info.dest_port;
    row[m_columns.col_args]      = argsStr;
    row[m_columns.col_pending]   = pending;
    row[m_columns.col_group_key] = key;
 
    if (!key.empty()) m_groupIndex[key] = it;
}
 
// ---------------------------------------------------------------------------
// Sparkline tick + draw
// ---------------------------------------------------------------------------
 
bool ConnectionsPage::onSparkTick()
{
    // Sposta il bucket corrente nella storia. Mantieni al massimo
    // kSparkBucketsMax bucket; scarta il piu' vecchio in testa.
    m_sparkBuckets.push_back(m_currentBucket);
    while (static_cast<int>(m_sparkBuckets.size()) > kSparkBucketsMax) {
        m_sparkBuckets.pop_front();
    }
    m_currentBucket = 0;
 
    // Aggiorna l'etichetta con il picco + media degli ultimi 60 s
    uint64_t peak = 0, sum = 0;
    for (auto b : m_sparkBuckets) {
        if (b > peak) peak = b;
        sum += b;
    }
    // Per avere "byte/s" moltiplichiamo per 1000/kSparkBucketMs = 2
    const uint64_t avg_bps  = (sum * 1000ULL) /
    (kSparkBucketMs * m_sparkBuckets.size());
    const uint64_t peak_bps = (peak * 1000ULL) / kSparkBucketMs;
    m_sparkLabel.set_markup(
        Glib::ustring::compose(
            _("<b>Throughput stimato</b>  <small>ultimi 60 s — media %1/s · picco %2/s  (stima basata sul numero di connessioni)</small>"),
                               formatBytes(avg_bps),
                                   formatBytes(peak_bps)));
 
                               m_sparkArea.queue_draw();
                               return true;  // mantieni il timer attivo
}
 
void ConnectionsPage::onSparkDraw(const Cairo::RefPtr<Cairo::Context>& cr,
                                  int width, int height)
{
    if (m_sparkBuckets.empty() || width <= 0 || height <= 0) return;
 
    // Trova il massimo per normalizzare
    uint64_t peak = 0;
    for (auto b : m_sparkBuckets) if (b > peak) peak = b;
    if (peak == 0) peak = 1;  // evita div/0 quando tutto vuoto
 
    const int n = static_cast<int>(m_sparkBuckets.size());
    const double bar_w = static_cast<double>(width) / n;
    const double pad   = 4.0;
 
    // Sfondo sottile (griglia a 25/50/75% dell'altezza)
    cr->set_source_rgba(1, 1, 1, 0.06);
    cr->set_line_width(1);
    for (int i = 1; i < 4; ++i) {
        double y = pad + (height - 2 * pad) * i / 4.0;
        cr->move_to(0, y);
        cr->line_to(width, y);
        cr->stroke();
    }
 
    // Area riempita (verde BastionGuard morbido)
    cr->set_source_rgba(0.30, 0.78, 0.55, 0.85);
    cr->move_to(0, height - pad);
    for (int i = 0; i < n; ++i) {
        const double frac = static_cast<double>(m_sparkBuckets[i]) / peak;
        const double x = i * bar_w;
        const double y = (height - pad) - frac * (height - 2 * pad);
        cr->line_to(x, y);
    }
    cr->line_to(width, height - pad);
    cr->close_path();
    cr->fill_preserve();
 
    // Contorno superiore piu' marcato
    cr->set_source_rgba(0.30, 0.78, 0.55, 1.0);
    cr->set_line_width(1.5);
    cr->stroke();
}
 
// ---------------------------------------------------------------------------
// Verdict handling
// ---------------------------------------------------------------------------
 
void ConnectionsPage::setLastVerdict(const std::string& verdict)
{
    auto children = m_store->children();
    for (auto it = children.begin(); it != children.end(); ++it) {
        auto row = *it;
        if (row[m_columns.col_pending]) {
            row[m_columns.col_verdict] = verdict;
            row[m_columns.col_pending] = false;
            const Glib::ustring k = row[m_columns.col_group_key];
            if (!k.empty()) m_groupIndex[k.raw()] = it;
            return;
        }
    }
    if (!children.empty()) {
        auto first = *children.begin();
        first[m_columns.col_verdict] = verdict;
    }
}
 
void ConnectionsPage::onVerdictEdited(const Glib::ustring& pathStr,
                                      const Glib::ustring& newText)
{
    auto it = m_store->get_iter(pathStr);
    if (!it) return;
 
    const bool wasPending = (*it)[m_columns.col_pending];
    (*it)[m_columns.col_verdict] = newText;
 
    if (wasPending) {
        m_uiServer.sendReply(parseReplyAction(newText));
        (*it)[m_columns.col_pending] = false;
    }
}
 
ReplyAction ConnectionsPage::parseReplyAction(const Glib::ustring& text) const
{
    if (text == "allow once")   return ReplyAction::ALLOW_ONCE;
    if (text == "allow always") return ReplyAction::ALLOW_ALWAYS;
    if (text == "deny always")  return ReplyAction::DENY_ALWAYS;
    return ReplyAction::DENY_ONCE;
}
 
void ConnectionsPage::onClear()
{
    clearLog();
    // Dopo Pulisci vogliamo sempre ripartire dalla vista aggregata:
    // 1) il filtro corrente ("Connessioni di firefox") diventa stale se
    //    siamo in detail — nuove connessioni di altre app non apparirebbero
    //    nel detail (per design), e il risultato sarebbe una schermata che
    //    sembra "rotta" con zero contenuti. L'utente si aspetta una
    //    panoramica fresca.
    // 2) Se l'utente vuole rientrare nel detail di un'app, ora dopo il
    //    reset basta un doppio click sulla riga app appena ricreata.
    if (m_stack.get_visible_child_name() == "detail") {
        showAppsView();
    }
}
 
std::string ConnectionsPage::currentTime()
{
    auto now = Glib::DateTime::create_now_local();
    return now.format("%H:%M:%S");
}
 
// ---------------------------------------------------------------------------
// Log persistente JSON Lines — include anche aggregati per-app
// ---------------------------------------------------------------------------
 
std::string ConnectionsPage::logPath()
{
    return "/tmp/bastionguard-sc-connections-" +
    std::to_string(::getuid()) + ".jsonl";
}
 
std::string ConnectionsPage::jsonEscapeStr(const std::string& s)
{
    std::string out;
    for (unsigned char c : s) {
        switch (c) {
            case '"':  out += "\\\""; break;
            case '\\': out += "\\\\"; break;
            case '\n': out += "\\n";  break;
            case '\r': out += "\\r";  break;
            case '\t': out += "\\t";  break;
            default:
                if (c < 0x20) { char b[8]; std::snprintf(b, sizeof(b), "\\u%04x", c); out += b; }
                else out += c;
        }
    }
    return out;
}
 
std::string ConnectionsPage::jsonFieldStr(const std::string& json, const std::string& key)
{
    const std::string needle = "\"" + key + "\":\"";
    auto pos = json.find(needle);
    if (pos == std::string::npos) return {};
    pos += needle.size();
    auto end = json.find('"', pos);
    return end == std::string::npos ? std::string{} : json.substr(pos, end - pos);
}
 
uint32_t ConnectionsPage::jsonFieldUint(const std::string& json, const std::string& key)
{
    const std::string needle = "\"" + key + "\":";
    auto pos = json.find(needle);
    if (pos == std::string::npos) return 0;
    pos += needle.size();
    return static_cast<uint32_t>(std::strtoul(json.c_str() + pos, nullptr, 10));
}
 
bool ConnectionsPage::jsonFieldBool(const std::string& json, const std::string& key)
{
    const std::string needle = "\"" + key + "\":";
    auto pos = json.find(needle);
    if (pos == std::string::npos) return false;
    pos += needle.size();
    return json.substr(pos, 4) == "true";
}
 
void ConnectionsPage::saveLog() const
{
    std::ofstream f(logPath(), std::ios::trunc);
    if (!f.is_open()) return;
 
    // Persistiamo:
    //   - aggregati per-app (type="app") — per la vista "Applicazioni"
    //   - ultimi 500 eventi detail per app (type="conn") — per la vista
    //     dettagli quando l'utente rientra in un'app
    //
    // Retention 7 giorni enforced al loadLog(): il file cresce comunque
    // proporzionalmente al kDetailRingMax (500 eventi × numero app),
    // tipicamente <5 MB anche con uso intenso.
    for (const auto& kv : m_appStats) {
        const std::string& app = kv.first;
        const AppStats& s      = kv.second;
        f << "{\"type\":\"app\""
        << ",\"app\":\""   << jsonEscapeStr(app) << "\""
        << ",\"count\":"   << s.conn_count
        << ",\"bytes\":"   << s.estimated_bytes
        << ",\"last_ts\":" << s.last_seen_epoch
        << "}\n";
    }
 
    // Eventi detail: per ogni app scriviamo il suo ring buffer in ordine
    // cronologico crescente (front = piu' vecchio, back = piu' recente).
    for (const auto& [app, ring] : m_detailRings) {
        for (const auto& e : ring) {
            f << "{\"type\":\"conn\""
            << ",\"app\":\""     << jsonEscapeStr(app)        << "\""
            << ",\"ts\":"        << e.ts_epoch
            << ",\"time\":\""    << jsonEscapeStr(e.time)     << "\""
            << ",\"pid\":"       << e.pid
            << ",\"proto\":\""   << jsonEscapeStr(e.protocol) << "\""
            << ",\"src_ip\":\""  << jsonEscapeStr(e.src_ip)   << "\""
            << ",\"host\":\""    << jsonEscapeStr(e.host)     << "\""
            << ",\"ip\":\""      << jsonEscapeStr(e.ip)       << "\""
            << ",\"port\":"      << e.port
            << ",\"args\":\""    << jsonEscapeStr(e.args)     << "\""
            << ",\"verdict\":\"" << jsonEscapeStr(e.verdict)  << "\""
            << ",\"pending\":"   << (e.pending ? "true" : "false")
            << ",\"count\":"     << e.count
            << "}\n";
        }
    }
}
 
void ConnectionsPage::loadLog()
{
    std::ifstream f(logPath());
    if (!f.is_open()) return;
 
    const int64_t now_epoch = static_cast<int64_t>(std::time(nullptr));
    const int64_t cutoff    = now_epoch - kRetentionSeconds;
    int n_apps = 0, n_conns = 0, n_dropped = 0;
 
    // Helper parser che gestiscono uint64/int64 (jsonFieldUint e' solo u32)
    auto parse_u64 = [](const std::string& line, const char* key) -> uint64_t {
        const std::string needle = std::string("\"") + key + "\":";
        auto pos = line.find(needle);
        if (pos == std::string::npos) return 0;
        pos += needle.size();
        return std::strtoull(line.c_str() + pos, nullptr, 10);
    };
    auto parse_i64 = [](const std::string& line, const char* key) -> int64_t {
        const std::string needle = std::string("\"") + key + "\":";
        auto pos = line.find(needle);
        if (pos == std::string::npos) return 0;
        pos += needle.size();
        return std::strtoll(line.c_str() + pos, nullptr, 10);
    };
 
    std::string line;
    while (std::getline(f, line)) {
        if (line.empty() || line[0] != '{') continue;
 
        const std::string type = jsonFieldStr(line, "type");
 
        if (type == "app") {
            // Ripristina aggregato per-app (caso v3)
            const std::string app = jsonFieldStr(line, "app");
            if (app.empty()) continue;
            const int64_t ts = parse_i64(line, "last_ts");
            // Retention 7 giorni: aggregato obsoleto se l'ultima
            // attivita' e' oltre il cutoff.
            if (ts > 0 && ts < cutoff) { ++n_dropped; continue; }
            AppStats s;
            s.conn_count      = jsonFieldUint(line, "count");
            s.estimated_bytes = parse_u64(line, "bytes");
            s.last_seen_epoch = ts;
            m_appStats[app] = s;
            ++n_apps;
            continue;
        }
 
        if (type == "conn") {
            // Evento detail persistito: lo rimettiamo nel ring buffer
            // dell'app corrispondente (se fresco).
            const std::string app = jsonFieldStr(line, "app");
            if (app.empty()) continue;
            const int64_t ts = parse_i64(line, "ts");
            if (ts > 0 && ts < cutoff) { ++n_dropped; continue; }
 
            DetailEvent e;
            e.ts_epoch = ts;
            e.time     = jsonFieldStr(line, "time");
            e.pid      = jsonFieldUint(line, "pid");
            e.protocol = jsonFieldStr(line, "proto");
            e.src_ip   = jsonFieldStr(line, "src_ip");
            e.host     = jsonFieldStr(line, "host");
            e.ip       = jsonFieldStr(line, "ip");
            e.port     = jsonFieldUint(line, "port");
            e.args     = jsonFieldStr(line, "args");
            e.verdict  = jsonFieldStr(line, "verdict");
            e.pending  = jsonFieldBool(line, "pending");
            e.count    = jsonFieldUint(line, "count");
            if (e.count == 0) e.count = 1;
            // Append in coda: preserviamo l'ordine cronologico del file
            // (e' scritto cronologico crescente). Se il ring e' pieno
            // sconfiniamo a kDetailRingMax — via pushDetailEvent.
            pushDetailEvent(app, e);
            ++n_conns;
            continue;
        }
 
        // Log legacy v2 senza "type": trattalo come conn per ricostruire
        // almeno il totale aggregato.
        const std::string app = jsonFieldStr(line, "app");
        if (app.empty()) continue;
        AppStats& s = m_appStats[app];
        s.conn_count     += 1;
        s.estimated_bytes += kEstimatedBytesPerConn;
        if (s.last_seen_epoch == 0) s.last_seen_epoch = now_epoch;
    }
 
    // Popola la ListStore apps a partire dagli aggregati accumulati.
    for (const auto& kv : m_appStats) {
        auto it = m_appStore->append();
        auto row = *it;
        row[m_appColumns.col_icon_name]  = resolveIconName(kv.first);
        row[m_appColumns.col_app]        = kv.first;
        row[m_appColumns.col_conn_count] = kv.second.conn_count;
        row[m_appColumns.col_bytes_raw]  = kv.second.estimated_bytes;
        row[m_appColumns.col_bytes_str]  = formatBytes(kv.second.estimated_bytes);
        row[m_appColumns.col_last_seen]  = formatEpochTime(kv.second.last_seen_epoch);
        row[m_appColumns.col_last_ts]    = kv.second.last_seen_epoch;
        m_appIndex[kv.first] = it;
    }
 
    std::cerr << "[ConnectionsPage] Caricato log: "
    << n_apps << " app + " << n_conns << " eventi detail, "
    << n_dropped << " scartati per retention 7gg ("
    << m_appStats.size() << " app uniche totali)\n";
}
 
void ConnectionsPage::clearLog()
{
    m_store->clear();
    m_groupIndex.clear();
    m_appStore->clear();
    m_appIndex.clear();
    m_appStats.clear();
    m_detailRings.clear();
    std::error_code ec;
    std::filesystem::remove(logPath(), ec);
}