SettingsPage.cpp File Reference

Go to the source code of this file.

Classes
struct	MailSignatureConfig
struct	MailRelayProfile
struct	MailSecurityConfig
struct	TbSmtpEntry
struct	TbIdentityEntry

Namespaces
namespace	anonymous_namespace{SettingsPage.cpp}

Enumerations
enum class	BypassKind {   Invalid , Domain , IPv4 , IPv6 ,   CIDR }

Functions
static bool	anonymous_namespace{SettingsPage.cpp}::run_cmd (const std::vector< std::string > &argv, std::string *out_stdout=nullptr, bool silence_stderr=true)
static bool	anonymous_namespace{SettingsPage.cpp}::pkexec_servicectl (const std::vector< std::string > &args, std::string *out_stdout=nullptr)
static std::string	mail_json_path_user ()
static std::string	iso_today_yyyy_mm_dd ()
static std::vector< std::string >	split_semicolon_list (const std::string &input)
static std::string	join_semicolon_list (const std::vector< std::string > &items)
static std::string	make_profile_id (const std::string &label)
static void	ensure_mail_json_exists ()
static bool	run_privhelper_and_capture (const std::vector< std::string > &args, std::string &stdout_out, std::string &stderr_out, int &exit_status)
static bool	write_mail_config_temp_json (const MailSecurityConfig &cfg, std::string &out_path)
static void	append_to_textbuffer (const Glib::RefPtr< Gtk::TextBuffer > &buffer, const Glib::ustring &text)
static MailSecurityConfig	load_mail_security_config ()
static bool	save_mail_security_config (const MailSecurityConfig &cfg)
static std::string	build_email_signature_preview_html (const MailSignatureConfig &sig)
static bool	is_clamav_signature_file (const std::filesystem::path &p)
static Gtk::Window *	create_log_popup (Gtk::Widget *owner, const Glib::RefPtr< Gtk::TextBuffer > &buffer)
static std::vector< std::filesystem::path >	list_clamav_signatures (const std::filesystem::path &dir)
static std::string	payments_json_path_user ()
static bool	tb_parse_pref_line (const std::string &line, std::string &key, std::string &value)
static std::map< std::string, std::map< std::string, std::string > >	tb_parse_ini_file (const std::string &path)
static std::string	tb_find_default_profile ()
static std::vector< MailRelayProfile >	tb_import_profiles (std::string &err_out)
static std::string	normalize_domain_or_url (const std::string &in_raw)
static void	ensure_payments_json_exists ()
static std::vector< std::string >	load_payments_domains ()
static bool	save_payments_domains (const std::vector< std::string > &domains_in, bool enabled_flag)
static bool	update_payments_enabled_only (bool enabled_flag)
static std::string	elev_cmd (const std::string &inner)
static bool	write_temp_script_and_elevate (const std::string &script_contents, std::string *out_log=nullptr, int *exit_code=nullptr)
std::pair< int, int >	read_webports_conf ()
bool	copy_with_pkexec (const std::string &src, const std::string &dst)
bool	restart_service (const std::string &svc)
bool	update_ports_in_file (const std::string &file, int http_port, int https_port)
std::string	detect_distro ()
static std::string	detect_webserver ()
std::pair< int, int >	read_current_ports (const std::string &)
bool	update_webserver_ports (const std::string &websrv, int http_port, int https_port)
std::string	anonymous_namespace{SettingsPage.cpp}::choose_clamd_conf_target ()
bool	anonymous_namespace{SettingsPage.cpp}::atomic_install_with_pkexec (const std::string &tmp_src, const std::string &target)
bool	anonymous_namespace{SettingsPage.cpp}::isServiceActive (const std::string &service, bool user=false)
bool	isClamonaccRunning ()
static std::string	normalize_locale (std::string s)
static std::vector< std::string >	load_proxy_bypass_domains ()
static bool	save_proxy_bypass_domains (const std::vector< std::string > &domains)
static BypassKind	classify_bypass_entry (const std::string &s_in)
void	show_service_error_dialog (const Glib::ustring &msg, const std::string &service)

Variables
static bool	updatingToggle = false
static std::map< std::string, bool >	toggleControlled

Enumeration Type Documentation

BypassKind

enum class BypassKind

strong

Enumerator
Invalid
Domain
IPv4
IPv6
CIDR

Definition at line 3885 of file SettingsPage.cpp.

{ Invalid, Domain, IPv4, IPv6, CIDR };

Function Documentation

append_to_textbuffer()

void append_to_textbuffer ( const Glib::RefPtr< Gtk::TextBuffer > & buffer, const Glib::ustring & text )

static

Definition at line 332 of file SettingsPage.cpp.

{
    buffer->insert(buffer->end(), text);
    auto mark = buffer->create_mark(buffer->end());
}

References append_to_textbuffer().

Referenced by append_to_textbuffer().

build_email_signature_preview_html()

std::string build_email_signature_preview_html ( const MailSignatureConfig & sig )

static

Definition at line 488 of file SettingsPage.cpp.

                                                                                    {
    std::ostringstream html;
 
    html << "<table cellpadding=\"0\" cellspacing=\"0\" border=\"0\" "
         << "style=\"font-family:Arial,Helvetica,sans-serif;font-size:14px;color:#212529;\">"
         << "<tr>";
 
    if (!sig.logo_path.empty()) {
        html << "<td style=\"vertical-align:top;padding-right:12px;\">"
             << "<img src=\"file://" << sig.logo_path << "\" alt=\"logo\" width=\"72\" "
             << "style=\"display:block;border:0;\">"
             << "</td>";
    }
 
    html << "<td style=\"vertical-align:top;\">";
 
    if (!sig.display_name.empty()) {
        html << "<div style=\"font-size:16px;font-weight:700;color:#0d6efd;\">"
             << sig.display_name << "</div>";
    }
 
    {
        std::string roleLine;
        if (!sig.job_title.empty()) roleLine += sig.job_title;
        if (!sig.job_title.empty() && !sig.company.empty()) roleLine += " · ";
        if (!sig.company.empty()) roleLine += sig.company;
 
        if (!roleLine.empty()) {
            html << "<div style=\"font-size:13px;color:#6c757d;\">"
                 << roleLine << "</div>";
        }
    }
 
    html << "<div style=\"margin-top:8px;\">";
 
    if (!sig.website.empty()) {
        html << "<a href=\"" << sig.website << "\" "
             << "style=\"color:#0d6efd;text-decoration:none;\">"
             << sig.website << "</a><br>";
    }
 
    if (!sig.phone.empty()) {
        html << "<span style=\"color:#212529;\">" << sig.phone << "</span><br>";
    }
 
    html << "<span style=\"color:#6c757d;\">Protected by BastionGuard</span>";
    html << "</div>";
    html << "</td></tr></table>";
 
    return html.str();
}

References build_email_signature_preview_html(), MailSignatureConfig::company, MailSignatureConfig::display_name, MailSignatureConfig::job_title, MailSignatureConfig::logo_path, MailSignatureConfig::phone, and MailSignatureConfig::website.

Referenced by build_email_signature_preview_html().

classify_bypass_entry()

BypassKind classify_bypass_entry ( const std::string & s_in )

static

Definition at line 3887 of file SettingsPage.cpp.

                                                               {
    if (s_in.empty()) return BypassKind::Invalid;
 
    // Strip eventuali bracket IPv6: [::1] → ::1
    std::string s = s_in;
    if (s.size() >= 2 && s.front() == '[' && s.back() == ']')
        s = s.substr(1, s.size() - 2);
 
    // Caso CIDR: c'è uno slash, tipo "1.2.3.0/24" o "2a01::/32"
    auto slash = s.find('/');
    if (slash != std::string::npos) {
        const std::string addr = s.substr(0, slash);
        const std::string mask = s.substr(slash + 1);
        if (addr.empty() || mask.empty()) return BypassKind::Invalid;
 
        // mask numerica
        for (char c : mask) if (!std::isdigit(static_cast<unsigned char>(c)))
            return BypassKind::Invalid;
        const int m = std::atoi(mask.c_str());
 
        in_addr v4{};
        in6_addr v6{};
        if (::inet_pton(AF_INET, addr.c_str(), &v4) == 1) {
            if (m < 0 || m > 32) return BypassKind::Invalid;
            return BypassKind::CIDR;
        }
        if (::inet_pton(AF_INET6, addr.c_str(), &v6) == 1) {
            if (m < 0 || m > 128) return BypassKind::Invalid;
            return BypassKind::CIDR;
        }
        return BypassKind::Invalid;
    }
 
    // Caso IPv4/IPv6 letterale
    {
        in_addr  v4{};
        in6_addr v6{};
        if (::inet_pton(AF_INET,  s.c_str(), &v4) == 1) return BypassKind::IPv4;
        if (::inet_pton(AF_INET6, s.c_str(), &v6) == 1) return BypassKind::IPv6;
    }
 
    // Caso dominio DNS: deve avere almeno un punto, solo caratteri DNS validi.
    if (s.find('.') == std::string::npos) return BypassKind::Invalid;
    for (char c : s) {
        const unsigned char uc = static_cast<unsigned char>(c);
        if (!(std::isalnum(uc) || c == '.' || c == '-' || c == '_'))
            return BypassKind::Invalid;
    }
    if (s.front() == '.' || s.back() == '.' || s.front() == '-')
        return BypassKind::Invalid;
 
    return BypassKind::Domain;
}

References AF_INET, AF_INET6, CIDR, classify_bypass_entry(), Domain, Invalid, IPv4, and IPv6.

Referenced by SettingsPage::build_proxy_bypass_tab(), and classify_bypass_entry().

copy_with_pkexec()

bool copy_with_pkexec	(	const std::string &	src,
		const std::string &	dst )

Definition at line 1158 of file SettingsPage.cpp.

{
    if (!fs::exists(src)) {
        std::cerr << _("[copy_with_pkexec] File sorgente non trovato: ") << src << std::endl;
        return false;
    }
 
    return bg_process::run({"pkexec", "/usr/bin/install", "-D", "-m", "0644", src, dst}).ok();
}

References _, copy_with_pkexec(), and bg_process::run().

Referenced by copy_with_pkexec().

create_log_popup()

Gtk::Window * create_log_popup ( Gtk::Widget * owner, const Glib::RefPtr< Gtk::TextBuffer > & buffer )

static

Definition at line 564 of file SettingsPage.cpp.

{
    auto* win = new Gtk::Window();
    win->set_title(_("Installazione navigazione sicura"));
    win->set_default_size(760, 420);
    win->set_modal(true);
    win->set_resizable(true);
 
    if (owner) {
        if (auto* root = owner->get_root()) {
            if (auto* parent = dynamic_cast<Gtk::Window*>(root)) {
                win->set_transient_for(*parent);
            }
        }
    }
 
    auto* outer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
    outer->set_margin_top(12);
    outer->set_margin_bottom(12);
    outer->set_margin_start(12);
    outer->set_margin_end(12);
 
    auto* title = Gtk::make_managed<Gtk::Label>(_("Log installazione"));
    title->set_halign(Gtk::Align::START);
    title->add_css_class("title-4");
    outer->append(*title);
 
    auto* text = Gtk::make_managed<Gtk::TextView>();
    text->set_buffer(buffer);
    text->set_editable(false);
    text->set_cursor_visible(false);
    text->set_monospace(true);
    text->set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
    text->set_vexpand(true);
    text->set_hexpand(true);
 
    auto* scroll = Gtk::make_managed<Gtk::ScrolledWindow>();
    scroll->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    scroll->set_min_content_height(320);
    scroll->set_child(*text);
    outer->append(*scroll);
 
    auto* btnClose = Gtk::make_managed<Gtk::Button>(_("Chiudi"));
    btnClose->set_halign(Gtk::Align::END);
    btnClose->signal_clicked().connect([win]() {
        win->hide();
        delete win;
    });
    outer->append(*btnClose);
 
    win->set_child(*outer);
    win->present();
    return win;
}

References _, and create_log_popup().

Referenced by SettingsPage::build_secure_payments_tab(), and create_log_popup().

detect_distro()

std::string detect_distro

(

)

Definition at line 1216 of file SettingsPage.cpp.

{
    std::string distro = "auto";
    std::string id;
 
 
    {
        const auto lsb = bg_process::run({"lsb_release", "-si"});
        std::string result = lsb.ok() ? lsb.output : std::string{};
 
        result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
        result.erase(std::remove(result.begin(), result.end(), '\r'), result.end());
 
        if (!result.empty() && result.find("n/a") == std::string::npos) {
            id = result;
        } else {
            std::cout << _("[detect_distro] lsb_release non fornisce info, fallback su /etc/os-release\n");
        }
    }
 
 
    if (id.empty() && std::filesystem::exists("/etc/os-release")) {
        std::ifstream file("/etc/os-release");
        std::string line;
        while (std::getline(file, line)) {
            if (line.rfind("ID=", 0) == 0)
                id = line.substr(3);
        }
        if (!id.empty() && id.front() == '"' && id.back() == '"')
            id = id.substr(1, id.size() - 2);
    }
 
 
    if (id.empty()) {
        if (std::filesystem::exists("/etc/arch-release")) id = "arch";
        else if (std::filesystem::exists("/etc/debian_version")) id = "debian";
        else if (std::filesystem::exists("/etc/redhat-release")) id = "fedora";
        else if (std::filesystem::exists("/etc/gentoo-release")) id = "gentoo";
        else if (std::filesystem::exists("/etc/slackware-version")) id = "slackware";
        else if (std::filesystem::exists("/usr/local/etc/rc.conf")) id = "bsd";
    }
 
    // Normalizza minuscolo
    std::transform(id.begin(), id.end(), id.begin(), ::tolower);
 
 
    if (id.find("debian") != std::string::npos || id.find("ubuntu") != std::string::npos || id.find("mint") != std::string::npos)
        distro = "debian";
    else if (id.find("fedora") != std::string::npos || id.find("rhel") != std::string::npos ||
             id.find("centos") != std::string::npos || id.find("alma") != std::string::npos || id.find("rocky") != std::string::npos)
        distro = "fedora";
    else if (id.find("arch") != std::string::npos || id.find("manjaro") != std::string::npos || id.find("endeavour") != std::string::npos)
        distro = "arch";
    else if (id.find("suse") != std::string::npos)
        distro = "opensuse";
    else if (id.find("gentoo") != std::string::npos)
        distro = "gentoo";
    else if (id.find("slackware") != std::string::npos)
        distro = "slackware";
    else if (id.find("bsd") != std::string::npos)
        distro = "bsd";
 
    std::cout << _("[detect_distro] Distribuzione rilevata: ") << distro << std::endl;
    return distro;
}

References _, detect_distro(), bg_process::Result::ok(), and bg_process::run().

Referenced by SettingsPage::build_options_tab(), and detect_distro().

detect_webserver()

std::string detect_webserver ( )

static

Definition at line 1283 of file SettingsPage.cpp.

                                    {
    using namespace std;
 
    auto is_active = [](const std::string& svc) -> bool {
        return bg_process::run({"/usr/libexec/bastionguard/bastionguard-service",
                                "--system", "is-active", svc}).ok();
    };
 
    auto cmd_exists = [](const std::string& cmd) -> bool {
        return bg_process::run({"which", "--", cmd}).ok();
    };
 
    if (is_active("apache2") || is_active("httpd") || cmd_exists("apache2") || cmd_exists("httpd")) {
        std::cout << _("[detect_webserver] Apache rilevato") << std::endl;
        return "apache";
    }
 
    if (is_active("nginx") || cmd_exists("nginx")) {
        std::cout << _("[detect_webserver] Nginx rilevato") << std::endl;
        return "nginx";
    }
 
    if (is_active("lshttpd") || is_active("lsws") || cmd_exists("lsws") || cmd_exists("lshttpd")) {
        std::cout << _("[detect_webserver] LiteSpeed rilevato") << std::endl;
        return "litespeed";
    }
 
    {
        const auto processes = bg_process::run({"ps", "-eo", "comm"});
        const std::string& out = processes.output;
        if (out.find("apache2") != std::string::npos || out.find("httpd") != std::string::npos) return "apache";
        if (out.find("nginx") != std::string::npos) return "nginx";
        if (out.find("lshttpd") != std::string::npos || out.find("lsws") != std::string::npos) return "litespeed";
    }
 
    std::cout << _("[detect_webserver] Nessun server rilevato") << std::endl;
    return "unknown";
}

References _, detect_webserver(), bg_process::Result::output, and bg_process::run().

Referenced by detect_webserver().

elev_cmd()

std::string elev_cmd ( const std::string & inner )

static

Definition at line 1074 of file SettingsPage.cpp.

                                                  {
    if (std::filesystem::exists("/usr/bin/pkexec")) return std::string("pkexec ") + inner;
    return std::string("sudo ") + inner;
}

References elev_cmd().

Referenced by elev_cmd().

ensure_mail_json_exists()

void ensure_mail_json_exists ( )

static

Definition at line 197 of file SettingsPage.cpp.

                                      {
    const std::string path = mail_json_path_user();
 
    try {
        std::filesystem::create_directories(std::filesystem::path(path).parent_path());
    } catch (...) {}
 
    if (std::filesystem::exists(path)) return;
 
    json j;
    j["version"] = 2;
    j["enabled"] = false;
    j["scan_outgoing"] = true;
    j["inject_signature"] = false;
    j["local_smtp_host"] = "127.0.0.1";
    j["local_smtp_port"] = 2525;
    j["default_profile_id"] = "default";
 
    j["profiles"] = json::array({
        {
            {"id", "default"},
            {"label", "Default"},
            {"match_from", json::array()},
            {"match_from_domain", json::array()},
            {"smtp_host", ""},
            {"smtp_port", 587},
            {"starttls", true},
            {"implicit_tls", false},
            {"username", ""},
            {"password", ""},
            {"signature", {
                {"display_name", ""},
                {"job_title", ""},
                {"company", ""},
                {"phone", ""},
                {"website", ""},
                {"logo_path", ""}
            }}
        }
    });
 
    std::ofstream out(path, std::ios::binary | std::ios::trunc);
    if (out.good()) out << j.dump(2);
}

References ensure_mail_json_exists(), and mail_json_path_user().

Referenced by ensure_mail_json_exists(), load_mail_security_config(), and save_mail_security_config().

ensure_payments_json_exists()

void ensure_payments_json_exists ( )

static

Definition at line 905 of file SettingsPage.cpp.

                                          {
    const std::string path = payments_json_path_user();
    try {
        fs::create_directories(fs::path(path).parent_path());
    } catch (...) {}
 
    if (fs::exists(path)) return;
 
    json j;
    j["version"] = 1;
    j["updated_at"] = iso_today_yyyy_mm_dd();
    j["enabled"] = false;
    j["list"] = json::array({
        "paypal.com",
        "stripe.com",
        "adyen.com",
        "klarna.com",
        "checkout.com",
        "worldpay.com",
        "braintreepayments.com",
        "braintreegateway.com",
        "amazonpay.com",
        "pay.google.com",
        "pay.apple.com",
        "amazon.com"
    });
 
    std::ofstream out(path, std::ios::binary | std::ios::trunc);
    if (out.good()) out << j.dump(2);
}

References ensure_payments_json_exists(), iso_today_yyyy_mm_dd(), and payments_json_path_user().

Referenced by SettingsPage::build_secure_payments_tab(), ensure_payments_json_exists(), load_payments_domains(), save_payments_domains(), and update_payments_enabled_only().

is_clamav_signature_file()

bool is_clamav_signature_file ( const std::filesystem::path & p )

static

Definition at line 540 of file SettingsPage.cpp.

{
    if (!p.has_extension()) return false;
 
    std::string ext = p.extension().string();
    std::transform(ext.begin(), ext.end(), ext.begin(),
                   [](unsigned char c){ return std::tolower(c); });
 
    // Estensioni comuni DB/firme ClamAV
    static const std::set<std::string> exts = {
        ".ndb", ".hdb", ".hsb", ".ldb", ".sdb", ".fp", ".mdb", ".pdb",
        ".wdb", ".cbc", ".cdb", ".cat"
    };
 
    if (exts.find(ext) == exts.end())
        return false;
 
    // scarta file nascosti
    const auto name = p.filename().string();
    if (!name.empty() && name[0] == '.') return false;
 
    return true;
}

References is_clamav_signature_file().

Referenced by is_clamav_signature_file(), and list_clamav_signatures().

isClamonaccRunning()

bool isClamonaccRunning

(

)

Definition at line 1437 of file SettingsPage.cpp.

                              {
        return isServiceActive("clamonacc.service") ||
               isServiceActive("clamav-clamonacc.service");
    }

References isClamonaccRunning(), and anonymous_namespace{SettingsPage.cpp}::isServiceActive().

Referenced by isClamonaccRunning(), and SettingsPage::SettingsPage().

iso_today_yyyy_mm_dd()

std::string iso_today_yyyy_mm_dd ( )

static

Definition at line 865 of file SettingsPage.cpp.

                                        {
    std::time_t t = std::time(nullptr);
    std::tm tm{};
    localtime_r(&t, &tm);
    std::ostringstream oss;
    oss << std::put_time(&tm, "%Y-%m-%d");
    return oss.str();
}

References iso_today_yyyy_mm_dd().

Referenced by ensure_payments_json_exists(), iso_today_yyyy_mm_dd(), save_mail_security_config(), save_payments_domains(), and update_payments_enabled_only().

join_semicolon_list()

std::string join_semicolon_list ( const std::vector< std::string > & items )

static

Definition at line 172 of file SettingsPage.cpp.

                                                                        {
    std::ostringstream oss;
    for (size_t i = 0; i < items.size(); ++i) {
        if (i) oss << "; ";
        oss << items[i];
    }
    return oss.str();
}

References join_semicolon_list().

Referenced by join_semicolon_list().

list_clamav_signatures()

std::vector< std::filesystem::path > list_clamav_signatures ( const std::filesystem::path & dir )

static

Definition at line 619 of file SettingsPage.cpp.

{
    std::vector<std::filesystem::path> out;
    std::error_code ec;
 
    if (!std::filesystem::exists(dir, ec) || !std::filesystem::is_directory(dir, ec))
        return out;
 
    for (const auto& entry : std::filesystem::directory_iterator(dir, ec))
    {
        if (ec) break;
        if (!entry.is_regular_file(ec)) continue;
 
        const auto& p = entry.path();
        if (is_clamav_signature_file(p))
            out.push_back(p);
    }
 
    std::sort(out.begin(), out.end(),
              [](const auto& a, const auto& b){
                  return a.filename().string() < b.filename().string();
              });
 
    return out;
}

References is_clamav_signature_file(), and list_clamav_signatures().

Referenced by list_clamav_signatures(), and SettingsPage::refresh_clamav_db_list().

load_mail_security_config()

MailSecurityConfig load_mail_security_config ( )

static

Definition at line 339 of file SettingsPage.cpp.

                                                      {
    ensure_mail_json_exists();
 
    MailSecurityConfig cfg;
    const std::string path = mail_json_path_user();
 
    try {
        std::ifstream in(path, std::ios::binary);
        if (!in.good()) return cfg;
 
        json j;
        in >> j;
 
        cfg.version          = j.value("version", 2);
        cfg.enabled          = j.value("enabled", false);
        cfg.scan_outgoing    = j.value("scan_outgoing", true);
        cfg.inject_signature = j.value("inject_signature", false);
        cfg.local_host       = j.value("local_smtp_host", std::string("127.0.0.1"));
        cfg.local_port             = j.value("local_smtp_port", 2525);
        cfg.local_tls_port         = j.value("local_smtp_tls_port", 2465);
        cfg.local_submission_port  = j.value("local_submission_port", 2587);
        cfg.advertise_starttls         = j.value("advertise_starttls", true);
        cfg.enable_implicit_tls_listener = j.value("enable_implicit_tls_listener", true);
        cfg.default_profile_id = j.value("default_profile_id", std::string("default"));
 
        if (j.contains("profiles") && j["profiles"].is_array()) {
            for (const auto& p : j["profiles"]) {
                if (!p.is_object()) continue;
 
                MailRelayProfile prof;
                prof.id           = p.value("id", std::string());
                prof.label        = p.value("label", std::string("Profile"));
                prof.smtp_host    = p.value("smtp_host", std::string());
                prof.smtp_port    = p.value("smtp_port", 587);
                prof.starttls     = p.value("starttls", true);
                prof.implicit_tls = p.value("implicit_tls", false);
                prof.username     = p.value("username", std::string());
                prof.password     = p.value("password", std::string());
 
                if (p.contains("match_from") && p["match_from"].is_array()) {
                    for (const auto& v : p["match_from"])
                        if (v.is_string()) prof.match_from.push_back(v.get<std::string>());
                }
 
                if (p.contains("match_from_domain") && p["match_from_domain"].is_array()) {
                    for (const auto& v : p["match_from_domain"])
                        if (v.is_string()) prof.match_from_domain.push_back(v.get<std::string>());
                }
 
                if (p.contains("signature") && p["signature"].is_object()) {
                    const auto& s = p["signature"];
                    prof.signature.display_name = s.value("display_name", std::string());
                    prof.signature.job_title    = s.value("job_title", std::string());
                    prof.signature.company      = s.value("company", std::string());
                    prof.signature.phone        = s.value("phone", std::string());
                    prof.signature.website      = s.value("website", std::string());
                    prof.signature.logo_path    = s.value("logo_path", std::string());
                }
 
                if (prof.id.empty())
                    prof.id = make_profile_id(prof.label);
 
                cfg.profiles.push_back(std::move(prof));
            }
        }
 
        if (cfg.profiles.empty()) {
            MailRelayProfile p;
            p.id = "default";
            p.label = "Default";
            cfg.profiles.push_back(std::move(p));
            cfg.default_profile_id = "default";
        }
    } catch (...) {
    }
 
    return cfg;
}

References MailSecurityConfig::advertise_starttls, MailSignatureConfig::company, MailSecurityConfig::default_profile_id, MailSignatureConfig::display_name, MailSecurityConfig::enable_implicit_tls_listener, MailSecurityConfig::enabled, ensure_mail_json_exists(), MailRelayProfile::id, MailRelayProfile::implicit_tls, MailSecurityConfig::inject_signature, MailSignatureConfig::job_title, MailRelayProfile::label, MailSecurityConfig::local_host, MailSecurityConfig::local_port, MailSecurityConfig::local_submission_port, MailSecurityConfig::local_tls_port, MailSignatureConfig::logo_path, mail_json_path_user(), make_profile_id(), MailRelayProfile::match_from, MailRelayProfile::match_from_domain, MailRelayProfile::password, MailSignatureConfig::phone, MailSecurityConfig::profiles, MailSecurityConfig::scan_outgoing, MailRelayProfile::signature, MailRelayProfile::smtp_host, MailRelayProfile::smtp_port, MailRelayProfile::starttls, MailRelayProfile::username, MailSecurityConfig::version, and MailSignatureConfig::website.

Referenced by SettingsPage::build_email_security_tab().

load_payments_domains()

std::vector< std::string > load_payments_domains ( )

static

Definition at line 936 of file SettingsPage.cpp.

                                                    {
    ensure_payments_json_exists();
 
    const std::string path = payments_json_path_user();
    std::vector<std::string> out;
 
    try {
        std::ifstream in(path, std::ios::binary);
        if (!in.good()) return out;
 
        json j;
        in >> j;
 
        if (j.contains("list") && j["list"].is_array()) {
            for (const auto& v : j["list"]) {
                if (!v.is_string()) continue;
                std::string d = normalize_domain_or_url(v.get<std::string>());
                if (!d.empty()) out.push_back(d);
            }
        }
 
        std::sort(out.begin(), out.end());
        out.erase(std::unique(out.begin(), out.end()), out.end());
 
    } catch (...) {
    }
 
    return out;
}

References ensure_payments_json_exists(), load_payments_domains(), normalize_domain_or_url(), and payments_json_path_user().

Referenced by SettingsPage::build_secure_payments_tab(), and load_payments_domains().

load_proxy_bypass_domains()

std::vector< std::string > load_proxy_bypass_domains ( )

static

Definition at line 3832 of file SettingsPage.cpp.

                                                        {
    const std::string path = Glib::build_filename(
        Glib::get_home_dir(), ".config", "BastionGuard", "proxy_bypass.json");
    std::vector<std::string> result;
    if (!std::filesystem::exists(path)) return result;
    try {
        std::ifstream f(path);
        nlohmann::json j; f >> j;
        if (j.contains("list") && j["list"].is_array())
            for (const auto& item : j["list"])
                if (item.is_string()) {
                    std::string d = item.get<std::string>();
                    if (!d.empty()) result.push_back(d);
                }
    } catch (...) {}
    return result;
}

References load_proxy_bypass_domains().

Referenced by SettingsPage::build_proxy_bypass_tab(), and load_proxy_bypass_domains().

mail_json_path_user()

std::string mail_json_path_user ( )

static

Definition at line 144 of file SettingsPage.cpp.

                                       {
    return Glib::get_home_dir() + "/.config/BastionGuard/mail.json";
}

References mail_json_path_user().

Referenced by ensure_mail_json_exists(), load_mail_security_config(), mail_json_path_user(), and save_mail_security_config().

make_profile_id()

std::string make_profile_id ( const std::string & label )

static

Definition at line 181 of file SettingsPage.cpp.

                                                         {
    std::string out;
    for (unsigned char c : label) {
        if (std::isalnum(c)) out += (char)std::tolower(c);
        else if (c == ' ' || c == '-' || c == '_') out += '-';
    }
 
    while (out.find("--") != std::string::npos)
        out = std::regex_replace(out, std::regex("--"), "-");
 
    if (!out.empty() && out.front() == '-') out.erase(out.begin());
    if (!out.empty() && out.back() == '-') out.pop_back();
    if (out.empty()) out = "profile";
    return out;
}

References make_profile_id().

Referenced by load_mail_security_config(), and make_profile_id().

normalize_domain_or_url()

std::string normalize_domain_or_url ( const std::string & in_raw )

static

Definition at line 874 of file SettingsPage.cpp.

                                                                  {
    std::string in = in_raw;
    auto l = in.find_first_not_of(" \t\r\n");
    auto r = in.find_last_not_of(" \t\r\n");
    if (l == std::string::npos) return {};
    in = in.substr(l, r - l + 1);
    std::string s = in;
    auto pos = s.find("://");
    if (pos != std::string::npos) s.erase(0, pos + 3);
    pos = s.find('/');
    if (pos != std::string::npos) s.erase(pos);
 
    pos = s.find('@');
    if (pos != std::string::npos) s = s.substr(pos + 1);
 
    pos = s.find(':');
    if (pos != std::string::npos) s.erase(pos);
 
    if (s.rfind("www.", 0) == 0) s.erase(0, 4);
 
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c){ return std::tolower(c); });
 
    static const std::regex re(R"(^[a-z0-9][a-z0-9.-]*[a-z0-9]$)");
    if (!std::regex_match(s, re)) return {};
 
    if (s.find('.') == std::string::npos) return {};
 
    return s;
}

References normalize_domain_or_url().

Referenced by SettingsPage::build_secure_payments_tab().

normalize_locale()

std::string normalize_locale ( std::string s )

static

Definition at line 2476 of file SettingsPage.cpp.

                                               {
    auto p = s.find('.'); if (p != std::string::npos) s = s.substr(0, p);
    p = s.find('@'); if (p != std::string::npos) s = s.substr(0, p);
    for (auto& c : s) if (c == '-') c = '_';
    return s;
}

References normalize_locale().

Referenced by SettingsPage::build_options_tab(), and normalize_locale().

payments_json_path_user()

std::string payments_json_path_user ( )

static

Definition at line 645 of file SettingsPage.cpp.

                                           {
    return Glib::get_home_dir() + "/.config/BastionGuard/payments.json";
}

References payments_json_path_user().

Referenced by ensure_payments_json_exists(), load_payments_domains(), payments_json_path_user(), save_payments_domains(), and update_payments_enabled_only().

read_current_ports()

std::pair< int, int > read_current_ports

(

const std::string &

)

Definition at line 1323 of file SettingsPage.cpp.

{
    int http_port = 81;
    int https_port = 444;
    const std::string portfile = "/etc/BastionGuard/webports.conf";
 
    std::ifstream f(portfile);
    if (f.is_open()) {
        int p1 = 0, p2 = 0;
        f >> p1 >> p2;
 
        if (p1 > 0 && p1 < 65536) http_port = p1;
        if (p2 > 0 && p2 < 65536) https_port = p2;
 
        std::cout << _("[settings] Porte lette da ") << portfile
                  << " → HTTP=" << http_port
                  << " HTTPS=" << https_port << std::endl;
    } else {
        std::cerr << _("[settings] ⚠ Impossibile aprire ") << portfile
                  << _(" — uso valori di default (80/443)\n");
    }
 
    return {http_port, https_port};
}

References _, and read_current_ports().

Referenced by read_current_ports().

read_webports_conf()

std::pair< int, int > read_webports_conf

(

)

Definition at line 1111 of file SettingsPage.cpp.

{
    constexpr int default_http_port = 81;
    constexpr int default_https_port = 444;
 
    auto valid_port = [](int port) {
        return port > 0 && port < 65536;
    };
 
    std::vector<std::string> paths = {
        "/etc/BastionGuard/webports.conf",
        "/tmp/BastionGuard_webports.conf"
    };
 
    for (const auto& p : paths) {
        std::ifstream f(p);
        if (!f.is_open())
            continue;
 
        std::stringstream buffer;
        buffer << f.rdbuf();
        const std::string content = buffer.str();
 
        int http_port = default_http_port;
        int https_port = default_https_port;
        std::istringstream iss(content);
 
        if ((iss >> http_port >> https_port) &&
            valid_port(http_port) && valid_port(https_port)) {
            std::cout << _("[settings] 📖 Letto webports.conf: ")
                      << http_port << " " << https_port << std::endl;
            return {http_port, https_port};
        }
 
        // Evita che un file scritto male venga interpretato come una singola porta HTTP.
        // La coppia supportata resta 81/444.
        std::cerr << _("[settings] ⚠️ webports.conf malformato, uso default 81/444: ")
                  << content << std::endl;
        return {default_http_port, default_https_port};
    }
 
    std::cout << _("[settings] ⚠️ Nessun webports.conf trovato, uso default 81/444\n");
    return {default_http_port, default_https_port};
}

References _, and read_webports_conf().

Referenced by SettingsPage::build_options_tab(), and read_webports_conf().

restart_service()

bool restart_service

(

const std::string &

svc

)

Definition at line 1168 of file SettingsPage.cpp.

{
    return bg_process::run({"pkexec", "/usr/libexec/bastionguard/bastionguard-service",
                            "--system", "restart", svc}).ok();
}

References restart_service(), and bg_process::run().

Referenced by restart_service().

run_privhelper_and_capture()

bool run_privhelper_and_capture ( const std::vector< std::string > & args, std::string & stdout_out, std::string & stderr_out, int & exit_status )

static

Definition at line 243 of file SettingsPage.cpp.

{
    try {
        std::vector<std::string> argv;
        argv.push_back("pkexec");
        argv.push_back("/usr/bin/bastionguard-emailproxy");
        argv.insert(argv.end(), args.begin(), args.end());
 
        auto proc = Gio::Subprocess::create(
            argv,
            Gio::Subprocess::Flags::STDOUT_PIPE |
            Gio::Subprocess::Flags::STDERR_PIPE
        );
 
        auto result = proc->communicate_utf8("");
        stdout_out = result.first;
        stderr_out = result.second;
 
        if (proc->get_if_exited())
            exit_status = proc->get_exit_status();
        else
            exit_status = -1;
 
        return proc->get_if_exited() && exit_status == 0;
    } catch (const std::exception& e) {
        stdout_out.clear();
        stderr_out = e.what();
        exit_status = -1;
        return false;
    }
}

References run_privhelper_and_capture().

Referenced by run_privhelper_and_capture().

save_mail_security_config()

bool save_mail_security_config ( const MailSecurityConfig & cfg )

static

Definition at line 418 of file SettingsPage.cpp.

                                                                     {
    ensure_mail_json_exists();
    const std::string path = mail_json_path_user();
 
    try {
        json j;
        j["version"] = 2;
        j["updated_at"] = iso_today_yyyy_mm_dd();
        j["enabled"] = cfg.enabled;
        j["scan_outgoing"] = cfg.scan_outgoing;
        j["inject_signature"] = cfg.inject_signature;
        j["local_smtp_host"] = cfg.local_host;
        j["local_smtp_port"] = cfg.local_port;
        j["local_smtp_tls_port"]         = cfg.local_tls_port;
        j["local_submission_port"]        = cfg.local_submission_port;
        j["advertise_starttls"]           = cfg.advertise_starttls;
        j["enable_implicit_tls_listener"] = cfg.enable_implicit_tls_listener;
        j["default_profile_id"] = cfg.default_profile_id;
        j["profiles"] = json::array();
 
        for (const auto& p : cfg.profiles) {
            json jp;
            jp["id"] = p.id;
            jp["label"] = p.label;
            jp["match_from"] = p.match_from;
            jp["match_from_domain"] = p.match_from_domain;
            jp["smtp_host"] = p.smtp_host;
            jp["smtp_port"] = p.smtp_port;
            jp["starttls"] = p.starttls;
            jp["implicit_tls"] = p.implicit_tls;
            jp["username"] = p.username;
            jp["password"] = p.password;
            jp["signature"] = {
                {"display_name", p.signature.display_name},
                {"job_title", p.signature.job_title},
                {"company", p.signature.company},
                {"phone", p.signature.phone},
                {"website", p.signature.website},
                {"logo_path", p.signature.logo_path}
            };
            j["profiles"].push_back(std::move(jp));
        }
 
        const std::string tmp = path + ".tmp";
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out.good()) return false;
            out << j.dump(2);
            out.flush();
            if (!out.good()) return false;
        }
 
        std::error_code ec;
        std::filesystem::rename(tmp, path, ec);
        if (ec) {
            std::filesystem::remove(path, ec);
            ec.clear();
            std::filesystem::rename(tmp, path, ec);
            if (ec) {
                std::filesystem::remove(tmp, ec);
                return false;
            }
        }
 
        return true;
    } catch (...) {
        return false;
    }
}

References MailSecurityConfig::advertise_starttls, MailSecurityConfig::default_profile_id, MailSecurityConfig::enable_implicit_tls_listener, MailSecurityConfig::enabled, ensure_mail_json_exists(), MailSecurityConfig::inject_signature, iso_today_yyyy_mm_dd(), MailSecurityConfig::local_host, MailSecurityConfig::local_port, MailSecurityConfig::local_submission_port, MailSecurityConfig::local_tls_port, mail_json_path_user(), MailSecurityConfig::profiles, save_mail_security_config(), and MailSecurityConfig::scan_outgoing.

Referenced by SettingsPage::build_email_security_tab(), and save_mail_security_config().

save_payments_domains()

bool save_payments_domains ( const std::vector< std::string > & domains_in, bool enabled_flag )

static

Definition at line 966 of file SettingsPage.cpp.

                                                                                             {
    ensure_payments_json_exists();
 
    const std::string path = payments_json_path_user();
 
    std::vector<std::string> domains;
    domains.reserve(domains_in.size());
    for (const auto& s : domains_in) {
        auto d = normalize_domain_or_url(s);
        if (!d.empty()) domains.push_back(d);
    }
    std::sort(domains.begin(), domains.end());
    domains.erase(std::unique(domains.begin(), domains.end()), domains.end());
 
    try {
        json j;
 
        {
            std::ifstream in(path, std::ios::binary);
            if (in.good()) {
                try { in >> j; } catch (...) { j = json::object(); }
            }
        }
 
        if (!j.is_object()) j = json::object();
 
        j["version"] = 1;
        j["updated_at"] = iso_today_yyyy_mm_dd();
        j["enabled"] = enabled_flag;
        j["list"] = json::array();
        for (const auto& d : domains) j["list"].push_back(d);
 
        const std::string tmp = path + ".tmp";
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out.good()) return false;
            out << j.dump(2);
            out.flush();
            if (!out.good()) return false;
        }
 
        std::error_code ec;
        fs::rename(tmp, path, ec);
        if (ec) {
            fs::remove(path, ec);
            ec.clear();
            fs::rename(tmp, path, ec);
            if (ec) {
                fs::remove(tmp, ec);
                return false;
            }
        }
 
        return true;
    } catch (...) {
        return false;
    }
}

References ensure_payments_json_exists(), iso_today_yyyy_mm_dd(), normalize_domain_or_url(), payments_json_path_user(), and save_payments_domains().

Referenced by SettingsPage::build_secure_payments_tab(), and save_payments_domains().

save_proxy_bypass_domains()

bool save_proxy_bypass_domains ( const std::vector< std::string > & domains )

static

Definition at line 3850 of file SettingsPage.cpp.

                                                                           {
    const std::string dir  = Glib::build_filename(
        Glib::get_home_dir(), ".config", "BastionGuard");
    const std::string path = Glib::build_filename(dir, "proxy_bypass.json");
    try {
        std::filesystem::create_directories(dir);
        nlohmann::json j;
        j["version"]     = 1;
        j["description"] = "Domini che bypassano completamente il proxy BastionGuard. "
                           "Tunnel TCP puro trasparente — nessuna intercettazione TLS. "
                           "Usare per siti che attivano 2FA o CAPTCHA in presenza del proxy.";
        j["list"] = nlohmann::json::array();
        for (const auto& d : domains) j["list"].push_back(d);
        const std::string tmp = path + ".tmp";
        std::ofstream out(tmp, std::ios::trunc);
        if (!out.is_open()) return false;
        out << j.dump(2); out.flush(); out.close();
        std::error_code ec;
        std::filesystem::rename(tmp, path, ec);
        return !ec;
    } catch (...) { return false; }
}

References save_proxy_bypass_domains().

Referenced by SettingsPage::build_proxy_bypass_tab(), and save_proxy_bypass_domains().

show_service_error_dialog()

void show_service_error_dialog	(	const Glib::ustring &	msg,
		const std::string &	service )

Definition at line 4501 of file SettingsPage.cpp.

{
    auto dlg = Gtk::AlertDialog::create(msg);
    dlg->set_detail(Glib::ustring::compose(_("Servizio: %1\n\n"
                                             "Verifica i permessi o prova ad eseguire il comando da terminale."), service));
    dlg->show();
}

References _, and show_service_error_dialog().

Referenced by show_service_error_dialog().

split_semicolon_list()

std::vector< std::string > split_semicolon_list ( const std::string & input )

static

Definition at line 148 of file SettingsPage.cpp.

                                                                         {
    std::vector<std::string> out;
    std::string cur;
 
    auto push_trimmed = [&](std::string s) {
        auto l = s.find_first_not_of(" \t\r\n");
        auto r = s.find_last_not_of(" \t\r\n");
        if (l == std::string::npos) return;
        s = s.substr(l, r - l + 1);
        if (!s.empty()) out.push_back(s);
    };
 
    for (char c : input) {
        if (c == ';') {
            push_trimmed(cur);
            cur.clear();
        } else {
            cur += c;
        }
    }
    push_trimmed(cur);
    return out;
}

References split_semicolon_list().

tb_find_default_profile()

std::string tb_find_default_profile ( )

static

Definition at line 716 of file SettingsPage.cpp.

                                           {
    const std::string base = Glib::get_home_dir() + "/.thunderbird";
 
    {
        auto installs = tb_parse_ini_file(base + "/installs.ini");
        for (const auto& [sec, kv] : installs) {
            auto it = kv.find("Default");
            if (it == kv.end()) continue;
            std::string path = it->second;
            if (!path.empty() && path.front() != '/')
                path = base + "/" + path;
            if (std::filesystem::exists(path + "/prefs.js"))
                return path;
        }
    }
 
    auto sections = tb_parse_ini_file(base + "/profiles.ini");
 
    std::string best_default_release;
    std::string best_default_flag;
    std::string best_any;
 
    for (const auto& [sec, kv] : sections) {
        if (sec.rfind("Profile", 0) != 0) continue;
        auto it_path = kv.find("Path");
        if (it_path == kv.end()) continue;
 
        std::string path = it_path->second;
        auto it_rel = kv.find("IsRelative");
        bool rel = (it_rel == kv.end() || it_rel->second != "0");
        if (rel) path = base + "/" + path;
 
        if (!std::filesystem::exists(path + "/prefs.js")) continue;
 
        // Default=1
        auto it_def = kv.find("Default");
        if (it_def != kv.end() && it_def->second == "1" && best_default_flag.empty())
            best_default_flag = path;
 
        // suffisso .default-release
        const std::string suffix = ".default-release";
        if (path.size() >= suffix.size() &&
            path.compare(path.size() - suffix.size(), suffix.size(), suffix) == 0 &&
            best_default_release.empty())
            best_default_release = path;
 
        if (best_any.empty()) best_any = path;
    }
 
    if (!best_default_flag.empty())   return best_default_flag;
    if (!best_default_release.empty()) return best_default_release;
    return best_any;
}

References tb_find_default_profile(), and tb_parse_ini_file().

Referenced by tb_find_default_profile(), and tb_import_profiles().

tb_import_profiles()

std::vector< MailRelayProfile > tb_import_profiles ( std::string & err_out )

static

Definition at line 770 of file SettingsPage.cpp.

                                                                          {
    std::vector<MailRelayProfile> result;
    err_out.clear();
 
    const std::string profile_dir = tb_find_default_profile();
    if (profile_dir.empty()) {
        err_out = _("Profilo Thunderbird non trovato");
        return result;
    }
 
    const std::string prefs_path = profile_dir + "/prefs.js";
    std::ifstream in(prefs_path);
    if (!in.is_open()) {
        err_out = _("prefs.js non trovato: ") + prefs_path;
        return result;
    }
 
    std::map<std::string, TbSmtpEntry>    smtp_map;
    std::map<std::string, TbIdentityEntry> identity_map;
 
    std::string line;
    while (std::getline(in, line)) {
        std::string key, value;
        if (!tb_parse_pref_line(line, key, value)) continue;
 
        if (key.rfind("mail.smtpserver.", 0) == 0) {
            auto rest = key.substr(16);
            auto dot  = rest.find('.');
            if (dot == std::string::npos) continue;
            auto sid   = rest.substr(0, dot);
            auto field = rest.substr(dot + 1);
            auto& s = smtp_map[sid];
            s.id = sid;
            if (field == "hostname")    s.hostname    = value;
            else if (field == "port")   s.port        = std::atoi(value.c_str());
            else if (field == "username") s.username  = value;
            else if (field == "try_ssl")  s.try_ssl   = std::atoi(value.c_str());
            else if (field == "description") s.description = value;
        }
        else if (key.rfind("mail.identity.", 0) == 0) {
            auto rest = key.substr(14);
            auto dot  = rest.find('.');
            if (dot == std::string::npos) continue;
            auto iid   = rest.substr(0, dot);
            auto field = rest.substr(dot + 1);
            auto& id = identity_map[iid];
            if (field == "useremail")   id.email       = value;
            else if (field == "smtpServer") id.smtp_server = value;
        }
    }
 
    std::map<std::string, MailRelayProfile> built;
 
    for (const auto& [iid, ident] : identity_map) {
        if (ident.email.empty() || ident.smtp_server.empty()) continue;
        auto it = smtp_map.find(ident.smtp_server);
        if (it == smtp_map.end()) continue;
 
        const auto& s = it->second;
        auto& p = built[s.id];
 
        if (p.id.empty()) {
            p.id         = s.id;
            p.label      = s.description.empty() ? s.hostname : s.description;
            p.smtp_host  = s.hostname;
            p.smtp_port  = (s.port > 0 ? s.port : 587);
            p.username   = s.username;
            p.password   = "";
            p.starttls      = (s.try_ssl == 2);
            p.implicit_tls  = (s.try_ssl == 3);
        }
 
        std::string email_lc = ident.email;
        std::transform(email_lc.begin(), email_lc.end(), email_lc.begin(), ::tolower);
        if (std::find(p.match_from.begin(), p.match_from.end(), email_lc) == p.match_from.end())
            p.match_from.push_back(email_lc);
 
        auto at = email_lc.find('@');
        if (at != std::string::npos) {
            std::string dom = email_lc.substr(at + 1);
            if (std::find(p.match_from_domain.begin(), p.match_from_domain.end(), dom)
                    == p.match_from_domain.end())
                p.match_from_domain.push_back(dom);
        }
    }
 
    for (auto& [id, p] : built)
        result.push_back(std::move(p));
 
    if (result.empty())
        err_out = _("Nessun server SMTP trovato in Thunderbird");
 
    return result;
}

References _, tb_find_default_profile(), tb_import_profiles(), and tb_parse_pref_line().

Referenced by SettingsPage::build_email_security_tab(), and tb_import_profiles().

tb_parse_ini_file()

std::map< std::string, std::map< std::string, std::string > > tb_parse_ini_file ( const std::string & path )

static

Definition at line 691 of file SettingsPage.cpp.

                                         {
    std::map<std::string, std::map<std::string,std::string>> sections;
    std::ifstream f(path);
    if (!f.is_open()) return sections;
 
    std::string line, sec;
    while (std::getline(f, line)) {
        // trim
        auto s = line.find_first_not_of(" \t\r\n");
        if (s == std::string::npos || line[s] == ';' || line[s] == '#') continue;
        line = line.substr(s);
        auto e = line.find_last_not_of(" \t\r\n");
        if (e != std::string::npos) line = line.substr(0, e + 1);
 
        if (line.front() == '[' && line.back() == ']') {
            sec = line.substr(1, line.size() - 2);
            continue;
        }
        auto eq = line.find('=');
        if (eq == std::string::npos || sec.empty()) continue;
        sections[sec][line.substr(0, eq)] = line.substr(eq + 1);
    }
    return sections;
}

References tb_parse_ini_file().

Referenced by tb_find_default_profile(), and tb_parse_ini_file().

tb_parse_pref_line()

bool tb_parse_pref_line ( const std::string & line, std::string & key, std::string & value )

static

Definition at line 664 of file SettingsPage.cpp.

                                                                  {
    const std::string prefix = "user_pref(\"";
    if (line.rfind(prefix, 0) != 0) return false;
 
    auto ks = prefix.size();
    auto ke = line.find('"', ks);
    if (ke == std::string::npos) return false;
    key = line.substr(ks, ke - ks);
 
    auto vs = line.find(',', ke);
    if (vs == std::string::npos) return false;
    ++vs;
    while (vs < line.size() && line[vs] == ' ') ++vs;
 
    auto ve = line.rfind(')');
    if (ve == std::string::npos || ve <= vs) return false;
    value = line.substr(vs, ve - vs);
 
 
    if (value.size() >= 2 && value.front() == '"' && value.back() == '"')
        value = value.substr(1, value.size() - 2);
 
    return true;
}

References tb_parse_pref_line().

Referenced by tb_import_profiles(), and tb_parse_pref_line().

update_payments_enabled_only()

bool update_payments_enabled_only ( bool enabled_flag )

static

Definition at line 1025 of file SettingsPage.cpp.

                                                            {
    ensure_payments_json_exists();
 
    const std::string path = payments_json_path_user();
    try {
        json j;
        {
            std::ifstream in(path, std::ios::binary);
            if (!in.good()) return false;
            in >> j;
        }
        if (!j.is_object()) j = json::object();
 
        j["version"] = 1;
        j["updated_at"] = iso_today_yyyy_mm_dd();
        j["enabled"] = enabled_flag;
 
        if (!j.contains("list") || !j["list"].is_array())
            j["list"] = json::array();
 
        const std::string tmp = path + ".tmp";
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out.good()) return false;
            out << j.dump(2);
            out.flush();
            if (!out.good()) return false;
        }
 
        std::error_code ec;
        fs::rename(tmp, path, ec);
        if (ec) {
            fs::remove(path, ec);
            ec.clear();
            fs::rename(tmp, path, ec);
            if (ec) {
                fs::remove(tmp, ec);
                return false;
            }
        }
 
        return true;
    } catch (...) {
        return false;
    }
}

References ensure_payments_json_exists(), iso_today_yyyy_mm_dd(), payments_json_path_user(), and update_payments_enabled_only().

Referenced by SettingsPage::build_secure_payments_tab(), and update_payments_enabled_only().

update_ports_in_file()

bool update_ports_in_file	(	const std::string &	file,
		int	http_port,
		int	https_port )

Definition at line 1174 of file SettingsPage.cpp.

{
    if (!fs::exists(file)) {
        std::cerr << _("[update_ports_in_file] File non trovato: ") << file << std::endl;
        return false;
    }
 
    std::ifstream fin(file);
    if (!fin.is_open()) {
        std::cerr << _("[update_ports_in_file] Impossibile aprire il file: ") << file << std::endl;
        return false;
    }
 
    std::stringstream buffer;
    buffer << fin.rdbuf();
    fin.close();
    std::string content = buffer.str();
 
    std::regex http_regex(R"((Listen\s+)80\b)");
    std::regex https_regex(R"((Listen\s+)443\b)");
    std::regex star_http(R"((\*|127\.0\.0\.1|\‍[::1\‍])?:80\b)");
    std::regex star_https(R"((\*|127\.0\.0\.1|\‍[::1\‍])?:443\b)");
 
    content = std::regex_replace(content, http_regex, "Listen " + std::to_string(http_port));
    content = std::regex_replace(content, https_regex, "Listen " + std::to_string(https_port));
    content = std::regex_replace(content, star_http, "$1:" + std::to_string(http_port));
    content = std::regex_replace(content, star_https, "$1:" + std::to_string(https_port));
 
    std::string tmpfile = "/tmp/BastionGuard-vhost.conf";
    std::ofstream fout(tmpfile);
    if (!fout.is_open()) {
        std::cerr << _("[update_ports_in_file] Impossibile scrivere il file temporaneo") << std::endl;
        return false;
    }
    fout << content;
    fout.close();
 
    return bg_process::run({"pkexec", "/usr/bin/install", "-m", "0644", tmpfile, file}).ok();
}

References _, bg_process::run(), and update_ports_in_file().

Referenced by update_ports_in_file().

update_webserver_ports()

bool update_webserver_ports	(	const std::string &	websrv,
		int	http_port,
		int	https_port )

Definition at line 1350 of file SettingsPage.cpp.

{
    (void)websrv;
    namespace fs = std::filesystem;
 
    const std::string tmpfile = "/tmp/BastionGuard_webports.conf";
    const std::string targetfile = "/etc/BastionGuard/webports.conf";
 
    try {
 
        std::ofstream fout(tmpfile);
        if (!fout.is_open()) {
            std::cerr << _("[settings] ❌ Impossibile creare file temporaneo: ") << tmpfile << std::endl;
            return false;
        }
 
        fout << http_port << " " << https_port << "\n";
        fout.close();
 
        const int ret = bg_process::run({"pkexec", "/usr/bin/install", "-D", "-m", "0644",
                                          tmpfile, targetfile}).exit_code;
 
        if (ret == 0) {
            std::cout << _("[settings] ✅ Porte BastionGuard salvate in ") << targetfile
                      << " → HTTP interno=" << http_port
                      << ", HTTPS interno=" << https_port << std::endl;
            return true;
        } else {
            std::cerr << _("[settings] ❌ Errore durante l'installazione via pkexec.\n");
            return false;
        }
    } catch (const std::exception& e) {
        std::cerr << _("[settings] ⚠ Eccezione durante update_webserver_ports: ") << e.what() << std::endl;
        return false;
    }
}

References _, bg_process::run(), and update_webserver_ports().

Referenced by update_webserver_ports().

write_mail_config_temp_json()

bool write_mail_config_temp_json ( const MailSecurityConfig & cfg, std::string & out_path )

static

Definition at line 278 of file SettingsPage.cpp.

                                                                                            {
    try {
        auto tmpdir = Glib::get_tmp_dir();
        out_path = Glib::build_filename(tmpdir, "bastionguard-mail-config.json");
 
        json j;
        j["version"] = cfg.version;
        j["enabled"] = cfg.enabled;
        j["scan_outgoing"] = cfg.scan_outgoing;
        j["inject_signature"] = cfg.inject_signature;
        j["local_smtp_host"] = cfg.local_host;
        j["local_smtp_port"] = cfg.local_port;
        j["local_smtp_tls_port"] = cfg.local_tls_port;
        j["advertise_starttls"] = cfg.advertise_starttls;
        j["enable_implicit_tls_listener"] = cfg.enable_implicit_tls_listener;
        j["default_profile_id"] = cfg.default_profile_id;
 
        j["profiles"] = json::array();
        for (const auto& p : cfg.profiles) {
            json jp;
            jp["id"] = p.id;
            jp["label"] = p.label;
            jp["match_from"] = p.match_from;
            jp["match_from_domain"] = p.match_from_domain;
            jp["smtp_host"] = p.smtp_host;
            jp["smtp_port"] = p.smtp_port;
            jp["starttls"] = p.starttls;
            jp["implicit_tls"] = p.implicit_tls;
            jp["username"] = p.username;
            jp["password"] = p.password;
 
            jp["signature"] = {
                {"display_name", p.signature.display_name},
                {"job_title", p.signature.job_title},
                {"company", p.signature.company},
                {"phone", p.signature.phone},
                {"website", p.signature.website},
                {"logo_path", "/usr/share/BastionGuard/data/logo.png"}
            };
 
            j["profiles"].push_back(jp);
        }
 
        std::ofstream out(out_path, std::ios::binary | std::ios::trunc);
        if (!out.good())
            return false;
 
        out << j.dump(2);
        return out.good();
    } catch (...) {
        return false;
    }
}

References MailSecurityConfig::advertise_starttls, MailSecurityConfig::default_profile_id, MailSecurityConfig::enable_implicit_tls_listener, MailSecurityConfig::enabled, MailSecurityConfig::inject_signature, MailSecurityConfig::local_host, MailSecurityConfig::local_port, MailSecurityConfig::local_tls_port, MailSecurityConfig::profiles, MailSecurityConfig::scan_outgoing, MailSecurityConfig::version, and write_mail_config_temp_json().

Referenced by write_mail_config_temp_json().

write_temp_script_and_elevate()

bool write_temp_script_and_elevate ( const std::string & script_contents, std::string * out_log = nullptr, int * exit_code = nullptr )

static

Definition at line 1079 of file SettingsPage.cpp.

                                                                                                                                {
    char tmpl[] = "/tmp/BastionGuard_tmp_XXXXXX";
    int fd = mkstemp(tmpl);
    if (fd < 0) {
        if (out_log) *out_log = _("Impossibile creare file temporaneo");
        return false;
    }
    std::string tmpname = tmpl;
    // write
    ssize_t written = write(fd, script_contents.c_str(), script_contents.size());
    close(fd);
    if (written < 0) {
        if (out_log) *out_log = _("Errore scrittura temporanea");
        std::filesystem::remove(tmpname);
        return false;
    }
    ::chmod(tmpname.c_str(), 0755);
 
    const std::string runner = std::filesystem::exists("/usr/bin/pkexec") ? "pkexec" : "sudo";
    const auto result = bg_process::run({runner, tmpname}, true);
    std::string out = result.output;
    const int rc = result.exit_code;
    const bool ok = result.ok();
 
    // pulizia
    std::filesystem::remove(tmpname);
 
    if (out_log) *out_log = out;
    if (exit_code) *exit_code = rc;
    return ok;
}

References _, bg_process::Result::output, bg_process::run(), and write_temp_script_and_elevate().

Referenced by SettingsPage::build_options_tab(), and write_temp_script_and_elevate().

Variable Documentation

toggleControlled

std::map<std::string, bool> toggleControlled

static

Definition at line 1391 of file SettingsPage.cpp.

updatingToggle

bool updatingToggle = false

static

Definition at line 1389 of file SettingsPage.cpp.