Classes
class	ClamApp

Functions
static void	ensure_dir_exists (const std::string &dir)
static std::string	getenv_str (const char *k)
static bool	icontains (std::string hay, std::string needle)
static bool	should_enable_trayicon ()
static void	ensure_lang_conf_exists (const std::string &lang_conf_path)
static std::string	resolve_path (const std::string &local, const std::string &installed)
static bool	wizard_needed ()
static void	ensureUserWrapperInstalled ()
int	main (int argc, char *argv[])

Function Documentation

◆ ensure_dir_exists()

void ensure_dir_exists ( const std::string & dir )

static

Definition at line 50 of file main.cpp.

                                                    {
    std::error_code ec;
    fs::create_directories(dir, ec);
    if (ec) {
        std::cerr << Glib::ustring::compose(
            _("[Lang] ⚠️ Errore creando %1: %2"), dir, ec.message()) << std::endl;
    }
}

References _, and ensure_dir_exists().

Referenced by ensure_dir_exists(), and ensure_lang_conf_exists().

◆ ensure_lang_conf_exists()

void ensure_lang_conf_exists ( const std::string & lang_conf_path )

static

Definition at line 92 of file main.cpp.

                                                                     {
    namespace fs = std::filesystem;
 
    std::error_code ec;
    if (fs::exists(lang_conf_path, ec) && !ec) {
        return;
    }
 
    std::string cfgdir = Glib::get_home_dir() + "/.config/BastionGuard";
    ensure_dir_exists(cfgdir);
 
    std::ofstream out(lang_conf_path, std::ios::out | std::ios::trunc);
    if (!out.is_open()) {
        std::cerr << "[Lang] ⚠️ Impossibile creare " << lang_conf_path << std::endl;
        return;
    }
 
    out << "LANG=en_US.UTF-8\n";
    out << "LC_ALL=en_US.UTF-8\n";
    out << "LANGUAGE=en_US\n";
    out.close();
 
    std::cout << "[Lang] ✅ Creato lang.conf di default: " << lang_conf_path << std::endl;
}

References ensure_dir_exists(), and ensure_lang_conf_exists().

Referenced by ensure_lang_conf_exists(), and main().

◆ ensureUserWrapperInstalled()

void ensureUserWrapperInstalled ( )

static

Definition at line 140 of file main.cpp.

                                         {
    const char* homeC = std::getenv("HOME");
    if (!homeC) {
        std::cerr << _("[Main] ⚠️ HOME non trovato, salto install wrapper") << "\n";
        return;
    }
 
    std::string home = homeC;
    std::string localBin = home + "/.local/bin";
    std::string targetLink = localBin + "/xdg-open";
    std::string realApp = "/usr/bin/BastionGuard-bankopener";
 
    try {
 
        std::error_code ec;
        fs::create_directories(localBin, ec);
        if (ec) {
            std::cerr << Glib::ustring::compose(
                _("[Main] ⚠️ Errore creando %1: %2"), localBin, ec.message()) << "\n";
            return;
        }
 
 
        bool must_create = true;
        if (fs::exists(targetLink)) {
            std::error_code ec2;
            fs::file_status st = fs::symlink_status(targetLink, ec2);
            if (!ec2 && fs::is_symlink(st)) {
                try {
                    std::string dest = fs::read_symlink(targetLink).string();
                    if (dest == realApp) must_create = false;
                } catch (...) {
                    must_create = true;
                }
            } else {
                try { fs::remove(targetLink); } catch (...) {}
                must_create = true;
            }
        }
 
        if (must_create) {
            try {
                if (fs::exists(targetLink)) fs::remove(targetLink);
                fs::create_symlink(realApp, targetLink);
                std::cout << Glib::ustring::compose(
                    _("[Main] 🔗 Creato symlink: %1 → %2"), targetLink, realApp) << "\n";
            } catch (const std::exception& e) {
                std::cerr << Glib::ustring::compose(
                    _("[Main] ⚠️ Impossibile creare symlink %1: %2"), targetLink, e.what()) << "\n";
            }
        } else {
            std::cout << Glib::ustring::compose(
                _("[Main] 🔁 Symlink già presente: %1 → %2"), targetLink, realApp) << "\n";
        }
 
 
        std::map<std::string, std::string> rc_to_line;
        rc_to_line[home + "/.bashrc"] = "export PATH=\"$HOME/.local/bin:$PATH\"";
        rc_to_line[home + "/.zshrc"]  = "export PATH=\"$HOME/.local/bin:$PATH\"";
        rc_to_line[home + "/.config/fish/config.fish"] = "set -gx PATH $HOME/.local/bin $PATH";
        rc_to_line[home + "/.cshrc"] = "setenv PATH $HOME/.local/bin:$PATH";
        rc_to_line[home + "/.tcshrc"] = "setenv PATH $HOME/.local/bin:$PATH";
 
        for (const auto& [rcfile, line] : rc_to_line) {
            bool present = false;
            std::ifstream in(rcfile);
            if (in.is_open()) {
                std::string l;
                while (std::getline(in, l)) {
                    if (l.find(line) != std::string::npos) { present = true; break; }
                }
            }
            in.close();
 
            if (!present) {
                std::ofstream out(rcfile, std::ios::app);
                if (out.is_open()) {
                    out << "\n# Added by BastionGuard Secure Browser\n" << line << "\n";
                    std::cout << Glib::ustring::compose(
                        _("[Main] ⚙️ Aggiornato %1"), rcfile) << "\n";
                }
            }
        }
 
        const char* oldPathC = std::getenv("PATH");
        std::string oldPath = oldPathC ? oldPathC : "";
        std::string newPath = localBin + ":" + oldPath;
        setenv("PATH", newPath.c_str(), 1);
 
        std::cout << _("[Main] ✅ PATH aggiornato per sessione corrente") << "\n";
 
    } catch (const std::exception& ex) {
        std::cerr << Glib::ustring::compose(
            _("[Main] ⚠️ Errore ensureUserWrapperInstalled(): %1"), ex.what()) << "\n";
    }
}

References _, and ensureUserWrapperInstalled().

Referenced by ensureUserWrapperInstalled(), and main().

◆ getenv_str()

std::string getenv_str ( const char * k )

static

Definition at line 59 of file main.cpp.

                                           {
    const char* v = std::getenv(k);
    return (v && *v) ? std::string(v) : std::string();
}

References getenv_str().

Referenced by getenv_str(), ClamApp::launch_main_window(), and should_enable_trayicon().

◆ icontains()

bool icontains	(	std::string	hay,
		std::string	needle )

static

Definition at line 64 of file main.cpp.

                                                       {
    auto tolower_ascii = [](unsigned char c){ return (c >= 'A' && c <= 'Z') ? char(c + 32) : char(c); };
    for (auto& c : hay) c = tolower_ascii((unsigned char)c);
    for (auto& c : needle) c = tolower_ascii((unsigned char)c);
    return hay.find(needle) != std::string::npos;
}

References icontains().

Referenced by icontains(), ClamApp::launch_main_window(), and should_enable_trayicon().

◆ main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 413 of file main.cpp.

                                 {
 
    std::string lang_conf = Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    ensure_lang_conf_exists(lang_conf);
 
    std::ifstream f(lang_conf);
    if (f.is_open()) {
        std::string line;
        while (std::getline(f, line)) {
            auto pos = line.find('=');
            if (pos != std::string::npos) {
                std::string key = line.substr(0, pos);
                std::string val = line.substr(pos + 1);
                if (!key.empty() && !val.empty()) {
                    setenv(key.c_str(), val.c_str(), 1);
                }
            }
        }
        f.close();
        std::cout << "[Lang] Config caricata da " << lang_conf << std::endl;
    } else {
        std::cerr << "[Lang] ⚠️ Impossibile aprire lang.conf, forzo inglese di default" << std::endl;
    }
 
    // Forza inglese se il file non ha impostato correttamente le variabili
    const char* lang_env = std::getenv("LANG");
    if (!lang_env || std::string(lang_env).empty()) {
        setenv("LANG", "en_US.UTF-8", 1);
    }
 
    const char* lc_all_env = std::getenv("LC_ALL");
    if (!lc_all_env || std::string(lc_all_env).empty()) {
        setenv("LC_ALL", "en_US.UTF-8", 1);
    }
 
    const char* language_env = std::getenv("LANGUAGE");
    if (!language_env || std::string(language_env).empty()) {
        setenv("LANGUAGE", "en_US", 1);
    }
 
    const char* applied = setlocale(LC_ALL, "");
    if (!applied) {
        applied = setlocale(LC_ALL, "en_US.UTF-8");
    }
    if (!applied) {
        applied = setlocale(LC_ALL, "en_US");
    }
    if (!applied) {
        applied = setlocale(LC_ALL, "C.UTF-8");
    }
    if (!applied) {
        applied = setlocale(LC_ALL, "C");
    }
 
    bindtextdomain("BastionGuard", LOCALEDIR);
    bind_textdomain_codeset("BastionGuard", "UTF-8");
    textdomain("BastionGuard");
 
    bool do_update_phish = false;
    bool do_update_sanesecurity = false;
    bool start_minimized = false;
 
    std::vector<char*> gtk_argv;
    gtk_argv.push_back(argv[0]);
 
    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (arg == "--update-phish") {
            do_update_phish = true;
        } else if (arg == "--update-sanesecurity") {
            do_update_sanesecurity = true;
        } else if (arg == "--minimized") {
            start_minimized = true;
        } else {
            gtk_argv.push_back(argv[i]);
        }
    }
 
    ensureUserWrapperInstalled();
 
    if (do_update_phish) {
        std::cout << "[BastionGuard] " << _("Avvio aggiornamento blacklist (modalità headless)...") << std::endl;
        try {
            bool ok = Backend::instance().updatePhishLists();
            if (ok) {
                std::cout << "[BastionGuard] " << _("✔ Blacklist aggiornata con successo.") << std::endl;
                return 0;
            } else {
                std::cerr << "[BastionGuard] " << _("❌ Errore durante l'aggiornamento blacklist.") << std::endl;
                return 2;
            }
        } catch (const std::exception& ex) {
            std::cerr << "[BastionGuard] " << _("Eccezione durante updatePhishLists(): ") << ex.what() << std::endl;
            return 3;
        }
    }
 
    if (do_update_sanesecurity) {
        std::cout << _("[BastionGuard] Avvio aggiornamento SaneSecurity (modalità headless)...") << std::endl;
        try {
            bool ok = SaneSecurityUpdater::runHeadless();
            if (ok) {
                std::cout << _("[BastionGuard] ✔ Aggiornamento SaneSecurity completato.") << std::endl;
                return 0;
            } else {
                std::cerr << _("[BastionGuard] ❌ Errore durante l'aggiornamento SaneSecurity.") << std::endl;
                return 5;
            }
        } catch (const std::exception& ex) {
            std::cerr << _("[BastionGuard] ❌ Eccezione durante updateSaneSecurity(): ")
                      << ex.what() << std::endl;
            return 6;
        }
    }
 
    {
        struct passwd* pw = getpwnam("clamav");
        if (!pw) {
            std::cerr << _("[Main] ❌ Utente 'clamav' non trovato. Lo scanner userà l'utente normale.") << std::endl;
        } else {
            uid_t original_euid = geteuid();
            gid_t original_egid = getegid();
 
            setenv("BastionGuard_ORIG_EUID", std::to_string(original_euid).c_str(), 1);
            setenv("BastionGuard_ORIG_EGID", std::to_string(original_egid).c_str(), 1);
 
            initgroups("clamav", pw->pw_gid);
 
            if (setegid(pw->pw_gid) != 0)
                perror("[Main] setegid clamav");
 
            if (seteuid(pw->pw_uid) != 0)
                perror("[Main] seteuid clamav");
 
            std::cout << _("[Main] 🔐 Processo configurato per lanciare i sottoprocessi come 'clamav'") << std::endl;
 
            setegid(original_egid);
            seteuid(original_euid);
        }
    }
 
    int gtk_argc = static_cast<int>(gtk_argv.size());
    char** gtk_argv_data = gtk_argv.data();
 
    auto app = Glib::make_refptr_for_instance<ClamApp>(new ClamApp(start_minimized));
    return app->run(gtk_argc, gtk_argv_data);
}

References _, ClamApp::ClamApp(), ensure_lang_conf_exists(), ensureUserWrapperInstalled(), Backend::instance(), LOCALEDIR, main(), SaneSecurityUpdater::runHeadless(), and Backend::updatePhishLists().

◆ resolve_path()

std::string resolve_path	(	const std::string &	local,
		const std::string &	installed )

static

Definition at line 118 of file main.cpp.

                                                                                  {
    return std::filesystem::exists(local) ? local : installed;
}

References resolve_path().

Referenced by ClamApp::launch_main_window(), and resolve_path().

◆ should_enable_trayicon()

bool should_enable_trayicon ( )

static

Definition at line 72 of file main.cpp.

                                     {
    const std::string xdg_current = getenv_str("XDG_CURRENT_DESKTOP");
    const std::string xdg_session = getenv_str("XDG_SESSION_DESKTOP");
    const std::string desktop_sess = getenv_str("DESKTOP_SESSION");
 
    auto is = [&](const char* s) {
        return icontains(xdg_current, s) || icontains(xdg_session, s) || icontains(desktop_sess, s);
    };
 
    if (is("gnome") || is("xfce")) return true;
 
    if (is("kde") || is("plasma")) return true;
 
 
     if (is("cinnamon") || is("mate") || is("lxqt") || is("lxde")) return true;
 
    return false;
}

References getenv_str(), icontains(), and should_enable_trayicon().

Referenced by ClamApp::launch_main_window(), and should_enable_trayicon().

◆ wizard_needed()

bool wizard_needed ( )

static

Definition at line 123 of file main.cpp.

                            {
    namespace fs = std::filesystem;
    std::string cfgdir = Glib::build_filename(Glib::get_user_config_dir(), "BastionGuard");
    std::string cfgfile = cfgdir + "/config.json";
    if (!fs::exists(cfgfile)) return true;
 
    try {
        std::ifstream in(cfgfile);
        nlohmann::json j;
        in >> j;
        return !(j.contains("wizard_completed") && j["wizard_completed"].get<bool>() == true);
    } catch (...) {
        return true;
    }
}

References wizard_needed().

Referenced by ClamApp::on_activate(), and wizard_needed().

Classes

Functions

Function Documentation

◆ ensure_dir_exists()

◆ ensure_lang_conf_exists()

◆ ensureUserWrapperInstalled()

◆ getenv_str()

◆ icontains()

◆ main()

◆ resolve_path()

◆ should_enable_trayicon()

◆ wizard_needed()