PrivacyPage Class Reference

#include <PrivacyPage.hpp>

Inheritance diagram for PrivacyPage:

Public Member Functions
	PrivacyPage ()
	~PrivacyPage ()

Private Member Functions
void	run_privacy_script_async (bool unblock)
bool	is_daemon_active ()
void	start_privacy_daemon ()
void	unblock_devices_local ()
void	save_privacy_state (bool enabled)
bool	load_privacy_state ()
std::vector< std::string >	detect_active_devices ()
void	start_monitor_thread ()
void	monitor_loop ()
void	show_permission_popup (const std::string &process_name)
void	show_next_alert ()
void	on_toggle_privacy ()
void	on_refresh_clicked ()
void	setup_auto_refresh_toggle ()
void	update_process_list ()
void	manual_unlock_devices ()
void	write_log (const std::string &msg)

Private Attributes
Gtk::Label	lbl_title_
Gtk::Switch	switch_webcam_
Gtk::Button	btn_refresh_
Gtk::CheckButton	chk_auto_refresh_
Gtk::ScrolledWindow	scroller_
Gtk::TextView	txt_processes_
Gtk::Label	lbl_status_
std::thread	monitor_thread_
std::atomic< bool >	monitor_running_ {false}
std::set< std::string >	known_processes_
sigc::connection	auto_refresh_conn_
std::atomic< bool >	toggle_busy_ {false}
Gtk::Button	btn_unlock_
std::atomic< bool >	devices_blocked_ {false}
BastionGuard::AliveFlag	alive_ = BastionGuard::make_alive_flag()

Detailed Description

Definition at line 34 of file PrivacyPage.hpp.

Constructor & Destructor Documentation

PrivacyPage()

PrivacyPage::PrivacyPage

(

)

Definition at line 180 of file PrivacyPage.cpp.

    : Gtk::Box(Gtk::Orientation::VERTICAL, 12)
{
    set_margin(16);
    set_vexpand(true);
 
 
    auto title_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    title_box->add_css_class("secure-headerbar");
    title_box->set_margin_bottom(8);
 
    lbl_title_.set_text(_("🔒 Privacy Webcam / Microfono"));
    lbl_title_.set_margin(8);
    lbl_title_.set_halign(Gtk::Align::CENTER);
    lbl_title_.set_hexpand(true);
    lbl_title_.add_css_class("secure-header-title");
    title_box->append(lbl_title_);
    append(*title_box);
 
 
    bool last_state = load_privacy_state();
    switch_webcam_.set_active(last_state);
 
    try {
        std::string config_path = Glib::get_home_dir() + "/.config/BastionGuard/privacy.conf";
        if (Glib::file_test(config_path, Glib::FileTest::EXISTS)) {
            auto keyfile = Glib::KeyFile::create();
            keyfile->load_from_file(config_path);
            bool auto_refresh_enabled = false;
            if (keyfile->has_key("privacy", "auto_refresh"))
                auto_refresh_enabled = keyfile->get_boolean("privacy", "auto_refresh");
            chk_auto_refresh_.set_active(auto_refresh_enabled);
        }
    } catch (...) {
        std::cerr << _("[Privacy] Errore lettura auto_refresh") << std::endl;
    }
 
    switch_webcam_.set_halign(Gtk::Align::CENTER);
    switch_webcam_.set_valign(Gtk::Align::CENTER);
    switch_webcam_.set_margin_bottom(6);
    append(switch_webcam_);
 
    auto lbl_switch = Gtk::make_managed<Gtk::Label>(_("Abilita/Disabilita Webcam e Microfono"));
    lbl_switch->set_halign(Gtk::Align::CENTER);
    append(*lbl_switch);
 
 
    auto control_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    control_box->set_halign(Gtk::Align::CENTER);
 
    btn_refresh_.set_label(_("🔄 Aggiorna"));
    btn_refresh_.signal_clicked().connect(sigc::mem_fun(*this, &PrivacyPage::on_refresh_clicked));
    control_box->append(btn_refresh_);
 
    chk_auto_refresh_.set_label(_("Aggiornamento automatico ogni 5 minuti"));
    chk_auto_refresh_.signal_toggled().connect(sigc::mem_fun(*this, &PrivacyPage::setup_auto_refresh_toggle));
    control_box->append(chk_auto_refresh_);
    append(*control_box);
 
    btn_unlock_.set_label(_("🔓 Sblocca dispositivi"));
    btn_unlock_.add_css_class("btn-warning");
    btn_unlock_.set_halign(Gtk::Align::END);
    btn_unlock_.set_margin_top(10);
    btn_unlock_.set_visible(false);
 
    btn_unlock_.signal_clicked().connect([this]() {
        write_log(_("Richiesto sblocco manuale dei dispositivi"));
        manual_unlock_devices();
    });
 
 
    append(btn_unlock_);
 
 
    scroller_.set_vexpand(true);
    scroller_.set_hexpand(true);
    txt_processes_.set_editable(false);
    txt_processes_.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
    scroller_.set_child(txt_processes_);
    append(scroller_);
 
 
    lbl_status_.set_margin_top(8);
    lbl_status_.set_halign(Gtk::Align::CENTER);
    append(lbl_status_);
 
    {
        auto alive = alive_;
        Glib::signal_idle().connect_once([this, alive]() {
          BastionGuard::if_alive(alive, [this]() {
            try {
                std::string base_dir = Glib::get_home_dir() + "/.local/share/BastionGuard/logs";
                auto t = std::time(nullptr);
                std::tm tm{};
                localtime_r(&t, &tm);  // thread-safe rispetto a std::localtime
                char datebuf[16];
                std::strftime(datebuf, sizeof(datebuf), "%Y-%m-%d", &tm);
                std::string log_path = base_dir + "/privacyd_" + std::string(datebuf) + ".log";
 
                if (fs::exists(log_path)) {
                    std::ifstream log_file(log_path);
                    std::stringstream buffer;
                    buffer << log_file.rdbuf();
                    txt_processes_.get_buffer()->set_text(buffer.str());
                    lbl_status_.set_text(_("📜 Log giornaliero caricato."));
                } else {
                    lbl_status_.set_text(_("📝 Nessun log disponibile per oggi."));
                }
            } catch (...) {
                lbl_status_.set_text(_("⚠️ Errore durante il caricamento del log."));
            }
          });
        });
    }
 
 
    switch_webcam_.property_active().signal_changed().connect(
        sigc::mem_fun(*this, &PrivacyPage::on_toggle_privacy));
 
 
    {
      auto alive_ctor = alive_;
      Glib::signal_idle().connect_once([this, alive_ctor]() {
        if (!alive_ctor || !alive_ctor->load(std::memory_order_acquire)) return;
        lbl_status_.set_text(_("⏳ Inizializzazione del servizio privacy..."));
        write_log(_("=== Avvio BastionGuard PrivacyPage ==="));
        auto alive = alive_;
        std::thread([this, alive]() {
            if (!alive || !alive->load(std::memory_order_acquire)) return;
            if (!is_daemon_active())
                start_privacy_daemon();
            unblock_devices_local();
            Glib::signal_idle().connect_once([this, alive]() {
                BastionGuard::if_alive(alive, [this]() {
                    update_process_list();
                    lbl_status_.set_text(_("🕵️ Monitoraggio privacy attivo"));
                    monitor_running_ = true;
                    start_monitor_thread();
                });
            });
        }).detach();
      });
    }
}

References _, alive_, btn_refresh_, btn_unlock_, chk_auto_refresh_, BastionGuard::if_alive(), is_daemon_active(), lbl_status_, lbl_title_, load_privacy_state(), manual_unlock_devices(), monitor_running_, on_refresh_clicked(), on_toggle_privacy(), scroller_, setup_auto_refresh_toggle(), start_monitor_thread(), start_privacy_daemon(), switch_webcam_, txt_processes_, unblock_devices_local(), update_process_list(), and write_log().

~PrivacyPage()

PrivacyPage::~PrivacyPage

(

)

Definition at line 325 of file PrivacyPage.cpp.

                          {
    // Segnala ai lambda in volo (signal_idle + thread detached) che `this`
    // sta per sparire: faranno early-return invece di fare use-after-free.
    if (alive_) alive_->store(false, std::memory_order_release);
 
    monitor_running_ = false;
    if (monitor_thread_.joinable())
        monitor_thread_.join();
    write_log(_("=== Arresto monitoraggio privacy ==="));
}

References _, alive_, monitor_running_, monitor_thread_, and write_log().

Member Function Documentation

detect_active_devices()

std::vector< std::string > PrivacyPage::detect_active_devices ( )

private

Definition at line 356 of file PrivacyPage.cpp.

                                                        {
    std::vector<std::string> result;
    const std::vector<std::string> prefixes = {"/dev/video", "/dev/snd/pcm"};
 
    // Usiamo l'overload con std::error_code per NON lanciare eccezioni:
    // /proc è intrinsecamente race-y (i PID possono sparire in qualsiasi momento)
    // e una filesystem_error non gestita in questo thread causerebbe std::terminate().
    std::error_code ec;
    fs::directory_iterator proc_it("/proc", ec);
    if (ec) {
        // Impossibile aprire /proc: restituiamo una lista vuota anziché crashare.
        return result;
    }
 
    for (; proc_it != fs::directory_iterator(); proc_it.increment(ec)) {
        if (ec) {
            // Errore avanzando l'iteratore (es. PID scomparso): fermiamo il ciclo
            // in modo pulito, i device attivi verranno rilevati al prossimo giro.
            break;
        }
 
        const auto& pid_entry = *proc_it;
 
        std::error_code ec_dir;
        if (!pid_entry.is_directory(ec_dir) || ec_dir) continue;
 
        const std::string pid_str = pid_entry.path().filename().string();
        if (!std::all_of(pid_str.begin(), pid_str.end(), ::isdigit)) continue;
 
        const std::string fd_path = "/proc/" + pid_str + "/fd";
        std::error_code ec_exists;
        if (!fs::exists(fd_path, ec_exists) || ec_exists) continue;
 
        // Lazy: carichiamo info processo solo se troviamo un fd interessante
        std::string comm, exe, cmdline;
        bool proc_info_loaded = false;
 
        // Anche qui: overload con error_code. Se il processo muore tra exists()
        // e la creazione dell'iteratore, non vogliamo un'eccezione non gestita.
        std::error_code ec_fd;
        fs::directory_iterator fd_it(
            fd_path,
            fs::directory_options::skip_permission_denied,
            ec_fd);
        if (ec_fd) continue;
 
        for (; fd_it != fs::directory_iterator(); fd_it.increment(ec_fd)) {
            if (ec_fd) break; // pid scomparso mentre iteravamo: skippa questo PID
 
            const auto& fd_entry = *fd_it;
 
            std::error_code ec_link;
            auto link_target = fs::read_symlink(fd_entry.path(), ec_link);
            if (ec_link) continue;
            std::string target = link_target.string();
 
            bool matches = false;
            for (const auto& prefix : prefixes) {
                if (target.rfind(prefix, 0) == 0) { // starts_with(prefix)
                    matches = true;
                    break;
                }
            }
            if (!matches) continue;
 
            if (!proc_info_loaded) {
                comm = read_text_file("/proc/" + pid_str + "/comm");
                if (comm.empty()) comm = "(sconosciuto)";
                exe = read_exe_path(pid_str);
                cmdline = read_cmdline("/proc/" + pid_str + "/cmdline");
                proc_info_loaded = true;
            }
 
            // Soppressione popup per terminali/polkit/portal/pipewire ecc.
            if (is_noise_process(comm, exe, cmdline)) break;
 
            // Soppressione anche se un parent (fino a 3 livelli) è un processo "noise"
            if (parent_is_noise(pid_str)) break;
 
            result.push_back(comm + " (PID=" + pid_str + ")");
            break; // trovato un accesso rilevante per questo PID, passa al prossimo PID
        }
    }
 
    std::sort(result.begin(), result.end());
    result.erase(std::unique(result.begin(), result.end()), result.end());
    return result;
}

References is_noise_process(), parent_is_noise(), read_cmdline(), read_exe_path(), and read_text_file().

Referenced by monitor_loop(), and update_process_list().

is_daemon_active()

bool PrivacyPage::is_daemon_active ( )

private

Definition at line 337 of file PrivacyPage.cpp.

                                   {
    int rc = (bg_process::run({"/usr/libexec/bastionguard/bastionguard-service", "--user", "is-active", "BastionGuard-privacyd.service"}).exit_code);
    return (WIFEXITED(rc) && WEXITSTATUS(rc) == 0);
}

References bg_process::run().

Referenced by PrivacyPage().

load_privacy_state()

bool PrivacyPage::load_privacy_state ( )

private

Definition at line 851 of file PrivacyPage.cpp.

                                     {
    try {
        auto keyfile = Glib::KeyFile::create();
        std::string config_path = Glib::get_home_dir() + "/.config/BastionGuard/privacy.conf";
        if (Glib::file_test(config_path, Glib::FileTest::EXISTS)) {
            keyfile->load_from_file(config_path);
            return keyfile->get_boolean("privacy", "enabled");
        }
    } catch (...) {
        std::cerr << _("[Privacy] Errore caricamento config") << std::endl;
    }
    return true;
}

References _.

Referenced by PrivacyPage().

manual_unlock_devices()

void PrivacyPage::manual_unlock_devices ( )

private

Definition at line 929 of file PrivacyPage.cpp.

                                        {
    auto alive = alive_;
    std::thread([this, alive]() {
        const bool ok = run_privhelper_pkexec("unblock");
 
        Glib::signal_idle().connect_once([this, alive, ok]() {
            BastionGuard::if_alive(alive, [this, ok]() {
                if (ok) {
                    write_log(_("🔓 Dispositivi sbloccati manualmente"));
                    devices_blocked_ = false;
                    btn_unlock_.set_visible(false);
                    lbl_status_.set_text(_("Webcam e microfono sbloccati"));
                } else {
                    write_log(_("❌ Errore durante sblocco manuale"));
                    lbl_status_.set_text(_("❌ Impossibile sbloccare i dispositivi."));
                }
 
                update_process_list();
            });
        });
    }).detach();
}

References _, alive_, btn_unlock_, devices_blocked_, BastionGuard::if_alive(), lbl_status_, run_privhelper_pkexec(), update_process_list(), and write_log().

Referenced by PrivacyPage().

monitor_loop()

void PrivacyPage::monitor_loop ( )

private

Definition at line 453 of file PrivacyPage.cpp.

                               {
    while (monitor_running_) {
        try {
            auto processes = detect_active_devices();
            for (const auto &proc : processes) {
                if (!known_processes_.count(proc)) {
                    known_processes_.insert(proc);
                    write_log(Glib::ustring::compose(_("Nuovo accesso rilevato: %1"), proc));
                    auto alive = alive_;
                    Glib::signal_idle().connect_once([this, alive, proc]() {
                        BastionGuard::if_alive(alive, [this, &proc]() {
                            show_permission_popup(proc);
                        });
                    });
                }
            }
            for (auto it = known_processes_.begin(); it != known_processes_.end();) {
                if (std::find(processes.begin(), processes.end(), *it) == processes.end())
                    it = known_processes_.erase(it);
                else ++it;
            }
        } catch (const std::exception& e) {
            // Difesa in profondità: un'eccezione non catturata qui ucciderebbe il thread
            // (std::terminate -> SIGABRT). La logghiamo e proseguiamo al prossimo giro.
            try {
                write_log(std::string(_("⚠️ Errore in monitor_loop: ")) + e.what());
            } catch (...) { /* nulla di più da fare */ }
        } catch (...) {
            try {
                write_log(_("⚠️ Errore sconosciuto in monitor_loop"));
            } catch (...) { /* nulla di più da fare */ }
        }
        std::this_thread::sleep_for(std::chrono::seconds(3));
    }
}

References _, alive_, detect_active_devices(), BastionGuard::if_alive(), known_processes_, monitor_running_, show_permission_popup(), and write_log().

Referenced by start_monitor_thread().

on_refresh_clicked()

void PrivacyPage::on_refresh_clicked ( )

private

Definition at line 673 of file PrivacyPage.cpp.

                                     {
    lbl_status_.set_text(_("🔄 Aggiornamento elenco processi e log..."));
    write_log(_("Aggiornamento manuale avviato"));
    update_process_list();
}

References _, lbl_status_, update_process_list(), and write_log().

Referenced by PrivacyPage().

on_toggle_privacy()

void PrivacyPage::on_toggle_privacy ( )

private

Definition at line 865 of file PrivacyPage.cpp.

                                    {
    if (toggle_busy_.load())
        return;
 
    const bool active = switch_webcam_.get_active();
    save_privacy_state(active);
 
    switch_webcam_.set_sensitive(false);
    lbl_status_.set_text(active
        ? _("📷 Riattivazione webcam/microfono...")
        : _("🔒 Disattivazione webcam/microfono in corso..."));
 
    write_log(std::string(_("Toggle privacy: ")) + (active ? "ON (unblock)" : "OFF (block)"));
 
    toggle_busy_ = true;
    run_privacy_script_async(active);
}

References _, lbl_status_, run_privacy_script_async(), save_privacy_state(), switch_webcam_, toggle_busy_, and write_log().

Referenced by PrivacyPage().

run_privacy_script_async()

void PrivacyPage::run_privacy_script_async ( bool unblock )

private

Definition at line 885 of file PrivacyPage.cpp.

                                                       {
    auto alive = alive_;
    std::thread([this, alive, unblock]() {
 
        const bool ok = run_privhelper_pkexec(unblock ? "unblock" : "block");
 
 
        Glib::signal_idle().connect_once([this, alive, ok, unblock]() {
          BastionGuard::if_alive(alive, [this, ok, unblock]() {
            if (ok) {
                if (unblock) {
 
                    lbl_status_.set_text(_("🕵️ Monitoraggio privacy attivo"));
                    write_log(_("Script OK: UNBLOCK eseguito"));
                    monitor_running_ = true;
                    if (!monitor_thread_.joinable()) {
                        start_monitor_thread();
                    }
                } else {
 
                    lbl_status_.set_text(_("🔕 Privacy monitor disattivato"));
                    write_log(_("Script OK: BLOCK eseguito"));
                    monitor_running_ = false;
                    if (monitor_thread_.joinable()) {
                        monitor_thread_.join();
                    }
                }
            } else {
 
                write_log(_("ERRORE: esecuzione script privacy fallita"));
                lbl_status_.set_text(_("❌ Errore nell'esecuzione dello script."));
 
                switch_webcam_.set_active(!unblock);
            }
 
 
            update_process_list();
            switch_webcam_.set_sensitive(true);
            toggle_busy_ = false;
          });
        });
    }).detach();
}

References _, alive_, BastionGuard::if_alive(), lbl_status_, monitor_running_, monitor_thread_, run_privhelper_pkexec(), start_monitor_thread(), switch_webcam_, toggle_busy_, update_process_list(), and write_log().

Referenced by on_toggle_privacy().

save_privacy_state()

void PrivacyPage::save_privacy_state ( bool enabled )

private

Definition at line 835 of file PrivacyPage.cpp.

                                                 {
    try {
        auto keyfile = Glib::KeyFile::create();
        auto config_dir = Glib::get_home_dir() + "/.config/BastionGuard";
        if (!std::filesystem::exists(config_dir))
            std::filesystem::create_directories(config_dir);
 
        std::string config_path = config_dir + "/privacy.conf";
        keyfile->set_boolean("privacy", "enabled", enabled);
        keyfile->save_to_file(config_path);
        write_log(enabled ? _("Privacy abilitata") : _("Privacy disabilitata"));
    } catch (const Glib::Error &e) {
        std::cerr << _("[Privacy] Errore salvataggio config: ") << e.what() << std::endl;
    }
}

References _, and write_log().

Referenced by on_toggle_privacy().

setup_auto_refresh_toggle()

void PrivacyPage::setup_auto_refresh_toggle ( )

private

Definition at line 681 of file PrivacyPage.cpp.

                                            {
    bool enabled = chk_auto_refresh_.get_active();
 
 
    try {
        auto keyfile = Glib::KeyFile::create();
        std::string config_dir = Glib::get_home_dir() + "/.config/BastionGuard";
        std::string config_path = config_dir + "/privacy.conf";
 
        if (!fs::exists(config_dir))
            fs::create_directories(config_dir);
 
        if (Glib::file_test(config_path, Glib::FileTest::EXISTS))
            keyfile->load_from_file(config_path);
 
        keyfile->set_boolean("privacy", "auto_refresh", enabled);
        keyfile->save_to_file(config_path);
        write_log(enabled ? _("Auto aggiornamento attivato (salvato in config)")
                          : _("Auto aggiornamento disattivato (salvato in config)"));
    } catch (const Glib::Error& e) {
        std::cerr << _("[Privacy] Errore salvataggio auto_refresh: ") << e.what() << std::endl;
    }
 
 
    if (enabled) {
        lbl_status_.set_text(_("⏳ Auto aggiornamento attivo ogni 5 minuti."));
        auto_refresh_conn_ = Glib::signal_timeout().connect_seconds(
            [this]() {
                // update_process_list() lancia internamente un thread protetto
                // dall'alive flag, quindi è sicuro anche se la pagina muore.
                update_process_list();
                return chk_auto_refresh_.get_active();
            },
            300);
    } else {
        lbl_status_.set_text(_("🛑 Auto aggiornamento disattivato."));
        auto_refresh_conn_.disconnect();
    }
}

References _, auto_refresh_conn_, chk_auto_refresh_, lbl_status_, update_process_list(), and write_log().

Referenced by PrivacyPage().

show_next_alert()

void PrivacyPage::show_next_alert ( )

private

Definition at line 500 of file PrivacyPage.cpp.

                                  {
    if (alert_queue_.empty() || current_alert_)
        return;
 
    std::string proc = alert_queue_.front();
    alert_queue_.pop();
    size_t pending = alert_queue_.size();
 
    current_alert_ = Gtk::make_managed<Gtk::Window>();
    auto *win = current_alert_;
 
    win->set_title("");
    win->set_default_size(480, 230);
    win->set_resizable(false);
    win->set_modal(false);
    win->add_css_class("BastionGuard-popup");
    win->add_css_class("BastionGuard-dialog");
 
 
    if (auto* root = dynamic_cast<Gtk::Window*>(get_root()))
        win->set_transient_for(*root);
 
 
    auto *header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->add_css_class("custom-headerbar");
 
 
    auto *left = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    left->set_size_request(240, -1);
 
    auto *title_lbl = Gtk::make_managed<Gtk::Label>(_("⚠️ Accesso dispositivo rilevato"));
    title_lbl->add_css_class("BastionGuard-title");
    title_lbl->set_halign(Gtk::Align::START);
    left->append(*title_lbl);
 
    header->pack_start(*left);
 
 
    auto *center = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    center->set_hexpand(true);
    header->pack_start(*center);
 
 
    auto *right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
 
    try {
        auto pmin = Gdk::Pixbuf::create_from_file(resource("icon-minimize.png"), 28, 28, true);
        auto *btn_min = Gtk::make_managed<Gtk::Button>();
        btn_min->set_child(*Gtk::make_managed<Gtk::Image>(pmin));
        btn_min->add_css_class("header-button");
        btn_min->signal_clicked().connect([win]() { win->minimize(); });
        right->append(*btn_min);
    } catch (...) {}
 
    try {
        auto pclose = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 28, 28, true);
        auto *btn_close = Gtk::make_managed<Gtk::Button>();
        btn_close->set_child(*Gtk::make_managed<Gtk::Image>(pclose));
        btn_close->add_css_class("header-button");
        btn_close->signal_clicked().connect([this, win]() {
            win->close();
            current_alert_ = nullptr;
            auto alive = alive_;
            Glib::signal_idle().connect_once([this, alive]() {
                BastionGuard::if_alive(alive, [this]() { show_next_alert(); });
            });
        });
        right->append(*btn_close);
    } catch (...) {}
 
    header->pack_end(*right);
 
    win->set_titlebar(*header);
 
 
    auto *vbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
    vbox->set_margin(20);
    win->set_child(*vbox);
 
    auto *msg = Gtk::make_managed<Gtk::Label>(
        Glib::ustring::compose(
            _("<b>%1</b> sta tentando di accedere a webcam o microfono."),
            proc
        )
    );
    msg->set_use_markup(true);
    msg->set_wrap(true);
    msg->set_halign(Gtk::Align::CENTER);
    vbox->append(*msg);
 
    if (pending > 0) {
        auto *lbl_pending = Gtk::make_managed<Gtk::Label>(
            Glib::ustring::compose(_("🕒 %1 altri processi in attesa..."), pending));
        lbl_pending->set_halign(Gtk::Align::CENTER);
        vbox->append(*lbl_pending);
    }
 
 
    auto *btn_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 12);
    btn_box->set_halign(Gtk::Align::CENTER);
 
    auto *btn_allow = Gtk::make_managed<Gtk::Button>(_("✔ Consenti"));
    auto *btn_deny  = Gtk::make_managed<Gtk::Button>(_("✖ Nega"));
 
    btn_allow->add_css_class("btn-primary");
    btn_deny->add_css_class("btn-danger");
 
    btn_box->append(*btn_allow);
    btn_box->append(*btn_deny);
    vbox->append(*btn_box);
 
    btn_allow->signal_clicked().connect([this, proc, win]() {
        write_log(Glib::ustring::compose(_("Accesso CONSENTITO a %1"), proc));
 
        win->close();
        current_alert_ = nullptr;
 
        auto alive = alive_;
        Glib::signal_idle().connect_once([this, alive]() {
            BastionGuard::if_alive(alive, [this]() { show_next_alert(); });
        });
    });
 
 
    btn_deny->signal_clicked().connect([this, proc, win]() {
 
    write_log(Glib::ustring::compose(
        _("Accesso NEGATO a %1 — blocco webcam/microfono"), proc));
 
 
    devices_blocked_ = true;
 
 
    btn_unlock_.set_visible(true);
 
 
    auto alive = alive_;
    std::thread([this, alive]() {
        const bool ok = run_privhelper_pkexec("block");
 
        Glib::signal_idle().connect_once([this, alive, ok]() {
            BastionGuard::if_alive(alive, [this, ok]() {
                if (!ok) {
                    write_log(_("❌ ERRORE: impossibile applicare il blocco tramite helper!"));
                    lbl_status_.set_text(_("❌ Errore: impossibile bloccare webcam/microfono"));
                } else {
                    write_log(_("🔒 Webcam/microfono BLOCCATI tramite helper (popup)"));
                    lbl_status_.set_text(_("🔒 Webcam e microfono bloccati"));
                }
 
                update_process_list();
            });
        });
    }).detach();
 
 
    win->close();
    current_alert_ = nullptr;
    {
        auto alive2 = alive_;
        Glib::signal_idle().connect_once([this, alive2]() {
            BastionGuard::if_alive(alive2, [this]() { show_next_alert(); });
        });
    }
    });
 
 
    win->present();
}

References _, alert_queue_, alive_, btn_unlock_, current_alert_, devices_blocked_, BastionGuard::if_alive(), lbl_status_, resource(), run_privhelper_pkexec(), show_next_alert(), update_process_list(), and write_log().

Referenced by show_next_alert(), and show_permission_popup().

show_permission_popup()

void PrivacyPage::show_permission_popup ( const std::string & process_name )

private

Definition at line 490 of file PrivacyPage.cpp.

                                                                     {
    alert_queue_.push(process_name);
    if (!current_alert_) {
        auto alive = alive_;
        Glib::signal_idle().connect_once([this, alive]() {
            BastionGuard::if_alive(alive, [this]() { show_next_alert(); });
        });
    }
}

References alert_queue_, alive_, current_alert_, BastionGuard::if_alive(), and show_next_alert().

Referenced by monitor_loop().

start_monitor_thread()

void PrivacyPage::start_monitor_thread ( )

private

Definition at line 448 of file PrivacyPage.cpp.

                                       {
    monitor_thread_ = std::thread(&PrivacyPage::monitor_loop, this);
    write_log(_("🕵️ Monitoraggio in tempo reale avviato"));
}

References _, monitor_loop(), monitor_thread_, and write_log().

Referenced by PrivacyPage(), and run_privacy_script_async().

start_privacy_daemon()

void PrivacyPage::start_privacy_daemon ( )

private

Definition at line 342 of file PrivacyPage.cpp.

                                       {
    write_log(_("Avvio automatico del servizio BastionGuard-privacyd..."));
    (bg_process::run({"/usr/libexec/bastionguard/bastionguard-service", "--user", "start", "BastionGuard-privacyd.service"}).exit_code);
}

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

Referenced by PrivacyPage().

unblock_devices_local()

void PrivacyPage::unblock_devices_local ( )

private

Definition at line 348 of file PrivacyPage.cpp.

                                        {
    if (run_privhelper_pkexec("unblock"))
        write_log(_("📷 Webcam/Microfono sbloccati automaticamente"));
    else
        write_log(_("❌ Errore nello sblocco automatico"));
}

References _, run_privhelper_pkexec(), and write_log().

Referenced by PrivacyPage().

update_process_list()

void PrivacyPage::update_process_list ( )

private

Definition at line 723 of file PrivacyPage.cpp.

                                      {
    auto alive = alive_;
    std::thread([this, alive]() {
        if (!alive || !alive->load(std::memory_order_acquire)) return;
        try {
 
            auto processes = detect_active_devices();
            std::ostringstream oss;
            if (processes.empty()) {
                oss << _("Nessun processo sta utilizzando webcam o microfono.") << "\n\n";
            } else {
                oss << _("📋 Processi attivi:\n\n");
                for (const auto &p : processes)
                    oss << " • " << p << "\n";
                oss << "\n";
            }
 
 
            oss << "────────────────────────────────────────────\n";
            oss << _("📜 Log giornaliero:\n\n");
 
 
            std::string base_dir = Glib::get_home_dir() + "/.local/share/BastionGuard/logs";
            auto t = std::time(nullptr);
            std::tm tm{};
            localtime_r(&t, &tm);  // thread-safe rispetto a std::localtime
            char datebuf[16];
            std::strftime(datebuf, sizeof(datebuf), "%Y-%m-%d", &tm);
            std::string log_path = base_dir + "/privacyd_" + std::string(datebuf) + ".log";
 
            if (fs::exists(log_path)) {
                std::ifstream log_file(log_path);
                if (log_file.is_open()) {
                    std::stringstream buffer;
                    buffer << log_file.rdbuf();
                    oss << buffer.str();
                } else {
                    oss << _("⚠️ Impossibile leggere il log giornaliero.") << "\n";
                }
            } else {
                oss << _("📝 Nessun log disponibile per oggi.") << "\n";
            }
 
 
            Glib::signal_idle().connect_once([this, alive, txt = oss.str()]() {
                BastionGuard::if_alive(alive, [this, &txt]() {
                    txt_processes_.get_buffer()->set_text(txt);
                    lbl_status_.set_text(_("✅ Aggiornamento completato."));
                });
            });
 
        } catch (const std::exception &e) {
            std::string err = std::string(_("Errore update_process_list: ")) + e.what();
            write_log(err);
        }
    }).detach();
}

References _, alive_, detect_active_devices(), and write_log().

Referenced by manual_unlock_devices(), on_refresh_clicked(), PrivacyPage(), run_privacy_script_async(), setup_auto_refresh_toggle(), and show_next_alert().

write_log()

void PrivacyPage::write_log ( const std::string & msg )

private

Definition at line 783 of file PrivacyPage.cpp.

                                                {
    std::thread([msg]() {
        try {
            std::string base_dir = Glib::get_home_dir() + "/.local/share/BastionGuard/logs";
            if (!fs::exists(base_dir))
                fs::create_directories(base_dir);
 
 
            auto t = std::time(nullptr);
            std::tm tm{};
            localtime_r(&t, &tm);  // thread-safe rispetto a std::localtime
            char datebuf[16];
            std::strftime(datebuf, sizeof(datebuf), "%Y-%m-%d", &tm);
            std::string log_path = base_dir + "/privacyd_" + std::string(datebuf) + ".log";
 
 
            std::ofstream log(log_path, std::ios::app);
            if (log.is_open()) {
                char timebuf[32];
                std::strftime(timebuf, sizeof(timebuf), "%H:%M:%S", &tm);
                log << "[" << timebuf << "] " << msg << std::endl;
            }
 
 
            const auto now = std::chrono::system_clock::now();
            const auto seven_days = std::chrono::hours(24 * 7);
 
            for (const auto& entry : fs::directory_iterator(base_dir)) {
                if (entry.is_regular_file()) {
                    auto ftime = fs::last_write_time(entry);
                    auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                    ftime - fs::file_time_type::clock::now()
                    + std::chrono::system_clock::now());
                    auto age = now - sctp;
                    if (age > seven_days) {
                        try {
                            fs::remove(entry.path());
                        } catch (...) {
 
                        }
                    }
                }
            }
 
        } catch (...) {
            std::cerr << _("[Privacy] Errore scrittura log giornaliero.") << std::endl;
        }
    }).detach();
}

References _.

Referenced by manual_unlock_devices(), monitor_loop(), on_refresh_clicked(), on_toggle_privacy(), PrivacyPage(), run_privacy_script_async(), save_privacy_state(), setup_auto_refresh_toggle(), show_next_alert(), start_monitor_thread(), start_privacy_daemon(), unblock_devices_local(), update_process_list(), and ~PrivacyPage().

Member Data Documentation

alive_

BastionGuard::AliveFlag PrivacyPage::alive_ = BastionGuard::make_alive_flag()

private

Definition at line 92 of file PrivacyPage.hpp.

Referenced by manual_unlock_devices(), monitor_loop(), PrivacyPage(), run_privacy_script_async(), show_next_alert(), show_permission_popup(), update_process_list(), and ~PrivacyPage().

auto_refresh_conn_

sigc::connection PrivacyPage::auto_refresh_conn_

private

Definition at line 53 of file PrivacyPage.hpp.

Referenced by setup_auto_refresh_toggle().

btn_refresh_

Gtk::Button PrivacyPage::btn_refresh_

private

Definition at line 43 of file PrivacyPage.hpp.

Referenced by PrivacyPage().

btn_unlock_

Gtk::Button PrivacyPage::btn_unlock_

private

Definition at line 83 of file PrivacyPage.hpp.

Referenced by manual_unlock_devices(), PrivacyPage(), and show_next_alert().

chk_auto_refresh_

Gtk::CheckButton PrivacyPage::chk_auto_refresh_

private

Definition at line 44 of file PrivacyPage.hpp.

Referenced by PrivacyPage(), and setup_auto_refresh_toggle().

devices_blocked_

std::atomic<bool> PrivacyPage::devices_blocked_ {false}

private

Definition at line 84 of file PrivacyPage.hpp.

Referenced by manual_unlock_devices(), and show_next_alert().

known_processes_

std::set<std::string> PrivacyPage::known_processes_

private

Definition at line 52 of file PrivacyPage.hpp.

Referenced by monitor_loop().

lbl_status_

Gtk::Label PrivacyPage::lbl_status_

private

Definition at line 47 of file PrivacyPage.hpp.

Referenced by manual_unlock_devices(), on_refresh_clicked(), on_toggle_privacy(), PrivacyPage(), run_privacy_script_async(), setup_auto_refresh_toggle(), and show_next_alert().

lbl_title_

Gtk::Label PrivacyPage::lbl_title_

private

Definition at line 41 of file PrivacyPage.hpp.

Referenced by PrivacyPage().

monitor_running_

std::atomic<bool> PrivacyPage::monitor_running_ {false}

private

Definition at line 51 of file PrivacyPage.hpp.

Referenced by monitor_loop(), PrivacyPage(), run_privacy_script_async(), and ~PrivacyPage().

monitor_thread_

std::thread PrivacyPage::monitor_thread_

private

Definition at line 50 of file PrivacyPage.hpp.

Referenced by run_privacy_script_async(), start_monitor_thread(), and ~PrivacyPage().

scroller_

Gtk::ScrolledWindow PrivacyPage::scroller_

private

Definition at line 45 of file PrivacyPage.hpp.

Referenced by PrivacyPage().

switch_webcam_

Gtk::Switch PrivacyPage::switch_webcam_

private

Definition at line 42 of file PrivacyPage.hpp.

Referenced by on_toggle_privacy(), PrivacyPage(), and run_privacy_script_async().

toggle_busy_

std::atomic<bool> PrivacyPage::toggle_busy_ {false}

private

Definition at line 58 of file PrivacyPage.hpp.

Referenced by on_toggle_privacy(), and run_privacy_script_async().

txt_processes_

Gtk::TextView PrivacyPage::txt_processes_

private

Definition at line 46 of file PrivacyPage.hpp.

Referenced by PrivacyPage().

---

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

• BastionGuard/src/PrivacyPage.hpp
• BastionGuard/src/PrivacyPage.cpp