PrivacyPage.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 "SafeProcess.hpp"
#include "PrivacyPage.hpp"
#include "Resource.hpp"
#include <filesystem>
#include <fstream>
#include <iostream>
#include <thread>
#include <queue>
#include <set>
#include <atomic>
#include <csignal>
#include <unistd.h>
#include <cerrno>
#include <sys/wait.h>
#include <glibmm/i18n.h>
#include <glibmm/miscutils.h>
#include <glibmm/main.h>
#include <glibmm/keyfile.h>
#include <glibmm/fileutils.h>
 
namespace fs = std::filesystem;
 
std::queue<std::string> alert_queue_;
Gtk::Window* current_alert_ = nullptr;
 
 
static bool run_privhelper_pkexec(const std::string& action) {
    if (action != "block" && action != "unblock")
        return false;
 
    const pid_t pid = ::fork();
    if (pid < 0)
        return false;
 
    if (pid == 0) {
        ::execl(
            "/usr/bin/pkexec",
            "pkexec",
            "/usr/bin/bastionguard-privhelper",
            action.c_str(),
            static_cast<char*>(nullptr)
        );
        _exit(127);
    }
 
    int status = 0;
    while (::waitpid(pid, &status, 0) < 0) {
        if (errno == EINTR)
            continue;
        return false;
    }
 
    return WIFEXITED(status) && WEXITSTATUS(status) == 0;
}
 
 
static std::string read_text_file(const std::string& path) {
    std::ifstream f(path);
    if (!f.is_open()) return {};
    std::string s;
    std::getline(f, s);
    return s;
}
 
static std::string read_cmdline(const std::string& path) {
    std::ifstream f(path, std::ios::binary);
    if (!f.is_open()) return {};
    std::string buf((std::istreambuf_iterator<char>(f)), {});
    for (char& c : buf) if (c == '\0') c = ' ';
    return buf;
}
 
static std::string read_exe_path(const std::string& pid_str) {
    std::error_code ec;
    auto p = fs::read_symlink("/proc/" + pid_str + "/exe", ec);
    if (ec) return {};
    return p.string();
}
 
static bool is_noise_process(const std::string& comm,
                             const std::string& exe,
                             const std::string& cmdline)
{
    // Match per nome (comm)
    static const std::set<std::string> kCommDeny = {
        "bash","zsh","fish","sh","dash",
        "konsole","gnome-terminal-","xfce4-terminal","kitty","alacritty","wezterm",
        "tmux","screen",
        "pkexec",
        "polkitd","polkit-agent-helper-1","polkit-kde-authentication-agent-1",
        "gnome-shell","plasmashell","kwin_wayland","kwin_x11",
        "xdg-desktop-portal","xdg-desktop-portal-gtk","xdg-desktop-portal-kde",
        "pipewire","wireplumber","pulseaudio"
    };
 
    if (!comm.empty() && kCommDeny.count(comm)) return true;
 
    // Match per path exe (più stabile di comm)
    auto has = [&](const char* needle) {
        return (!exe.empty() && exe.find(needle) != std::string::npos) ||
               (!cmdline.empty() && cmdline.find(needle) != std::string::npos);
    };
 
    // Polkit / privilege prompts
    if (has("polkit") || has("pkexec")) return true;
 
    // Terminali / shell
    if (has("konsole") || has("gnome-terminal") || has("xfce4-terminal") ||
        has("kitty") || has("alacritty") || has("wezterm") ||
        has("/bin/bash") || has("/usr/bin/bash") || has("/bin/zsh") || has("/usr/bin/zsh") ||
        has("/bin/fish") || has("/usr/bin/fish"))
        return true;
 
    // Portali / media stack (spesso fanno probing o broker)
    if (has("xdg-desktop-portal") || has("pipewire") || has("wireplumber") || has("pulseaudio"))
        return true;
 
    // Desktop env “core”
    if (has("plasmashell") || has("gnome-shell") || has("kwin"))
        return true;
 
    return false;
}
 
static int read_ppid(const std::string& pid_str) {
    std::ifstream f("/proc/" + pid_str + "/status");
    if (!f.is_open()) return -1;
 
    std::string line;
    while (std::getline(f, line)) {
        if (line.rfind("PPid:", 0) == 0) {
            try {
                // dopo "PPid:" ci sono tab/spazi -> stoi li gestisce
                return std::stoi(line.substr(5));
            } catch (...) {
                return -1;
            }
        }
    }
    return -1;
}
 
 
static bool parent_is_noise(const std::string& pid_str) {
    std::string cur = pid_str;
    for (int i = 0; i < 3; ++i) {           // risali max 3 livelli
        int ppid = read_ppid(cur);
        if (ppid <= 1) break;
        std::string p = std::to_string(ppid);
        std::string comm = read_text_file("/proc/" + p + "/comm");
        std::string exe  = read_exe_path(p);
        std::string cmd  = read_cmdline("/proc/" + p + "/cmdline");
        if (is_noise_process(comm, exe, cmd)) return true;
        cur = p;
    }
    return false;
}
 
 
PrivacyPage::PrivacyPage()
    : 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();
      });
    }
}
 
PrivacyPage::~PrivacyPage() {
    // 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 ==="));
}
 
 
bool PrivacyPage::is_daemon_active() {
    int rc = (bg_process::run({"/usr/libexec/bastionguard/bastionguard-service", "--user", "is-active", "BastionGuard-privacyd.service"}).exit_code);
    return (WIFEXITED(rc) && WEXITSTATUS(rc) == 0);
}
 
void PrivacyPage::start_privacy_daemon() {
    write_log(_("Avvio automatico del servizio BastionGuard-privacyd..."));
    (bg_process::run({"/usr/libexec/bastionguard/bastionguard-service", "--user", "start", "BastionGuard-privacyd.service"}).exit_code);
}
 
 
void PrivacyPage::unblock_devices_local() {
    if (run_privhelper_pkexec("unblock"))
        write_log(_("📷 Webcam/Microfono sbloccati automaticamente"));
    else
        write_log(_("❌ Errore nello sblocco automatico"));
}
 
 
std::vector<std::string> PrivacyPage::detect_active_devices() {
    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;
}
 
 
 
 
void PrivacyPage::start_monitor_thread() {
    monitor_thread_ = std::thread(&PrivacyPage::monitor_loop, this);
    write_log(_("🕵️ Monitoraggio in tempo reale avviato"));
}
 
void PrivacyPage::monitor_loop() {
    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));
    }
}
 
 
void PrivacyPage::show_permission_popup(const std::string &process_name) {
    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(); });
        });
    }
}
 
void PrivacyPage::show_next_alert() {
    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();
}
 
 
void PrivacyPage::on_refresh_clicked() {
    lbl_status_.set_text(_("🔄 Aggiornamento elenco processi e log..."));
    write_log(_("Aggiornamento manuale avviato"));
    update_process_list();
}
 
 
 
void PrivacyPage::setup_auto_refresh_toggle() {
    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();
    }
}
 
 
 
void PrivacyPage::update_process_list() {
    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();
}
 
 
 
void PrivacyPage::write_log(const std::string& msg) {
    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();
}
 
 
 
void PrivacyPage::save_privacy_state(bool enabled) {
    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;
    }
}
 
bool PrivacyPage::load_privacy_state() {
    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;
}
 
void PrivacyPage::on_toggle_privacy() {
    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);
}
 
 
 
void PrivacyPage::run_privacy_script_async(bool unblock) {
    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();
}
 
void PrivacyPage::manual_unlock_devices() {
    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();
}