first-run-services-window.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 "first-run-services-window.hpp"
#include "../DistroUtils.hpp"
#include "Resource.hpp"
#include "StyleProvider.hpp"
 
#include <glib/gi18n.h>
#include <glibmm/fileutils.h>
#include <glibmm/datetime.h>
#include <glibmm/miscutils.h>
#include <giomm/file.h>
#include <giomm/subprocess.h>
 
#include <fstream>
#include <set>
#include <algorithm>
#include <iostream>
#include <filesystem>
#include <thread>
#include <vector>
#include <nlohmann/json.hpp>
 
using json = nlohmann::json;
 
namespace {
    const std::string FLAG_DIR  = Glib::get_user_config_dir() + "/BastionGuard";
    const std::string FLAG_FILE = FLAG_DIR + "/first-run-services-done";
 
    const std::string CONFIG_DIR  = Glib::get_user_config_dir() + "/BastionGuard";
    const std::string CONFIG_FILE = CONFIG_DIR + "/config.json";
 
    const std::set<std::string> SYSTEM_UNITS = {
        "BastionGuard-phishing-scanner.service",
        "BastionGuard-phishing-updater.service",
        "BastionGuard-phishing-updater.timer",
        "Bastionguard-privhelper.service",
        "bastionguard-sanesecurity.service",
        "bastionguard-sanesecurity.timer",
        "BastionGuard-ransomware-realtime.service",
        "BastionGuard-usbd.service",
    };
 
    static constexpr const char* CA_HELPER =
        "/usr/share/BastionGuard/data/scripts/install-ca-system.sh";
 
    static bool is_system_unit(const std::string& unit_name)
    {
        return SYSTEM_UNITS.contains(unit_name);
    }
 
    static bool run_cmd(const std::vector<std::string>& argv,
                        bool silence_stderr = true,
                        bool capture_stdout = false,
                        std::string* out_stdout = nullptr)
    {
        try
        {
            Gio::Subprocess::Flags flags = Gio::Subprocess::Flags::NONE;
 
            if (capture_stdout)
                flags |= Gio::Subprocess::Flags::STDOUT_PIPE;
 
            if (silence_stderr)
                flags |= Gio::Subprocess::Flags::STDERR_SILENCE;
            else
                flags |= Gio::Subprocess::Flags::STDERR_PIPE;
 
            auto proc = Gio::Subprocess::create(argv, flags);
 
            if (capture_stdout && out_stdout)
            {
                auto [stdout_str, stderr_str] = proc->communicate_utf8("");
                *out_stdout = stdout_str.raw();
                return proc->get_successful();
            }
 
            proc->wait();
            return proc->get_successful();
        }
        catch (...)
        {
            return false;
        }
    }
 
    static bool pkexec_servicectl(const std::vector<std::string>& args,
                                 bool silence_stderr = false)
    {
        std::vector<std::string> argv;
        argv.reserve(args.size() + 3);
        argv.push_back("pkexec");
        argv.push_back("/usr/libexec/bastionguard/bastionguard-service");
        argv.push_back("--system");
        argv.insert(argv.end(), args.begin(), args.end());
        return run_cmd(argv, silence_stderr);
    }
 
    static std::string get_user_intercept_ca_path()
    {
        return Glib::build_filename(
            Glib::get_home_dir(),
            ".local", "share", "BastionGuard", "certs", "intercept-ca.crt.pem");
    }
 
    static std::string get_system_fallback_ca_path()
    {
        return "/etc/BastionGuard/certs/intercept-ca.crt.pem";
    }
 
    static std::string resolve_ca_path()
    {
        const auto user_ca = get_user_intercept_ca_path();
        if (std::filesystem::exists(user_ca))
            return user_ca;
 
        const auto system_ca = get_system_fallback_ca_path();
        if (std::filesystem::exists(system_ca))
            return system_ca;
 
        return {};
    }
}
 
static void ensure_config_dir()
{
    Glib::RefPtr<Gio::File> dir = Gio::File::create_for_path(CONFIG_DIR);
 
    if (!dir->query_exists())
    {
        try
        {
            dir->make_directory_with_parents();
        }
        catch (const Glib::Error& ex)
        {
            std::cerr << _("Impossibile creare directory config: ") << ex.what() << std::endl;
        }
    }
}
 
static void ensure_flag_dir()
{
    Glib::RefPtr<Gio::File> dir = Gio::File::create_for_path(FLAG_DIR);
 
    if (!dir->query_exists())
    {
        try
        {
            dir->make_directory_with_parents();
        }
        catch (const Glib::Error& ex)
        {
            std::cerr << _("Impossibile creare directory flag: ") << ex.what() << std::endl;
        }
    }
}
 
static void touch_flag_file()
{
    ensure_flag_dir();
 
    try
    {
        std::ofstream touch(FLAG_FILE, std::ios::out | std::ios::trunc);
        touch.close();
    }
    catch (const std::exception& ex)
    {
        std::cerr << _("Errore durante scrittura flag file: ") << ex.what() << std::endl;
    }
}
 
static void save_config(const std::vector<std::string>& service_names,
                        const std::vector<Gtk::CheckButton*>& check_buttons)
{
    ensure_config_dir();
 
    json config;
    config["wizard_completed"] = true;
 
    Glib::DateTime now = Glib::DateTime::create_now_utc();
    config["installed_at"] = now.format("%FT%TZ");
 
    json services = json::object();
    for (size_t i = 0; i < service_names.size(); ++i)
    {
        services[service_names[i]] = check_buttons[i]->get_active();
    }
    config["services"] = services;
 
    try
    {
        std::ofstream file(CONFIG_FILE, std::ios::out | std::ios::trunc);
        if (file.is_open())
        {
            file << config.dump(2);
            file.close();
        }
        else
        {
            std::cerr << _("Errore: impossibile aprire config.json per scrittura") << std::endl;
        }
    }
    catch (const std::exception& ex)
    {
        std::cerr << _("Errore durante il salvataggio config: ") << ex.what() << std::endl;
    }
}
 
FirstRunServicesWindow::FirstRunServicesWindow()
{
    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();
}
 
void FirstRunServicesWindow::maybe_show()
{
    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();
}
 
void FirstRunServicesWindow::build_headerbar()
{
    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);
}
 
void FirstRunServicesWindow::build_ui()
{
    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);
}
 
void FirstRunServicesWindow::load_current_states()
{
    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);
    }
}
 
void FirstRunServicesWindow::select_all()
{
    for (auto* ch : check_buttons)
        ch->set_active(true);
}
 
void FirstRunServicesWindow::select_minimal()
{
    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]));
    }
}
 
 
static void install_ca_system()
{
    if (!BastionGuard::Platform::cef_available()) {
        std::cerr << _("[FirstRun] CA di sistema disabilitata: CEF non disponibile in questa build/distribuzione.\n");
        return;
    }
    const std::string ca_src = resolve_ca_path();
 
    if (ca_src.empty()) {
        std::cerr << _("[FirstRun] CA non trovata né nella home utente né in /etc, verrà installata al primo avvio CEF\n");
        return;
    }
 
    if (!std::filesystem::exists(CA_HELPER)) {
        std::cerr << _("[FirstRun] helper non trovato: ") << CA_HELPER << "\n";
        return;
    }
 
    std::cerr << _("[FirstRun] Installazione CA BastionGuard nel trust store...\n");
    std::cerr << _("[FirstRun] Uso certificato: ") << ca_src << "\n";
 
    bool ok = run_cmd({"pkexec", CA_HELPER, ca_src}, false);
    if (!ok) {
        std::cerr << _("[FirstRun] ⚠️  pkexec fallito, tentativo sudo...\n");
        ok = run_cmd({"sudo", "--non-interactive", CA_HELPER, ca_src}, false);
    }
 
    if (ok) {
        std::cerr << _("[FirstRun] ✅ CA installata nel sistema\n");
    } else {
        std::cerr << _("[FirstRun] ❌ Installazione CA fallita — verrà ritentata al primo avvio CEF\n");
        try {
            std::filesystem::remove(
                Glib::get_user_data_dir() + "/BastionGuard/ca-installed.stamp");
        } catch (...) {}
    }
}
 
static void install_ca_nss_user()
{
    if (!BastionGuard::Platform::cef_available()) {
        return;
    }
    const std::string ca_src = resolve_ca_path();
    if (ca_src.empty()) {
        std::cerr << _("[FirstRun] CA NSS utente non trovata\n");
        return;
    }
 
    auto nss_add = [&](const std::string& db) {
        if (!std::filesystem::exists(db))
            return;
 
        const std::string prefix =
            std::filesystem::exists(db + "/cert9.db") ? "sql:" : "dbm:";
 
        run_cmd({"certutil", "-D", "-d", prefix + db, "-n", "BastionGuard-CA"}, true);
 
        bool ok = run_cmd({"certutil", "-A",
            "-d", prefix + db,
            "-n", "BastionGuard-CA",
            "-t", "CT,,",
            "-i", ca_src}, false);
 
        if (ok)
            std::cerr << _("[FirstRun] ✅ NSS: ") << db << "\n";
    };
 
    const std::string home = Glib::get_home_dir();
 
 
    for (const auto& db : std::vector<std::string>{
            home + "/.pki/nssdb",
            home + "/snap/chromium/current/.pki/nssdb",
            home + "/.var/app/org.chromium.Chromium/.pki/nssdb",
            home + "/.var/app/com.google.Chrome/.pki/nssdb",
            home + "/.var/app/com.brave.Browser/.pki/nssdb",
            home + "/.var/app/com.microsoft.Edge/.pki/nssdb",
            home + "/.var/app/com.opera.Opera/.pki/nssdb",
            home + "/.var/app/com.vivaldi.Vivaldi/.pki/nssdb",
            home + "/.config/BraveSoftware/Brave-Browser/Default",
            home + "/.config/microsoft-edge/Default",
            home + "/.config/opera",
            home + "/.config/vivaldi/Default",
            home + "/.config/chromium/Default",
            home + "/.config/yandex-browser/Default",
    }) {
        nss_add(db);
    }
 
    auto is_profile = [](const std::string& n) {
        for (const auto& s : {
                 ".default",
                 ".default-release",
                 ".default-esr",
                 ".dev-edition-default",
                 "-release",
                 "-esr"
             }) {
            if (n.size() >= std::string(s).size() &&
                n.compare(n.size() - std::string(s).size(), std::string(s).size(), s) == 0)
                return true;
        }
        return n.size() > 9 && n[8] == '.';
    };
 
    for (const auto& base : std::vector<std::string>{
            home + "/.mozilla/firefox",
            home + "/.var/app/org.mozilla.firefox/.mozilla/firefox",
            home + "/.var/app/org.mozilla.firefoxesr/.mozilla/firefox",
            home + "/snap/firefox/current/.mozilla/firefox",
            home + "/.librewolf",
            home + "/.var/app/io.gitlab.librewolf-community/.librewolf",
            home + "/.waterfox",
            home + "/.floorp",
            home + "/.var/app/one.ablaze.floorp/.floorp",
            home + "/.zen",
            home + "/.var/app/io.github.zen_browser.zen/.zen",
            home + "/.icecat",
            home + "/.thunderbird",
            home + "/.var/app/org.mozilla.Thunderbird/.thunderbird",
            home + "/snap/thunderbird/current/.thunderbird",
    }) {
        if (!std::filesystem::exists(base))
            continue;
 
        try {
            for (const auto& e : std::filesystem::directory_iterator(base)) {
                if (e.is_directory() && is_profile(e.path().filename().string()))
                    nss_add(e.path().string());
            }
        } catch (...) {}
    }
 
    std::cerr << _("[FirstRun] ✅ NSS profili utente aggiornati\n");
}
 
void FirstRunServicesWindow::apply_and_close()
{
    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();
}
 
void FirstRunServicesWindow::on_minimize_clicked()
{
#if GTKMM_CHECK_VERSION(4,10,0)
    hide();
#endif
}
 
void FirstRunServicesWindow::on_close_clicked()
{
    apply_and_close();
}
 
bool FirstRunServicesWindow::on_close_request()
{
    apply_and_close();
    return false;
}
 
bool FirstRunServicesWindow::is_user_service_enabled(const std::string& service_name)
{
    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;
    }
}
 
bool FirstRunServicesWindow::enable_user_service(const std::string& service_name)
{
    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;
}
 
bool FirstRunServicesWindow::disable_user_service(const std::string& service_name)
{
    run_cmd({"/usr/libexec/bastionguard/bastionguard-service", "--user", "stop", service_name});
    return run_cmd({"/usr/libexec/bastionguard/bastionguard-service", "--user", "disable", "--now", service_name});
}
 
bool FirstRunServicesWindow::is_system_service_enabled(const std::string& unit_name)
{
    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;
    }
}
 
bool FirstRunServicesWindow::enable_system_service(const std::string& unit_name)
{
    if (!pkexec_servicectl({"enable", "--now", unit_name}, false))
        return false;
 
    pkexec_servicectl({"start", unit_name}, false);
    return true;
}
 
bool FirstRunServicesWindow::disable_system_service(const std::string& unit_name)
{
    pkexec_servicectl({"stop", unit_name}, false);
    return pkexec_servicectl({"disable", "--now", unit_name}, false);
}