SettingsPage.cpp

Go to the documentation of this file.

#include "SettingsPage.hpp"
 
#include <glibmm/i18n.h>
#include <glibmm/miscutils.h>
#include <glibmm/markup.h>
 
#include <cstdlib>
 
#ifndef BSC_SERVICECTL_PATH
#define BSC_SERVICECTL_PATH "/usr/libexec/bastionguard/bastionguard-service"
#endif
#include <filesystem>
#include <fstream>
 
namespace fs = std::filesystem;
 
namespace {
    constexpr const char* kServiceName = "bsc-daemon.service";
    constexpr const char* kAutostartPath = "/etc/xdg/autostart/bastionguard-sc-autostart.desktop";
    constexpr const char* kFallbackAutostartPath = "/etc/xdg/autostart/bastionguard-sc.desktop";
    constexpr const char* kAutostartBackupPath = "/etc/xdg/autostart/bastionguard-sc-autostart.desktop.bak";
 
    void set_badge_class(Gtk::Widget& w, const char* css_class)
    {
        w.remove_css_class("status-badge-success");
        w.remove_css_class("status-badge-danger");
        w.remove_css_class("status-badge-warning");
        w.remove_css_class("status-badge-info");
 
        if (css_class && *css_class) {
            w.add_css_class(css_class);
        }
    }
}
 
SettingsPage::SettingsPage()
: Gtk::Box(Gtk::Orientation::VERTICAL, 0),
m_applyButton(_("Applica")),
m_refreshButton(_("Aggiorna stato"))
{
    const auto cfgDir = Glib::get_user_config_dir() + "/bastionguard-sc";
    m_configPath = cfgDir + "/service-control.ini";
    m_backupPath = kAutostartBackupPath;
 
    buildUi();
    loadPreference();
    refreshState();
}
 
void SettingsPage::setProtectionEnabled(bool enabled)
{
    m_savedEnabled = enabled;
    m_updatingSwitch = true;
    m_enableSwitch.set_active(enabled);
    m_updatingSwitch = false;
}
 
void SettingsPage::setSystemIntegrationStatus(const std::string& text)
{
    m_statusLabel.set_text(text);
}
 
void SettingsPage::buildUi()
{
    set_hexpand(true);
    set_vexpand(true);
 
    m_scroll.set_policy(Gtk::PolicyType::NEVER, Gtk::PolicyType::AUTOMATIC);
    m_scroll.set_hexpand(true);
    m_scroll.set_vexpand(true);
 
    m_content.set_margin_top(24);
    m_content.set_margin_bottom(24);
    m_content.set_margin_start(24);
    m_content.set_margin_end(24);
    m_content.set_hexpand(true);
    m_content.set_spacing(16);
 
    m_title.set_markup(
        "<span size='xx-large' weight='bold'>" +
        Glib::Markup::escape_text(_("Impostazioni")) +
        "</span>");
    m_title.set_halign(Gtk::Align::START);
 
    m_intro.set_text(_("Da questa pagina puoi attivare o disattivare BastionGuard™ Secure Connection in modo persistente. La scelta viene salvata in ~/.config; quando disattivi viene fermato/disabilitato bsc-daemon, l'autostart viene rimosso da /etc/xdg/autostart dopo backup nello stesso percorso e i flag vengono impostati a false."));
    m_intro.add_css_class("alert-info");
    m_intro.set_wrap(true);
    m_intro.set_halign(Gtk::Align::START);
    m_intro.set_justify(Gtk::Justification::LEFT);
    m_intro.set_margin_bottom(4);
 
    // =========================
    // Card: Protezione di sistema
    // =========================
    m_serviceFrame.set_label(_("Protezione di sistema"));
    m_serviceFrame.set_child(m_serviceBox);
 
    m_serviceBox.set_margin_top(12);
    m_serviceBox.set_margin_bottom(12);
    m_serviceBox.set_margin_start(12);
    m_serviceBox.set_margin_end(12);
    m_serviceBox.set_spacing(12);
    m_serviceBox.add_css_class("settings-card");
 
    auto serviceHeader = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 12);
    serviceHeader->set_hexpand(true);
    serviceHeader->set_halign(Gtk::Align::FILL);
 
    m_serviceTitle.set_text(_("Protezione di sistema"));
    m_serviceTitle.set_halign(Gtk::Align::START);
    m_serviceTitle.set_hexpand(true);
    m_serviceTitle.add_css_class("settings-card-title");
 
    m_serviceBadge.set_halign(Gtk::Align::END);
    m_serviceBadge.set_valign(Gtk::Align::CENTER);
 
    serviceHeader->append(m_serviceTitle);
    serviceHeader->append(m_serviceBadge);
 
    auto switchRow = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 12);
    switchRow->set_halign(Gtk::Align::FILL);
    switchRow->set_hexpand(true);
 
    m_enableLabel.set_text(_("BastionGuard™ Secure Connection attivo"));
    m_enableLabel.set_halign(Gtk::Align::START);
    m_enableLabel.set_hexpand(true);
    m_enableLabel.set_valign(Gtk::Align::CENTER);
 
    // Il CSS dell'app usa un reset globale (`all: unset`), quindi i widget
    // nativi come Gtk::Switch devono avere dimensioni/stile espliciti.
    // Senza questo il controllo può essere presente nel layout ma invisibile.
    m_enableSwitch.set_halign(Gtk::Align::END);
    m_enableSwitch.set_valign(Gtk::Align::CENTER);
    m_enableSwitch.set_size_request(56, 30);
    m_enableSwitch.add_css_class("bsc-toggle-switch");
    m_enableSwitch.set_tooltip_text(_("Attiva o disattiva l'avvio automatico e bsc-daemon"));
 
    switchRow->append(m_enableLabel);
    switchRow->append(m_enableSwitch);
 
    m_statusLabel.set_wrap(true);
    m_statusLabel.set_halign(Gtk::Align::START);
    m_statusLabel.set_xalign(0.0f);
    m_statusLabel.set_selectable(true);
 
    m_infoLabel.set_wrap(true);
    m_infoLabel.set_halign(Gtk::Align::START);
    m_infoLabel.set_xalign(0.0f);
    m_infoLabel.set_text(_("Disattivando vengono eseguite queste operazioni: salvataggio di enabled=false, autostart_enabled=false e daemon_enabled=false, backup dell'autostart in /etc/xdg/autostart/bastionguard-sc-autostart.desktop.bak, rimozione dell'autostart attivo e disattivazione di bsc-daemon tramite il gestore servizi. Riattivando, il backup viene ripristinato e il servizio viene riabilitato."));
    m_infoLabel.add_css_class("alert-info");
 
    auto buttons = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    buttons->append(m_applyButton);
    buttons->append(m_refreshButton);
 
    m_serviceBox.append(*serviceHeader);
    m_serviceBox.append(*switchRow);
    m_serviceBox.append(m_statusLabel);
    m_serviceBox.append(m_infoLabel);
    m_serviceBox.append(*buttons);
 
    // =========================
    // Card: Stato rilevato
    // =========================
    m_detailsFrame.set_label(_("Stato rilevato"));
    m_detailsFrame.set_child(m_detailsBox);
 
    m_detailsBox.set_margin_top(12);
    m_detailsBox.set_margin_bottom(12);
    m_detailsBox.set_margin_start(12);
    m_detailsBox.set_margin_end(12);
    m_detailsBox.set_spacing(8);
    m_detailsBox.add_css_class("settings-card");
 
    auto detailsHeader = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 12);
    detailsHeader->set_hexpand(true);
    detailsHeader->set_halign(Gtk::Align::FILL);
 
    m_detailsTitle.set_text(_("Stato rilevato"));
    m_detailsTitle.set_halign(Gtk::Align::START);
    m_detailsTitle.set_hexpand(true);
    m_detailsTitle.add_css_class("settings-card-title");
 
    m_detailsBadge.set_halign(Gtk::Align::END);
    m_detailsBadge.set_valign(Gtk::Align::CENTER);
 
    detailsHeader->append(m_detailsTitle);
    detailsHeader->append(m_detailsBadge);
 
    m_savedPrefLabel.set_halign(Gtk::Align::START);
    m_savedPrefLabel.set_xalign(0.0f);
 
    m_serviceStateLabel.set_halign(Gtk::Align::START);
    m_serviceStateLabel.set_xalign(0.0f);
 
    m_autostartStateLabel.set_halign(Gtk::Align::START);
    m_autostartStateLabel.set_xalign(0.0f);
 
    m_backupStateLabel.set_halign(Gtk::Align::START);
    m_backupStateLabel.set_xalign(0.0f);
 
    m_detailsBox.append(*detailsHeader);
    m_detailsBox.append(m_savedPrefLabel);
    m_detailsBox.append(m_serviceStateLabel);
    m_detailsBox.append(m_autostartStateLabel);
    m_detailsBox.append(m_backupStateLabel);
 
    m_enableSwitch.property_active().signal_changed().connect([this]() {
        if (m_updatingSwitch) return;
 
        const bool enabled = m_enableSwitch.get_active();
        m_statusLabel.set_text(enabled
            ? _("Attivazione richiesta dalle impostazioni...")
            : _("Disattivazione richiesta dalle impostazioni..."));
        m_signalToggleProtectionRequested.emit(enabled);
    });
 
    m_applyButton.signal_clicked().connect([this]() {
        const bool enabled = m_enableSwitch.get_active();
        m_statusLabel.set_text(enabled
            ? _("Attivazione richiesta dalle impostazioni...")
            : _("Disattivazione richiesta dalle impostazioni..."));
        m_signalToggleProtectionRequested.emit(enabled);
    });
 
    m_refreshButton.signal_clicked().connect([this]() {
        refreshState();
    });
 
    m_content.append(m_title);
    m_content.append(m_intro);
    m_content.append(m_serviceFrame);
    m_content.append(m_detailsFrame);
 
    m_scroll.set_child(m_content);
    append(m_scroll);
}
 
void SettingsPage::loadPreference()
{
    m_savedEnabled = true;
 
    std::ifstream in(m_configPath);
    std::string line;
    while (std::getline(in, line)) {
        if (line == "enabled=false") m_savedEnabled = false;
        if (line == "enabled=true") m_savedEnabled = true;
        if (line == "autostart_enabled=false") m_savedEnabled = false;
        if (line == "daemon_enabled=false") m_savedEnabled = false;
    }
 
    m_updatingSwitch = true;
    m_enableSwitch.set_active(m_savedEnabled);
    m_updatingSwitch = false;
}
 
 
bool SettingsPage::serviceEnabled() const
{
    const std::string cmd =
        std::string(BSC_SERVICECTL_PATH) + " --system is-enabled " +
        kServiceName + " >/dev/null 2>&1";
    return std::system(cmd.c_str()) == 0;
}
 
bool SettingsPage::autostartInstalled() const
{
    return fs::exists(kAutostartPath) || fs::exists(kFallbackAutostartPath);
}
 
bool SettingsPage::backupExists() const
{
    return fs::exists(m_backupPath);
}
 
 
std::string SettingsPage::boolText(bool value)
{
    return value ? _("sì") : _("no");
}
 
 
void SettingsPage::refreshState()
{
    loadPreference();
 
    const bool svc = serviceEnabled();
    const bool autoStart = autostartInstalled();
    const bool backup = backupExists();
 
    const bool protectionActive = m_savedEnabled && svc && autoStart;
    const bool protectionInactive = !m_savedEnabled && !svc && !autoStart;
    const bool protectionPartial = !protectionActive && !protectionInactive;
 
    m_savedPrefLabel.set_text(
        _("Preferenza salvata in ~/.config: ") +
        std::string(m_savedEnabled ? _("attivo") : _("disattivato")));
 
    m_serviceStateLabel.set_text(
        _("Servizio di sistema abilitato: ") + boolText(svc));
 
    m_autostartStateLabel.set_text(
        _("Autostart presente in /etc/xdg/autostart: ") + boolText(autoStart));
 
    m_backupStateLabel.set_text(
        _("Backup autostart in /etc/xdg/autostart disponibile: ") + boolText(backup));
 
    if (m_statusLabel.get_text().empty()) {
        m_statusLabel.set_text(
            _("Usa questa pagina per applicare o ripristinare la configurazione di avvio di BastionGuard."));
    }
 
    if (protectionActive) {
        m_serviceBadge.set_text(_("Attivo"));
        m_detailsBadge.set_text(_("Coerente"));
        set_badge_class(m_serviceBadge, "status-badge-success");
        set_badge_class(m_detailsBadge, "status-badge-success");
    } else if (protectionInactive) {
        m_serviceBadge.set_text(_("Disattivato"));
        m_detailsBadge.set_text(_("Disattivato"));
        set_badge_class(m_serviceBadge, "status-badge-danger");
        set_badge_class(m_detailsBadge, "status-badge-danger");
    } else if (protectionPartial) {
        m_serviceBadge.set_text(_("Parziale"));
        m_detailsBadge.set_text(_("Incoerente"));
        set_badge_class(m_serviceBadge, "status-badge-warning");
        set_badge_class(m_detailsBadge, "status-badge-warning");
    } else {
        m_serviceBadge.set_text(_("Info"));
        m_detailsBadge.set_text(_("Info"));
        set_badge_class(m_serviceBadge, "status-badge-info");
        set_badge_class(m_detailsBadge, "status-badge-info");
    }
 
    m_updatingSwitch = true;
    m_enableSwitch.set_active(m_savedEnabled);
    m_updatingSwitch = false;
}