DashboardPage.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "Resource.hpp"
#include "DashboardPage.hpp"
#include "SafeProcess.hpp"
#include "Backend.hpp"
#include <gdkmm/pixbuf.h>
#include <gdkmm/texture.h>
#include <gtkmm/image.h>
#include <gtkmm/picture.h>
#include <glibmm/main.h>
#include <glib/gi18n.h>
#include <sstream>
#include <cstdlib>
#include <string>
#include <iostream>
#include <vector>
#include <fstream>
#include <filesystem>
#include <unistd.h>
#include <libsoup/soup.h>
 
 
static int compare_semver(const std::string& a, const std::string& b)
{
    auto parse = [](const std::string& v) {
        std::vector<int> parts;
        std::stringstream ss(v);
        std::string item;
 
        while (std::getline(ss, item, '.')) {
            try {
                parts.push_back(std::stoi(item));
            } catch (...) {
                parts.push_back(0);
            }
        }
 
        while (parts.size() < 3)
            parts.push_back(0);
 
        return parts;
    };
 
    auto pa = parse(a);
    auto pb = parse(b);
 
    for (size_t i = 0; i < 3; ++i) {
        if (pa[i] != pb[i])
            return pa[i] < pb[i] ? -1 : 1;
    }
 
    return 0;
}
 
 
 
static bool check_service_active(const std::string& service_name) {
    return bg_process::run({"/usr/libexec/bastionguard/bastionguard-service",
                            "--system", "is-active", service_name}).ok();
}
 
 
 
DashboardPage::~DashboardPage()
{
    if (alive_) alive_->store(false, std::memory_order_release);
    if (refresh_timer_.connected())       refresh_timer_.disconnect();
    if (update_check_timer_.connected())  update_check_timer_.disconnect();
}
 
 
DashboardPage::DashboardPage()
: Gtk::Box(Gtk::Orientation::VERTICAL, 16),
  lbl_title_("<b>Dashboard BastionGuard Endpoint</b>", Gtk::Align::START),
  grid_cards_(),
  lbl_status_(_("Inizializzazione...")),
  lbl_db_version_(_("Versione firme: sconosciuta")),
  lbl_db_date_(_("Data aggiornamento: sconosciuta")),
  lbl_ransomware_status_(_("Anti-Ransomware: stato sconosciuto")),
  lbl_phishing_status_(_("Anti-Phishing: stato sconosciuto"))
{
    set_margin(20);
    set_hexpand(true);
    set_halign(Gtk::Align::FILL);
 
 
    lbl_title_.set_use_markup(true);
    lbl_title_.set_margin_bottom(12);
    lbl_title_.get_style_context()->add_class("title");
    append(lbl_title_);
 
 
    grid_cards_.set_row_spacing(20);
    grid_cards_.set_column_spacing(20);
    grid_cards_.set_column_homogeneous(true);
    grid_cards_.set_hexpand(true);
    grid_cards_.set_halign(Gtk::Align::FILL);
 
 
    auto vbox_status = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    vbox_status->append(lbl_status_);
    vbox_status->append(lbl_ransomware_status_);
    vbox_status->append(lbl_phishing_status_);
 
 
    card_status_     = make_card(resource("icons/status.svg"),      *vbox_status,    _("Stato"));
    card_db_version_ = make_card(resource("icons/version.svg"),     lbl_db_version_, _("Versione Firme"));
    card_db_date_    = make_card(resource("icons/update-date.svg"), lbl_db_date_,    _("Ultimo aggiornamento"));
 
 
    grid_cards_.attach(*card_status_,     0, 0, 1, 1);
    grid_cards_.attach(*card_db_version_, 1, 0, 1, 1);
    grid_cards_.attach(*card_db_date_,    2, 0, 1, 1);
    append(grid_cards_);
 
 
    buf_onaccess_report_ = Gtk::TextBuffer::create();
    txt_onaccess_report_.set_buffer(buf_onaccess_report_);
    txt_onaccess_report_.set_editable(false);
    txt_onaccess_report_.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
    txt_onaccess_report_.set_vexpand(true);
 
    card_logs_ = make_card(resource("icons/log-dash.svg"), txt_onaccess_report_, _("Ultimi file scansionati"));
    append(*card_logs_);
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(false); // <-- IMPORTANTE
    append(*spacer);
 
    footer_box_ = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    footer_box_->set_hexpand(true);
    footer_box_->set_halign(Gtk::Align::FILL);
    footer_box_->set_margin_top(12);
    footer_box_->set_spacing(4);
 
    {
        auto applyTheme = [this](const std::string& themeId) {
            std::string cssFile;
            if (themeId == "dark")
                cssFile = Glib::build_filename(DATA_DIR, "BastionGuard-dark.css");
            else
                cssFile = Glib::build_filename(DATA_DIR, "BastionGuard.css");
            if (!std::filesystem::exists(cssFile)) {
                char self_path[1024] = {};
                ssize_t n = readlink("/proc/self/exe", self_path, sizeof(self_path) - 1);
                if (n > 0) {
                    std::string exeDir =
                        std::filesystem::path(self_path).parent_path().string();
                    std::string candidate = exeDir + "/" +
                        (themeId == "dark" ? "BastionGuard-dark.css" : "BastionGuard.css");
                    if (std::filesystem::exists(candidate))
                        cssFile = candidate;
                }
            }
 
            if (!std::filesystem::exists(cssFile)) {
                std::cerr << "[BastionGuard] CSS non trovato: " << cssFile << "\n";
                return;
            }
 
            try {
                auto provider = Gtk::CssProvider::create();
                provider->load_from_path(cssFile);
                Gtk::StyleContext::add_provider_for_display(
                    Gdk::Display::get_default(),
                    provider,
                    GTK_STYLE_PROVIDER_PRIORITY_USER);
            } catch (const Glib::Error& e) {
                std::cerr << "[BastionGuard] Errore CSS: " << e.what() << "\n";
                return;
            }
 
            std::string cfgDir = Glib::get_home_dir() + "/.config/BastionGuard";
            std::filesystem::create_directories(cfgDir);
            std::ofstream tf(cfgDir + "/theme.conf", std::ios::trunc);
            tf << themeId;
 
            btn_theme_light_->get_style_context()->remove_class("theme-btn-active");
            btn_theme_dark_->get_style_context()->remove_class("theme-btn-active");
            if (themeId == "dark")
                btn_theme_dark_->get_style_context()->add_class("theme-btn-active");
            else
                btn_theme_light_->get_style_context()->add_class("theme-btn-active");
        };
 
        btn_theme_light_ = Gtk::make_managed<Gtk::Button>("☀");
        btn_theme_light_->set_tooltip_text(_("Tema Chiaro"));
        btn_theme_light_->get_style_context()->add_class("flat");
        btn_theme_light_->get_style_context()->add_class("theme-btn");
        btn_theme_light_->signal_clicked().connect([applyTheme]() { applyTheme("light"); });
 
        btn_theme_dark_ = Gtk::make_managed<Gtk::Button>("🌙");
        btn_theme_dark_->set_tooltip_text(_("Tema Scuro"));
        btn_theme_dark_->get_style_context()->add_class("flat");
        btn_theme_dark_->get_style_context()->add_class("theme-btn");
        btn_theme_dark_->signal_clicked().connect([applyTheme]() { applyTheme("dark"); });
 
        {
            std::string saved;
            std::ifstream tf(Glib::get_home_dir() + "/.config/BastionGuard/theme.conf");
            tf >> saved;
            if (saved == "dark")
                btn_theme_dark_->get_style_context()->add_class("theme-btn-active");
            else
                btn_theme_light_->get_style_context()->add_class("theme-btn-active");
        }
 
        footer_box_->append(*btn_theme_light_);
        footer_box_->append(*btn_theme_dark_);
    }
 
    lbl_update_status_.set_text(_("Verifica aggiornamenti..."));
    lbl_update_status_.set_halign(Gtk::Align::END);
    lbl_update_status_.set_hexpand(true);
    lbl_update_status_.set_xalign(1.0f);
 
    auto ctx = lbl_update_status_.get_style_context();
    ctx->add_class("update-badge");
    ctx->add_class("update-checking");
 
    footer_box_->append(lbl_update_status_);
    append(*footer_box_);
 
 
    refresh_timer_ = Glib::signal_timeout().connect(
        sigc::mem_fun(*this,
            static_cast<bool(DashboardPage::*)()>(&DashboardPage::update_from_logs)),
        5000
    );
    check_updates_async();
    update_check_timer_ = Glib::signal_timeout().connect(
    sigc::mem_fun(*this, &DashboardPage::on_update_check_timer),
    6 * 60 * 60 * 1000
    );
}
 
 
bool DashboardPage::on_update_check_timer() {
    check_updates_async();
    return true;
}
 
void DashboardPage::check_updates_async()
{
    if (update_check_in_progress_)
        return;
    update_check_in_progress_ = true;
 
    const char* url = "https://bastionguard.eu/version.php";
 
    SoupSession* session = soup_session_new();
    g_object_set(session, "timeout", 10, NULL);
 
    SoupMessage* msg = soup_message_new("GET", url);
 
    // Passiamo via user_data una coppia (this, alive_flag) allocata sullo heap:
    // se la pagina viene distrutta prima del callback async, alive_flag->load()
    // è false e il callback fa early-return.
    struct CheckUpdateCtx {
        DashboardPage* self;
        BastionGuard::AliveFlag alive;
    };
    auto* ctx = new CheckUpdateCtx{this, alive_};
 
    soup_session_send_and_read_async(
        session,
        msg,
        G_PRIORITY_DEFAULT,
        nullptr,
        +[](GObject* source, GAsyncResult* res, gpointer user_data) {
 
            std::unique_ptr<CheckUpdateCtx> ctx(
                static_cast<CheckUpdateCtx*>(user_data));
            DashboardPage* self = ctx->self;
            auto alive = ctx->alive;
 
            SoupSession* session = SOUP_SESSION(source);
 
            GError* error = nullptr;
            GBytes* bytes = soup_session_send_and_read_finish(session, res, &error);
 
            if (!alive->load()) {
                if (bytes) g_bytes_unref(bytes);
                if (error) g_error_free(error);
                g_object_unref(session);
                return;
            }
 
            if (error || !bytes) {
                Glib::signal_idle().connect_once([self, alive]{
                    BastionGuard::if_alive(alive, [self]{
                        self->update_check_in_progress_ = false;
                        self->set_update_status("error");
                    });
                });
 
                if (error) g_error_free(error);
                g_object_unref(session);
                return;
            }
 
            gsize size = 0;
            const char* data = static_cast<const char*>(g_bytes_get_data(bytes, &size));
            std::string body(data, size);
            g_bytes_unref(bytes);
 
            std::istringstream iss(body);
            std::string line;
            std::string remote_version = "0.0";
            int remote_build = 0;
 
            try {
                while (std::getline(iss, line)) {
                    if (!line.empty() && line.back() == '\r')
                        line.pop_back();
 
                    if (line.rfind("version=", 0) == 0) {
                        remote_version = line.substr(8);
                    } else if (line.rfind("build=", 0) == 0) {
                        remote_build = std::stoi(line.substr(6));
                    }
                }
            } catch (...) {
                Glib::signal_idle().connect_once([self, alive]{
                    BastionGuard::if_alive(alive, [self]{
                        self->update_check_in_progress_ = false;
                        self->set_update_status("error");
                    });
                });
 
                g_object_unref(session);
                return;
            }
 
            const std::string local_version = Backend::getAppVersion();
            const int local_build = Backend::getAppBuild();
 
            bool update_available = false;
 
            int vcmp = compare_semver(local_version, remote_version);
            if (vcmp < 0) update_available = true;
            else if (vcmp == 0 && remote_build > local_build) update_available = true;
 
            Glib::signal_idle().connect_once([self, alive, update_available, remote_version, remote_build]{
                BastionGuard::if_alive(alive, [self, update_available, &remote_version, remote_build]{
                    self->update_check_in_progress_ = false;
 
                    self->set_update_status(update_available ? "update" : "ok");
                    self->lbl_update_status_.set_tooltip_text(
                        Glib::ustring::compose(
                            _("Remoto: %1 (%2)"),
                            remote_version,
                            std::to_string(remote_build)
                        )
                    );
                });
            });
 
            g_object_unref(session);
        },
        ctx
    );
 
    g_object_unref(msg);
}
 
 
 
void DashboardPage::set_update_status(const std::string& state)
{
    auto ctx = lbl_update_status_.get_style_context();
 
    ctx->add_class("update-badge");
 
    ctx->remove_class("update-ok");
    ctx->remove_class("update-warn");
    ctx->remove_class("update-unk");
    ctx->remove_class("update-checking");
 
    if (state == "ok") {
        ctx->add_class("update-ok");
        lbl_update_status_.set_text(_("Aggiornato"));
    }
    else if (state == "update") {
        ctx->add_class("update-warn");
        lbl_update_status_.set_text(_("Aggiornamento disponibile"));
    }
    else if (state == "checking") {
        ctx->add_class("update-checking");
        lbl_update_status_.set_text(_("Verifica aggiornamenti..."));
    }
    else {
        ctx->add_class("update-unk");
        lbl_update_status_.set_text(_("Impossibile verificare"));
    }
}
 
 
 
static Gtk::Picture* load_picture_fixed(const std::string& path, int size) {
    auto pic = Gtk::make_managed<Gtk::Picture>();
    try {
        auto pb     = Gdk::Pixbuf::create_from_file(path);
        auto scaled = pb->scale_simple(size, size, Gdk::InterpType::BILINEAR);
        auto tex    = Gdk::Texture::create_for_pixbuf(scaled);
 
 
        pic->set_paintable(tex);
        pic->set_content_fit(Gtk::ContentFit::CONTAIN);
        pic->set_keep_aspect_ratio(true);
    } catch (...) {
        std::cerr << _("⚠ Impossibile caricare immagine: ") << path << "\n";
    }
 
 
    pic->set_hexpand(false);
    pic->set_vexpand(false);
    pic->set_halign(Gtk::Align::START);
    pic->set_valign(Gtk::Align::START);
 
    return pic;
}
 
inline Gtk::Picture* make_small_icon(const std::string& path) {
    return load_picture_fixed(path, 32);
}
 
inline Gtk::Picture* make_large_icon(const std::string& path) {
    return load_picture_fixed(path, 128);
}
 
 
Gtk::Frame* DashboardPage::make_card(const std::string& icon_path,
                                     Gtk::Widget& content,
                                     const Glib::ustring& title)
{
    auto frame = Gtk::make_managed<Gtk::Frame>();
    frame->get_style_context()->add_class("card");
    frame->set_margin_bottom(10);
    frame->set_hexpand(true);
    frame->set_halign(Gtk::Align::FILL);
 
    auto hbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 12);
    hbox->set_margin(12);
    hbox->set_hexpand(true);
    hbox->set_halign(Gtk::Align::FILL);
 
 
    auto icon_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    icon_box->set_size_request(64, 64);
    icon_box->set_halign(Gtk::Align::START);
    icon_box->set_valign(Gtk::Align::START);
 
    auto pic = Gtk::make_managed<Gtk::Picture>();
    try {
        auto pb     = Gdk::Pixbuf::create_from_file(icon_path);
        auto scaled = pb->scale_simple(64, 64, Gdk::InterpType::BILINEAR);
        auto tex    = Gdk::Texture::create_for_pixbuf(scaled);
        pic->set_paintable(tex);
        pic->set_content_fit(Gtk::ContentFit::FILL);
        pic->set_keep_aspect_ratio(true);
    } catch (...) {
        std::cerr << _("⚠ Impossibile caricare icona: ") << icon_path << "\n";
    }
 
    icon_box->append(*pic);
    hbox->append(*icon_box);
 
 
    auto vbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    vbox->set_hexpand(true);
    vbox->set_halign(Gtk::Align::FILL);
 
    auto lbl_title = Gtk::make_managed<Gtk::Label>();
    lbl_title->set_markup("<b>" + title + "</b>");
    lbl_title->set_halign(Gtk::Align::START);
 
    if (auto lbl = dynamic_cast<Gtk::Label*>(&content)) {
        lbl->set_wrap(true);
        lbl->set_wrap_mode(Pango::WrapMode::WORD_CHAR);
        lbl->set_ellipsize(Pango::EllipsizeMode::NONE);
        lbl->set_xalign(0.0);
        lbl->set_hexpand(true);
        lbl->set_halign(Gtk::Align::FILL);
    }
 
    vbox->append(*lbl_title);
    vbox->append(content);
 
    hbox->append(*vbox);
    frame->set_child(*hbox);
 
    return frame;
}
 
 
 
 
 
bool DashboardPage::update_from_logs() {
    update_from_logs("", Backend::getDbVersion(), Backend::isClamonaccActive());
    return true;
}
 
 
void DashboardPage::update_from_logs(const std::string& ,
                                     const Glib::ustring& db_version,
                                     bool )
{
 
    lbl_status_.set_markup(_("<b>Antivirus engine:</b> <span foreground='green'><b>Attivo</b></span>"));
 
    if (!db_version.empty() && db_version != _("sconosciuta")) {
        lbl_db_version_.set_text(db_version);
    } else {
        lbl_db_version_.set_text(_("Versione firme: sconosciuta"));
    }
 
    auto update_date = Backend::getLastUpdateDate();
    if (!update_date.empty())
        lbl_db_date_.set_text(update_date);
    else
        lbl_db_date_.set_text(_("Data aggiornamento: sconosciuta"));
 
 
    auto events = Backend::getOnAccessEvents();
 
    if (!events.empty()) {
        std::ostringstream oss;
 
 
        int count = 0;
        for (auto it = events.rbegin(); it != events.rend() && count < 2; ++it, ++count) {
            oss << "• " << *it << "\n";
        }
 
        buf_onaccess_report_->set_text(oss.str());
    } else {
        buf_onaccess_report_->set_text(_("Nessun file scansionato di recente."));
    }
 
    // Stato Anti-Ransomware → servizio utente
    bool ransom_ok = check_service_active("BastionGuard-ransomware-realtime.service");
    if (ransom_ok) {
        lbl_ransomware_status_.set_markup(
            _("<b>Anti-Ransomware:</b> <span foreground='green'><b>Attivo</b></span>")
        );
    } else {
        lbl_ransomware_status_.set_markup(
            _("<b>Anti-Ransomware:</b> <span foreground='red'><b>Disattivato</b></span>")
        );
    }
 
 
    bool phish_ok = check_service_active("BastionGuard-phishing-scanner.service");
    if (phish_ok) {
        lbl_phishing_status_.set_markup(
            _("<b>Anti-Phishing:</b> <span foreground='green'><b>Attivo</b></span>")
        );
    } else {
        lbl_phishing_status_.set_markup(
            _("<b>Anti-Phishing:</b> <span foreground='red'><b>Disattivato</b></span>")
        );
    }
}