FirstRunServicesWindow Class Reference

#include <first-run-services-window.hpp>

Inheritance diagram for FirstRunServicesWindow:

Classes
struct	ServiceInfo

Public Member Functions
	FirstRunServicesWindow ()

Static Public Member Functions
static void	maybe_show ()

Protected Member Functions
bool	on_close_request () override

Private Member Functions
void	build_headerbar ()
void	build_ui ()
void	load_current_states ()
void	select_all ()
void	select_minimal ()
void	apply_and_close ()
void	on_minimize_clicked ()
void	on_close_clicked ()
bool	is_user_service_enabled (const std::string &service_name)
bool	enable_user_service (const std::string &service_name)
bool	disable_user_service (const std::string &service_name)
bool	is_system_service_enabled (const std::string &unit_name)
bool	enable_system_service (const std::string &unit_name)
bool	disable_system_service (const std::string &unit_name)

Private Attributes
std::vector< Gtk::CheckButton * >	check_buttons
std::vector< std::string >	service_names
Gtk::Button *	btn_minimize = nullptr
Gtk::Button *	btn_close = nullptr

Detailed Description

Definition at line 28 of file first-run-services-window.hpp.

Constructor & Destructor Documentation

FirstRunServicesWindow()

FirstRunServicesWindow::FirstRunServicesWindow

(

)

Definition at line 229 of file first-run-services-window.cpp.

{
    set_title("");
    set_resizable(true);
    set_default_size(720, 640);
    set_size_request(680, 580);
    set_modal(true);
 
    build_headerbar();
    build_ui();
    load_current_states();
}

References build_headerbar(), build_ui(), and load_current_states().

Referenced by maybe_show().

Member Function Documentation

apply_and_close()

void FirstRunServicesWindow::apply_and_close ( )

private

Definition at line 599 of file first-run-services-window.cpp.

{
    for (size_t i = 0; i < check_buttons.size(); ++i)
    {
        const auto& unit = service_names[i];
        bool want = check_buttons[i]->get_active();
 
        bool current = false;
        if (is_system_unit(unit))
            current = is_system_service_enabled(unit);
        else
            current = is_user_service_enabled(unit);
 
        if (want == current)
            continue;
 
        if (is_system_unit(unit))
        {
            if (want) enable_system_service(unit);
            else      disable_system_service(unit);
        }
        else
        {
            if (want) enable_user_service(unit);
            else      disable_user_service(unit);
        }
    }
 
    save_config(service_names, check_buttons);
 
    install_ca_system();
 
    std::thread([]() { install_ca_nss_user(); }).detach();
 
    hide();
}

References check_buttons, disable_system_service(), disable_user_service(), enable_system_service(), enable_user_service(), install_ca_nss_user(), install_ca_system(), is_system_service_enabled(), is_user_service_enabled(), save_config(), and service_names.

Referenced by build_ui(), on_close_clicked(), and on_close_request().

build_headerbar()

void FirstRunServicesWindow::build_headerbar ( )

private

Definition at line 257 of file first-run-services-window.cpp.

{
    auto header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->get_style_context()->add_class("custom-headerbar");
 
    auto title_label = Gtk::make_managed<Gtk::Label>(_("BastionGuard - Configurazione iniziale"));
    title_label->get_style_context()->add_class("header-title");
    title_label->set_halign(Gtk::Align::CENTER);
    title_label->set_valign(Gtk::Align::CENTER);
    header->set_title_widget(*title_label);
 
    auto header_right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
 
    try {
        auto pix_min = Gdk::Pixbuf::create_from_file(resource("icon-minimize.png"), 32, 32, true);
        btn_minimize = Gtk::make_managed<Gtk::Button>();
        btn_minimize->set_child(*Gtk::make_managed<Gtk::Image>(pix_min));
        btn_minimize->get_style_context()->add_class("header-button");
        header_right->append(*btn_minimize);
        btn_minimize->signal_clicked().connect(sigc::mem_fun(*this, &FirstRunServicesWindow::on_minimize_clicked));
    } catch (...) {
        std::cerr << _("⚠ Errore caricamento icona minimize\n");
    }
 
    try {
        auto pix_close = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 32, 32, true);
        btn_close = Gtk::make_managed<Gtk::Button>();
        btn_close->set_child(*Gtk::make_managed<Gtk::Image>(pix_close));
        btn_close->get_style_context()->add_class("header-button");
        header_right->append(*btn_close);
        btn_close->signal_clicked().connect(sigc::mem_fun(*this, &FirstRunServicesWindow::on_close_clicked));
    } catch (...) {
        std::cerr << _("⚠ Errore caricamento icona close\n");
    }
 
    header->pack_end(*header_right);
    set_titlebar(*header);
}

References _, btn_close, btn_minimize, on_close_clicked(), on_minimize_clicked(), and resource().

Referenced by FirstRunServicesWindow().

build_ui()

void FirstRunServicesWindow::build_ui ( )

private

Definition at line 298 of file first-run-services-window.cpp.

{
    auto main_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
    main_box->set_vexpand(false);
    main_box->set_hexpand(true);
    set_child(*main_box);
 
    auto sidebar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
    sidebar->set_size_request(240, -1);
    sidebar->set_vexpand(false);
    sidebar->get_style_context()->add_class("sidebar");
 
    auto header_sidebar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    header_sidebar->get_style_context()->add_class("sidebar-header");
 
    try {
        auto pixbuf = Gdk::Pixbuf::create_from_file(resource("logo-sidebar.png"), 96, 96, true);
        auto logo = Gtk::make_managed<Gtk::Image>(pixbuf);
        header_sidebar->append(*logo);
    } catch (...) {
        std::cerr << _("⚠ Impossibile caricare logo-sidebar.png\n");
    }
 
    auto lbl = Gtk::make_managed<Gtk::Label>("BastionGuard");
    lbl->set_halign(Gtk::Align::START);
    lbl->get_style_context()->add_class("sidebar-title");
    header_sidebar->append(*lbl);
 
    sidebar->append(*header_sidebar);
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(true);
    sidebar->append(*spacer);
 
    main_box->append(*sidebar);
 
    auto content_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
    content_box->set_margin(24);
    content_box->set_hexpand(true);
    content_box->set_vexpand(false);
    content_box->get_style_context()->add_class("content");
    main_box->append(*content_box);
 
    auto title = Gtk::make_managed<Gtk::Label>(_("Scegli quali servizi di protezione attivare"));
    title->get_style_context()->add_class("title");
    content_box->append(*title);
 
    auto subtitle = Gtk::make_managed<Gtk::Label>(
        _("I servizi selezionati verranno avviati automaticamente al login.\n"
          "Potrai modificarli in qualsiasi momento dalle impostazioni."));
    subtitle->set_wrap();
    subtitle->add_css_class("alert-info");
    content_box->append(*subtitle);
 
    auto grid = Gtk::make_managed<Gtk::Grid>();
    grid->set_column_spacing(20);
    grid->set_row_spacing(10);
    grid->set_margin_top(12);
    grid->set_margin_bottom(12);
    grid->set_vexpand(false);
    grid->set_valign(Gtk::Align::START);
    content_box->append(*grid);
 
    std::vector<ServiceInfo> services = {
        {"BastionGuard-privacyd.service", _("Privacy Guard"), _("Blocco microfono e webcam quando non in uso")},
        {"BastionGuard-ransomware-alert.service", _("Ransomware Alert"), _("Notifiche su possibili attività ransomware")},
        {"BastionGuard-ransomware-realtime-alert.service", _("Ransomware Realtime Alert"), _("Avvisi in tempo reale su comportamenti sospetti")},
        {"BastionGuard-ransomware-scanner.service", _("Ransomware Scanner"), _("Scansione periodica alla ricerca di comportamenti malevoli")},
        {"BastionGuard-useragent.service", _("User-Agent Randomizer"), _("Modifica user-agent per aumentare anonimato")},
        {"BastionGuard-pacd.service", _("PAC Daemon"), _("Gestione automatica di proxy PAC sicuri")},
        {"BastionGuard-phishing-scanner.service", _("Phishing Scanner (System)"), _("Scansione anti-phishing a livello di sistema")},
        {"BastionGuard-mailproxy.service", _("Mail Proxy"), _("Proxy SMTP locale per protezione email in uscita")},
        {"BastionGuard-usbd.service", _("USB Protection (System)"), _("Monitoraggio e blocco dispositivi USB sospetti")},
        {"BastionGuard-ransomware-realtime.service", _("Ransomware Realtime (System)"), _("Monitor realtime ransomware a livello di sistema")},
    };
 
    if (BastionGuard::Platform::cef_available()) {
        services.push_back({"BastionGuard-cef.service", _("CEF Sandbox Service"), _("Supporto in background per pagamenti sicuri con CEF")});
    }
 
    int row = 0;
    for (const auto& svc : services)
    {
        auto check = Gtk::make_managed<Gtk::CheckButton>(svc.label);
        check->set_active(true);
 
        auto desc = Gtk::make_managed<Gtk::Label>(svc.description);
        desc->add_css_class("label");
        desc->set_wrap();
        desc->set_halign(Gtk::Align::START);
        desc->set_margin_start(24);
        desc->set_max_width_chars(50);
        desc->set_ellipsize(Pango::EllipsizeMode::END);
 
        grid->attach(*check, 0, row, 1, 1);
        grid->attach(*desc,  1, row, 1, 1);
 
        check_buttons.push_back(check);
        service_names.push_back(svc.name);
 
        row++;
    }
 
    auto btn_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 12);
    btn_box->set_halign(Gtk::Align::END);
    btn_box->set_margin_top(16);
    btn_box->set_vexpand(false);
 
    auto btn_minimal = Gtk::make_managed<Gtk::Button>(_("Configurazione minima"));
    btn_minimal->get_style_context()->add_class("btn-warning");
    btn_minimal->signal_clicked().connect(sigc::mem_fun(*this, &FirstRunServicesWindow::select_minimal));
 
    auto btn_all = Gtk::make_managed<Gtk::Button>(_("Attiva tutto"));
    btn_all->get_style_context()->add_class("btn-primary");
    btn_all->signal_clicked().connect(sigc::mem_fun(*this, &FirstRunServicesWindow::select_all));
 
    auto btn_apply = Gtk::make_managed<Gtk::Button>(_("Applica e continua"));
    btn_apply->get_style_context()->add_class("btn-success");
    btn_apply->signal_clicked().connect(sigc::mem_fun(*this, &FirstRunServicesWindow::apply_and_close));
 
    btn_box->append(*btn_minimal);
    btn_box->append(*btn_all);
    btn_box->append(*btn_apply);
 
    content_box->append(*btn_box);
}

References _, apply_and_close(), BastionGuard::Platform::cef_available(), check_buttons, resource(), select_all(), select_minimal(), and service_names.

Referenced by FirstRunServicesWindow().

disable_system_service()

bool FirstRunServicesWindow::disable_system_service ( const std::string & unit_name )

private

Definition at line 732 of file first-run-services-window.cpp.

{
    pkexec_servicectl({"stop", unit_name}, false);
    return pkexec_servicectl({"disable", "--now", unit_name}, false);
}

Referenced by apply_and_close().

disable_user_service()

bool FirstRunServicesWindow::disable_user_service ( const std::string & service_name )

private

Definition at line 690 of file first-run-services-window.cpp.

{
    run_cmd({"/usr/libexec/bastionguard/bastionguard-service", "--user", "stop", service_name});
    return run_cmd({"/usr/libexec/bastionguard/bastionguard-service", "--user", "disable", "--now", service_name});
}

Referenced by apply_and_close().

enable_system_service()

bool FirstRunServicesWindow::enable_system_service ( const std::string & unit_name )

private

Definition at line 723 of file first-run-services-window.cpp.

{
    if (!pkexec_servicectl({"enable", "--now", unit_name}, false))
        return false;
 
    pkexec_servicectl({"start", unit_name}, false);
    return true;
}

Referenced by apply_and_close().

enable_user_service()

bool FirstRunServicesWindow::enable_user_service ( const std::string & service_name )

private

Definition at line 681 of file first-run-services-window.cpp.

{
    if (!run_cmd({"/usr/libexec/bastionguard/bastionguard-service", "--user", "enable", "--now", service_name}))
        return false;
 
    run_cmd({"/usr/libexec/bastionguard/bastionguard-service", "--user", "start", service_name});
    return true;
}

Referenced by apply_and_close().

is_system_service_enabled()

bool FirstRunServicesWindow::is_system_service_enabled ( const std::string & unit_name )

private

Definition at line 696 of file first-run-services-window.cpp.

{
    try
    {
        auto proc = Gio::Subprocess::create(
            {"/usr/libexec/bastionguard/bastionguard-service", "--system", "is-enabled", unit_name},
            Gio::Subprocess::Flags::STDOUT_PIPE |
            Gio::Subprocess::Flags::STDERR_PIPE
        );
 
        auto [stdout_str, stderr_str] = proc->communicate_utf8("");
 
        if (!proc->get_successful())
            return false;
 
        std::string result = stdout_str.raw();
        result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
        result.erase(std::remove(result.begin(), result.end(), '\r'), result.end());
 
        return result == "enabled";
    }
    catch (...)
    {
        return false;
    }
}

Referenced by apply_and_close(), and load_current_states().

is_user_service_enabled()

bool FirstRunServicesWindow::is_user_service_enabled ( const std::string & service_name )

private

Definition at line 654 of file first-run-services-window.cpp.

{
    try
    {
        auto proc = Gio::Subprocess::create(
            {"/usr/libexec/bastionguard/bastionguard-service", "--user", "is-enabled", service_name},
            Gio::Subprocess::Flags::STDOUT_PIPE |
            Gio::Subprocess::Flags::STDERR_PIPE
        );
 
        auto [stdout_str, stderr_str] = proc->communicate_utf8("");
 
        if (!proc->get_successful())
            return false;
 
        std::string result = stdout_str.raw();
        result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
        result.erase(std::remove(result.begin(), result.end(), '\r'), result.end());
 
        return result == "enabled";
    }
    catch (...)
    {
        return false;
    }
}

Referenced by apply_and_close(), and load_current_states().

load_current_states()

void FirstRunServicesWindow::load_current_states ( )

private

Definition at line 425 of file first-run-services-window.cpp.

{
    for (size_t i = 0; i < check_buttons.size(); ++i)
    {
        const auto& unit = service_names[i];
 
        bool enabled = false;
        if (is_system_unit(unit))
            enabled = is_system_service_enabled(unit);
        else
            enabled = is_user_service_enabled(unit);
 
        check_buttons[i]->set_active(enabled);
    }
}

References check_buttons, is_system_service_enabled(), is_user_service_enabled(), and service_names.

Referenced by FirstRunServicesWindow().

maybe_show()

void FirstRunServicesWindow::maybe_show ( )

static

Definition at line 242 of file first-run-services-window.cpp.

{
    if (Glib::file_test(FLAG_FILE, Glib::FileTest::EXISTS))
        return;
 
    auto* win = new FirstRunServicesWindow();
 
    win->signal_hide().connect([win]() {
        touch_flag_file();
        delete win;
    });
 
    win->show();
}

References FirstRunServicesWindow(), and touch_flag_file().

Referenced by ClamApp::on_activate().

on_close_clicked()

void FirstRunServicesWindow::on_close_clicked ( )

private

Definition at line 643 of file first-run-services-window.cpp.

{
    apply_and_close();
}

References apply_and_close().

Referenced by build_headerbar().

on_close_request()

bool FirstRunServicesWindow::on_close_request ( )

overrideprotected

Definition at line 648 of file first-run-services-window.cpp.

{
    apply_and_close();
    return false;
}

References apply_and_close().

on_minimize_clicked()

void FirstRunServicesWindow::on_minimize_clicked ( )

private

Definition at line 636 of file first-run-services-window.cpp.

{
#if GTKMM_CHECK_VERSION(4,10,0)
    hide();
#endif
}

Referenced by build_headerbar().

select_all()

void FirstRunServicesWindow::select_all ( )

private

Definition at line 441 of file first-run-services-window.cpp.

{
    for (auto* ch : check_buttons)
        ch->set_active(true);
}

References check_buttons.

Referenced by build_ui().

select_minimal()

void FirstRunServicesWindow::select_minimal ( )

private

Definition at line 447 of file first-run-services-window.cpp.

{
    std::set<std::string> minimal = {
        "BastionGuard-usbd.service",
        "BastionGuard-privacyd.service",
        "BastionGuard-ransomware-realtime-alert.service"
    };
 
    for (size_t i = 0; i < check_buttons.size(); ++i)
    {
        check_buttons[i]->set_active(minimal.contains(service_names[i]));
    }
}

References check_buttons, and service_names.

Referenced by build_ui().

Member Data Documentation

btn_close

Gtk::Button* FirstRunServicesWindow::btn_close = nullptr

private

Definition at line 63 of file first-run-services-window.hpp.

Referenced by build_headerbar().

btn_minimize

Gtk::Button* FirstRunServicesWindow::btn_minimize = nullptr

private

Definition at line 62 of file first-run-services-window.hpp.

Referenced by build_headerbar().

check_buttons

std::vector<Gtk::CheckButton*> FirstRunServicesWindow::check_buttons

private

Definition at line 45 of file first-run-services-window.hpp.

Referenced by apply_and_close(), build_ui(), load_current_states(), select_all(), and select_minimal().

service_names

std::vector<std::string> FirstRunServicesWindow::service_names

private

Definition at line 46 of file first-run-services-window.hpp.

Referenced by apply_and_close(), build_ui(), load_current_states(), and select_minimal().

---

The documentation for this class was generated from the following files:

• BastionGuard/src/first_run/first-run-services-window.hpp
• BastionGuard/src/first_run/first-run-services-window.cpp