main.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 "Resource.hpp"
#include "MainWindow.hpp"
#include "Backend.hpp"
#include "StyleProvider.hpp"
#include "TrayIcon.hpp"
#include "SaneSecurityUpdater.hpp"
#include "wizard/wizard_window.hpp"
#include "SettingsWindow.hpp"
#include "SettingsStore.hpp"
 
#include "first_run/first-run-services-window.hpp"
 
#include <gtkmm/application.h>
#include <glib/gi18n.h>
#include <fstream>
#include <iostream>
#include <filesystem>
#include <memory>
#include <nlohmann/json.hpp>
#include <cstdlib>
#include <map>
#include <vector>
#include <system_error>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
 
namespace fs = std::filesystem;
 
static void ensure_dir_exists(const std::string& dir) {
    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;
    }
}
 
static std::string getenv_str(const char* k) {
    const char* v = std::getenv(k);
    return (v && *v) ? std::string(v) : std::string();
}
 
static bool icontains(std::string hay, std::string needle) {
    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;
}
 
 
static bool should_enable_trayicon() {
    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;
}
 
 
static void ensure_lang_conf_exists(const std::string& lang_conf_path) {
    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;
}
 
 
static std::string resolve_path(const std::string& local, const std::string& installed) {
    return std::filesystem::exists(local) ? local : installed;
}
 
 
static bool wizard_needed() {
    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;
    }
}
 
 
static void ensureUserWrapperInstalled() {
    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";
    }
}
 
 
 
 
class ClamApp : public Gtk::Application {
public:
    ClamApp(bool start_minimized)
        : Gtk::Application("org.BastionGuard.gui"),
          start_minimized_(start_minimized)
    {}
 
protected:
    void on_activate() override {
        if (win_) {
            win_->present();
            return;
        }
 
        if (wizard_needed()) {
            auto wiz = new BastionGuard::wizard::WizardWindow();
            add_window(*wiz);
 
            load_style();
 
            wiz->signal_finished().connect([this, wiz]() {
                wiz->hide();
                delete wiz;
                launch_main_window();
            });
 
            wiz->present();
            return;
        }
 
        launch_main_window();
 
        FirstRunServicesWindow::maybe_show();
 
        if (!start_minimized_ && win_) {
            win_->present();
        }
    }
 
private:
  void launch_main_window() {
    win_ = new MainWindow();
    add_window(*win_);
 
    load_style();
 
    win_->set_resizable(false);
    win_->set_default_size(600, 400);
 
    bool tray_ok = should_enable_trayicon();
 
 
    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);
    };
 
    const bool is_gnome = is("gnome");
 
#if BASTIONGUARD_HAS_SDBUS
    if (is_gnome) {
        tray_ok = true;
    }
#else
    tray_ok = false;
#endif
 
    const bool hide_on_close = tray_ok;
 
 
    if (hide_on_close && !holding_) {
        hold();
        holding_ = true;
    }
 
    win_->signal_close_request().connect(
        [this, hide_on_close]() -> bool {
            if (!hide_on_close)
                return false;
 
            if (win_)
                win_->hide();
 
            return true;
        },
        false
    );
 
 
    if (start_minimized_ && !tray_ok) {
        start_minimized_ = false;
    }
 
    if (!start_minimized_) {
        win_->present();
    } else {
        win_->hide();
    }
 
    if (tray_ok) {
    tray_ = std::make_unique<TrayIcon>();
 
    tray_->bind_ui_context();
 
    const std::string icon_path =
        resolve_path("data/logo.png", std::string(DATA_DIR) + "/logo.png");
 
    tray_->set_icon_file(icon_path, 32);
    tray_->set_tooltip(_("BastionGuard in esecuzione"));
 
    tray_->set_on_activate([this]() {
        // NB: questa lambda è già dispatchata sul main loop GTK da TrayIcon
        // via g_main_context_invoke(ui_ctx_, ...). Tuttavia, sd_bus può
        // invocarla all'interno di sd_bus_process: per evitare che gtk_widget_show
        // riesca a generare un GMainContext annidato dentro lo stack di un
        // callback sd_bus (che è la causa del crash SIGTRAP visto in
        // g_main_context_new_with_flags -> g_log fatale), differiamo
        // ulteriormente di un giro idle del main loop.
        Glib::signal_idle().connect_once([this]() {
            if (!win_) return;
            try {
                // IMPORTANTE: present() PRIMA di showDashboard().
                // Se l'app è stata avviata con --minimized, alla prima Activate
                // dalla tray la finestra non è ancora "realized": chiamare
                // showDashboard() (che fa grab_focus su widget non realizzati)
                // emette un g_critical che, con G_DEBUG=fatal-criticals,
                // termina il processo. Realizziamo la finestra prima.
                win_->present();
                win_->showDashboard();
            } catch (const std::exception& ex) {
                std::cerr << "[ClamApp] tray activate: " << ex.what() << std::endl;
            } catch (...) {
                std::cerr << "[ClamApp] tray activate: errore sconosciuto" << std::endl;
            }
        });
    });
 
    tray_->set_on_settings([this]() {
        Glib::signal_idle().connect_once([this]() {
            if (!win_) return;
            try {
                win_->open_settings_window();
            } catch (const std::exception& ex) {
                std::cerr << "[ClamApp] tray settings: " << ex.what() << std::endl;
            } catch (...) {
                std::cerr << "[ClamApp] tray settings: errore sconosciuto" << std::endl;
            }
        });
    });
 
    tray_->set_on_quit([this]() {
        Glib::signal_idle().connect_once([this]() {
            if (tray_) tray_->stop();
            quit();
        });
    });
 
    tray_->start();
    }
}
 
private:
    MainWindow* win_ = nullptr;
    std::unique_ptr<TrayIcon> tray_;
    bool start_minimized_;
    bool holding_ = false;
};
 
 
 
int main(int argc, char *argv[]) {
 
    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);
}