USBScanPage.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 "USBScanPage.hpp"
#include "../Resource.hpp"
#include "../Quarantine.hpp"
#include "ScanPromptWindow.hpp"
#include "LiveScanDialog.hpp"
#include <giomm.h>
#include <giomm/subprocess.h>
#include <giomm/datainputstream.h>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <thread>
#include <chrono>
#include <regex>
#include <glibmm/i18n.h>
#include <glibmm/miscutils.h>
#include <libudev.h>
 
namespace fs = std::filesystem;
 
 
 
std::string usb_conf_path() {
    return Glib::get_home_dir() + "/.config/BastionGuard/usb.conf";
}
 
void save_usb_autoscan(bool enabled) {
    std::string dir = Glib::get_home_dir() + "/.config/BastionGuard";
    std::filesystem::create_directories(dir);
 
    std::ofstream f(usb_conf_path());
    if (!f) return;
    f << "auto_scan=" << (enabled ? "1" : "0") << "\n";
}
 
bool load_usb_autoscan() {
    std::ifstream f(usb_conf_path());
    if (!f) return false;
 
    std::string line;
    while (std::getline(f, line)) {
        if (line.rfind("auto_scan=", 0) == 0)
            return line.substr(10) == "1";
    }
    return false;
}
 
bool has_virus(const std::string& text)
{
    std::regex re(R"(FOUND\s*$)");
    std::istringstream ss(text);
    std::string line;
 
    while (std::getline(ss, line)) {
        if (line.find("FOUND") != std::string::npos)
            return true;
    }
    return false;
}
 
 
std::string USBScanPage::human_readable_size(uint64_t bytes) {
    const char* units[] = {"B", "KB", "MB", "GB", "TB"};
    int idx = 0;
    double sz = bytes;
 
    while (sz > 1024 && idx < 4) {
        sz /= 1024;
        idx++;
    }
 
    char buf[32];
    std::snprintf(buf, sizeof(buf), "%.1f %s", sz, units[idx]);
    return buf;
}
 
static std::string trim(const std::string& s) {
    size_t a = s.find_first_not_of(" \t\n\r");
    size_t b = s.find_last_not_of(" \t\n\r");
    if (a == std::string::npos) return "";
    return s.substr(a, b - a + 1);
}
 
USBScanPage::~USBScanPage()
{
    if (alive_) alive_->store(false, std::memory_order_release);
    monitor_running_ = false;
    if (monitor_thread_.joinable()) monitor_thread_.join();
    if (log_idle_connection_.connected())  log_idle_connection_.disconnect();
    if (auto_refresh_conn_.connected())    auto_refresh_conn_.disconnect();
}
 
 
USBScanPage::USBScanPage()
: Gtk::Box(Gtk::Orientation::VERTICAL, 12),
  initial_scan_done_(false)
{
    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);
 
    auto spacer_left = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer_left->set_hexpand(true);
 
    auto title_label = Gtk::make_managed<Gtk::Label>(_("🖴 Periferiche USB"));
    title_label->set_margin(8);
    title_label->set_halign(Gtk::Align::CENTER);
    title_label->add_css_class("secure-header-title");
 
    auto spacer_right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer_right->set_hexpand(true);
 
    title_box->append(*spacer_left);
    title_box->append(*title_label);
    title_box->append(*spacer_right);
 
    append(*title_box);
 
    auto ctrl = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    ctrl->set_halign(Gtk::Align::CENTER);
 
 
    btn_refresh_.set_label(_("🔄 Aggiorna"));
    btn_refresh_.signal_clicked().connect([this]() {
        update_cards();
        update_log_view();
        write_log(_("Aggiornamento manuale lista USB."));
    });
    ctrl->append(btn_refresh_);
 
   chk_auto_refresh_.set_label(_("Auto scan ogni 3 min"));
    bool autoscan_enabled = load_usb_autoscan();
    chk_auto_refresh_.set_active(autoscan_enabled);
 
    if (autoscan_enabled) {
        auto_refresh_conn_ =
            Glib::signal_timeout().connect_seconds(
                [this]() { update_cards(); return chk_auto_refresh_.get_active(); },
                180
            );
    }
 
    chk_auto_refresh_.signal_toggled().connect([this]() {
 
        bool enabled = chk_auto_refresh_.get_active();
        save_usb_autoscan(enabled);
 
        if (enabled) {
            auto_refresh_conn_ =
                Glib::signal_timeout().connect_seconds(
                    [this]() { update_cards(); return chk_auto_refresh_.get_active(); },
                    180
                );
            write_log(_("Autoscan USB attivato (ogni 3 minuti)"));
        } else {
            auto_refresh_conn_.disconnect();
            write_log(_("Autoscan USB disattivato"));
        }
    });
 
    ctrl->append(chk_auto_refresh_);
 
 
    append(*ctrl);
 
    flowbox_devices_.set_valign(Gtk::Align::START);
    flowbox_devices_.set_max_children_per_line(3);
    flowbox_devices_.set_selection_mode(Gtk::SelectionMode::NONE);
    flowbox_devices_.set_row_spacing(8);
    flowbox_devices_.set_column_spacing(8);
 
    auto sc_cards = Gtk::make_managed<Gtk::ScrolledWindow>();
    sc_cards->set_child(flowbox_devices_);
    sc_cards->set_vexpand(true);
    append(*sc_cards);
 
    auto lbl_log = Gtk::make_managed<Gtk::Label>(_("📜 Log giornaliero USB"));
    lbl_log->set_halign(Gtk::Align::CENTER);
    append(*lbl_log);
 
    scroller_log_.set_vexpand(true);
    scroller_log_.set_hexpand(true);
 
    txt_log_.set_editable(false);
    txt_log_.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
 
    scroller_log_.set_child(txt_log_);
    append(scroller_log_);
 
    monitor_running_ = true;
 
    ignore_existing_devices_ = true;
    Glib::signal_timeout().connect_seconds_once([this]() {
        ignore_existing_devices_ = false;
    }, 3);
 
    start_monitor_thread();
 
    update_cards();
    update_log_view();
 
}
 
 
std::vector<USBDeviceInfo> USBScanPage::detect_usb_devices()
{
    std::vector<USBDeviceInfo> list;
 
    udev* udev = udev_new();
    if (!udev) return list;
 
    udev_enumerate* en = udev_enumerate_new(udev);
    udev_enumerate_add_match_subsystem(en, "block");
    udev_enumerate_add_match_property(en, "DEVTYPE", "disk");
    udev_enumerate_scan_devices(en);
 
    udev_list_entry* devices = udev_enumerate_get_list_entry(en);
    udev_list_entry* entry;
 
    udev_list_entry_foreach(entry, devices)
    {
        const char* path = udev_list_entry_get_name(entry);
        udev_device* dev = udev_device_new_from_syspath(udev, path);
        if (!dev) continue;
 
        const char* devnode = udev_device_get_devnode(dev);
        if (!devnode) { udev_device_unref(dev); continue; }
 
        std::string dn = devnode;
        if (dn.starts_with("/dev/sr")) { udev_device_unref(dev); continue; }
 
        udev_device* parent =
            udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device");
        if (!parent) { udev_device_unref(dev); continue; }
 
        const char* rem = udev_device_get_sysattr_value(dev, "removable");
        if (!rem || std::string(rem) != "1") {
            udev_device_unref(dev);
            continue;
        }
 
        const char* size = udev_device_get_sysattr_value(dev, "size");
        uint64_t sectors = size ? std::strtoull(size, nullptr, 10) : 0;
        if (sectors == 0) { udev_device_unref(dev); continue; }
 
        USBDeviceInfo info;
        info.devnode = devnode;
        info.size_bytes = sectors * 512ULL;
 
        const char* vendor  = udev_device_get_sysattr_value(parent, "manufacturer");
        const char* product = udev_device_get_sysattr_value(parent, "product");
 
        if (vendor) info.name += vendor;
        if (product) {
            if (!info.name.empty()) info.name += " ";
            info.name += product;
        }
        if (info.name.empty())
            info.name = info.devnode;
 
        const char* serial =
            udev_device_get_property_value(dev, "ID_SERIAL_SHORT");
 
        if (!serial)
            serial = udev_device_get_property_value(dev, "ID_SERIAL");
 
        info.uid = serial ? serial : udev_device_get_syspath(dev);
 
        list.push_back(info);
        udev_device_unref(dev);
    }
 
    udev_enumerate_unref(en);
    udev_unref(udev);
    return list;
}
 
bool USBScanPage::try_start_scan(const std::string& uid)
{
    std::lock_guard<std::mutex> lk(scan_mtx_);
 
    auto& st = device_state_[uid];
    if (st == ScanState::Mounting || st == ScanState::Scanning)
        return false;
 
    st = ScanState::Mounting;
    return true;
}
 
 
Gtk::Widget* USBScanPage::build_usb_card(const USBDeviceInfo& dev) {
 
    auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    box->add_css_class("usb-card");
 
    try {
        auto icon = Gtk::make_managed<Gtk::Image>(
            Gdk::Pixbuf::create_from_file(resource("icons/usb.png"), 24, 24, true)
        );
        icon->set_halign(Gtk::Align::START);
        box->append(*icon);
    } catch (...) {}
 
    auto lbl_title = Gtk::make_managed<Gtk::Label>(dev.name);
    lbl_title->add_css_class("usb-card-title");
    lbl_title->set_halign(Gtk::Align::START);
    lbl_title->set_wrap(true);
    box->append(*lbl_title);
 
    auto lbl_info = Gtk::make_managed<Gtk::Label>(
        dev.devnode + "\n" +
        (dev.serial.empty() ? "" : "SN: " + dev.serial + "\n") +
        human_readable_size(dev.size_bytes)
    );
    lbl_info->add_css_class("usb-card-info");
    lbl_info->set_halign(Gtk::Align::START);
    lbl_info->set_wrap(true);
    box->append(*lbl_info);
 
    auto btn_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 4);
    btn_box->add_css_class("usb-card-buttons");
 
    auto btn_action = Gtk::make_managed<Gtk::Button>(_("Monta e Scansiona"));
    btn_action->add_css_class("scan-btn");
    btn_box->append(*btn_action);
    box->append(*btn_box);
 
    btn_action->signal_clicked().connect([this, dev]() {
        write_log(_("Richiesta scansione completa per: ") + dev.devnode);
        run_clamdscan_async(dev.devnode);
    });
 
    return box;
}
 
 
void USBScanPage::update_cards() {
    auto list = detect_usb_devices();
 
    auto children = flowbox_devices_.get_children();
    for (auto* child : children)
        flowbox_devices_.remove(*child);
 
    for (auto& dev : list)
        flowbox_devices_.insert(*build_usb_card(dev), -1);
 
    flowbox_devices_.show();
}
 
std::string USBScanPage::find_mountpoint(const std::string& devnode) {
    std::ifstream f("/proc/mounts");
    std::string line;
 
    while (std::getline(f, line)) {
        if (line.starts_with(devnode + " ")) {
            auto pos = line.find(' ');
            if (pos != std::string::npos)
                return line.substr(pos + 1, line.find(' ', pos + 1) - (pos + 1));
        }
    }
    return "";
}
 
std::string USBScanPage::mount_partition(const std::string& devnode, bool& auto_mounted)
{
    auto_mounted = false;
    std::string partition = devnode;
 
    if (devnode.rfind("/dev/sd", 0) == 0 && devnode.size() == 8) {
        std::string p1 = devnode + "1";
        if (fs::exists(p1)) {
            write_log(_("Rilevato disco senza partizione montabile, uso: ") + p1);
            partition = p1;
        } else {
            write_log(_("Nessuna partizione valida trovata su ") + devnode);
            return "";
        }
    }
 
    std::string already = find_mountpoint(partition);
    if (!already.empty()) {
        write_log(_("Device già montato: ") + already);
        return already;
    }
 
    try {
        auto proc = Gio::Subprocess::create(
            { "udisksctl", "mount", "-b", partition, "--options", "umask=022" },
            Gio::Subprocess::Flags::STDOUT_PIPE |
            Gio::Subprocess::Flags::STDERR_MERGE
        );
 
        proc->wait();
 
        int exit_status = proc->get_exit_status();
        bool ok = (exit_status == 0);
 
        auto stream = proc->get_stdout_pipe();
        auto data = Gio::DataInputStream::create(stream);
 
        std::string output;
        data->read_line(output);
        write_log(_("Mount output: ") + output);
 
        if (!ok || output.find("Error") != std::string::npos) {
            write_log(_("Errore udisksctl: ") + output);
            return "";
        }
 
        if (output.find("not a mountable filesystem") != std::string::npos) {
            write_log(_("Non è un filesystem montabile: ") + partition);
            return "";
        }
 
        const std::string key = " at ";
        size_t pos = output.find(key);
        if (pos == std::string::npos) {
            write_log(_("Output udisksctl non interpretabile."));
            return "";
        }
 
        std::string mp = output.substr(pos + key.size());
 
        while (!mp.empty() &&
               (mp.back() == '\n' ||
                mp.back() == '.'  ||
                mp.back() == ' '))
        {
            mp.pop_back();
        }
 
        if (!fs::exists(mp) || !fs::is_directory(mp)) {
            write_log(_("Mountpoint non valido o inesistente: ") + mp);
            return "";
        }
 
        auto_mounted = true;
        return mp;
    }
    catch (const Glib::Error& ex) {
        write_log(_("Eccezione montaggio: ") + std::string(ex.what()));
        return "";
    }
}
 
void USBScanPage::run_clamdscan_async(const std::string& devnode)
{
    USBDeviceInfo dev;
    for (auto& d : detect_usb_devices())
        if (d.devnode == devnode)
            dev = d;
 
    if (dev.uid.empty()) {
        write_log(_("Device non trovato: ") + devnode);
        return;
    }
 
    if (!try_start_scan(dev.uid)) {
        write_log(_("Scansione già in corso per device: ") + dev.uid);
        return;
    }
 
    write_log(_("Avvio scansione USB: ") + dev.devnode);
 
    bool autom = false;
    std::string mp = mount_partition(dev.devnode, autom);
    if (mp.empty()) {
        {
            std::lock_guard<std::mutex> lk(scan_mtx_);
            device_state_.erase(dev.uid);
        }
        show_scan_result(_("Errore: impossibile montare il dispositivo USB."));
        return;
    }
 
    {
        std::lock_guard<std::mutex> lk(scan_mtx_);
        device_state_[dev.uid] = ScanState::Scanning;
    }
 
    Gtk::Window* parent = dynamic_cast<Gtk::Window*>(get_root());
    auto dialog = std::make_shared<LiveScanDialog>(parent, mp);
 
    std::vector<std::string> args = {
        "clamdscan",
        "--verbose",
        "--fdpass",
        "--remove=no"
    };
 
 
    args.push_back(mp);
 
    auto proc = Gio::Subprocess::create(
        args,
        Gio::Subprocess::Flags::STDOUT_PIPE |
        Gio::Subprocess::Flags::STDERR_MERGE
    );
 
    auto stream = proc->get_stdout_pipe();
    auto data   = Gio::DataInputStream::create(stream);
 
    auto pproc = std::make_shared<Glib::RefPtr<Gio::Subprocess>>(proc);
    auto pdata = std::make_shared<Glib::RefPtr<Gio::DataInputStream>>(data);
 
    auto loop = std::make_shared<std::function<void()>>();
 
    *loop = [this, dialog, loop, pproc, pdata, uid = dev.uid]()
    {
        if (dialog->cancelled()) {
            (*pproc)->send_signal(SIGKILL);
            return;
        }
 
        (*pdata)->read_line_async(
            [this, dialog, loop, pproc, pdata, uid]
            (const Glib::RefPtr<Gio::AsyncResult>& r)
            {
                std::string line;
                bool ok = false;
 
                try {
                    ok = (*pdata)->read_line_finish(r, line);
                } catch (...) {
                    ok = false;
                }
 
                if (ok) {
                    line += "\n";
                    Glib::signal_idle().connect_once([dialog, line]() {
                        dialog->append_output(line);
                    });
                    (*loop)();
                    return;
                }
 
                (*pproc)->wait_async(
                    [this, alive = alive_, dialog, uid](const Glib::RefPtr<Gio::AsyncResult>&)
                    {
                        {
                            std::lock_guard<std::mutex> lk(scan_mtx_);
                            if (!alive->load()) return;
                            device_state_.erase(uid);
                        }
 
                        dialog->mark_finished();
 
                        Glib::signal_idle().connect_once([this, alive, dialog]() {
                            BastionGuard::if_alive(alive, [this, dialog]() {
                                std::string out = dialog->get_full_output();
                                write_log("SCAN OUTPUT:\n" + out);
 
                                dialog->close();
 
                                show_scan_result(out);
 
 
                                if (out.find("FOUND") != std::string::npos) {
                                    show_infected_dialog(out);
                                }
                            });
                        });
                    }
                );
            },
            Glib::RefPtr<Gio::Cancellable>(),
            Glib::PRIORITY_DEFAULT
        );
    };
 
    (*loop)();
}
 
 
void USBScanPage::send_dbus_alert(const std::string& file, const std::string& family)
{
    try {
        auto conn = Gio::DBus::Connection::get_sync(Gio::DBus::BusType::SESSION);
 
        auto msg = Gio::DBus::Message::create_method_call(
            "org.BastionGuard.Ransomware.Alert",
            "/org/BastionGuard/ransomware/alert",
            "org.BastionGuard.Ransomware.Alert",
            "ShowAlert"
        );
 
        auto body = Glib::VariantContainerBase::create_tuple({
            Glib::Variant<Glib::ustring>::create(file),
            Glib::Variant<Glib::ustring>::create(family)
        });
 
        msg->set_body(body);
 
        conn->send_message(msg);
    }
    catch (const Glib::Error& ex) {
        write_log(_("Errore invio D-Bus alert: ") + std::string(ex.what()));
    }
}
 
 
 
std::string USBScanPage::build_scan_report(const std::string& raw)
{
    std::istringstream ss(raw);
    std::string line;
 
    int scanned_files = 0;
    int infected_files = 0;
    std::vector<std::string> infected_list;
 
    // Parsing
    while (std::getline(ss, line)) {
 
        if (line.find(": OK") != std::string::npos)
            scanned_files++;
 
        else if (line.find("FOUND") != std::string::npos) {
            infected_files++;
            scanned_files++;
            infected_list.push_back(line);
        }
    }
 
    std::ostringstream out;
 
    out << _("=========== RISULTATO SCANSIONE ===========\n");
    out << _("File analizzati: ") << scanned_files << "\n";
    out << _("File infetti:   ") << infected_files << "\n";
    out << "===========================================\n\n";
 
    if (infected_files > 0) {
        out << _("---- FILE INFETTI ----\n");
        for (auto& f : infected_list)
            out << f << "\n";
        out << "\n";
    } else {
        out << _("Nessuna minaccia rilevata.\n\n");
    }
 
    out << _("---- OUTPUT COMPLETO ----\n");
    out << raw << "\n";
 
    return out.str();
}
 
 
void USBScanPage::show_scan_result(const std::string& text)
{
    bool infected = (text.find("FOUND") != std::string::npos);
 
    auto dialog = new Gtk::Window();
    dialog->set_title("");
    dialog->set_default_size(620, 240);
    dialog->set_resizable(false);
    dialog->set_modal(true);
    dialog->add_css_class("app-dialog");
    dialog->add_css_class("main-window");
    dialog->add_css_class("app-window");
 
    try {
        auto css = Gtk::CssProvider::create();
        css->load_from_path(resource("BastionGuard.css"));
        auto display = Gdk::Display::get_default();
        Gtk::StyleContext::add_provider_for_display(
            display, css, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
        );
    } catch (const Glib::Error& e) {
        std::cerr << _("[ResultDialog] CSS error: ") << e.what() << "\n";
    }
 
 
    auto *header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->add_css_class("custom-headerbar");
 
    auto *close_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    close_box->set_margin_end(6);
 
    try {
        auto icon = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 28, 28, true);
        auto *btn = Gtk::make_managed<Gtk::Button>();
        btn->set_child(*Gtk::make_managed<Gtk::Image>(icon));
        btn->add_css_class("header-button");
        btn->signal_clicked().connect([dialog]() { dialog->hide(); delete dialog; });
        close_box->append(*btn);
    } catch (...) {}
 
    header->pack_end(*close_box);
 
    auto *header_wrapper = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    header_wrapper->append(*header);
    dialog->set_titlebar(*header_wrapper);
 
 
    auto *vbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 16);
    vbox->set_margin(25);
 
    auto titleLabel = Gtk::make_managed<Gtk::Label>(_("Scansione USB completata"));
    titleLabel->add_css_class("title");
    titleLabel->set_halign(Gtk::Align::CENTER);
 
    // ICONA: OK oppure threat
    auto *picture = Gtk::make_managed<Gtk::Picture>();
    picture->set_content_fit(Gtk::ContentFit::CONTAIN);
    picture->set_halign(Gtk::Align::CENTER);
    picture->set_margin_bottom(10);
    picture->set_size_request(68, 68);
    std::string iconPath = infected
        ? "/usr/share/BastionGuard/data/icons/false.png"
        : "/usr/share/BastionGuard/data/icons/true.png";
 
    try {
        if (std::filesystem::exists(iconPath))
        {
            auto pb = Gdk::Pixbuf::create_from_file(iconPath);
            auto scaled = pb->scale_simple(68, 68, Gdk::InterpType::BILINEAR);
            auto tex = Gdk::Texture::create_for_pixbuf(scaled);
            picture->set_paintable(tex);
        }
    } catch (...) {}
 
    std::string msg = infected
        ? _("Minacce rilevate durante la scansione.\nVerifica la quarantena.")
        : _("La scansione si è conclusa senza rilevare minacce.");
 
    auto messageLabel = Gtk::make_managed<Gtk::Label>(msg);
    messageLabel->set_wrap(true);
    messageLabel->set_justify(Gtk::Justification::CENTER);
    messageLabel->set_halign(Gtk::Align::CENTER);
 
    // Pulsante chiudi
    auto closeBtn = Gtk::make_managed<Gtk::Button>(_("Chiudi"));
    closeBtn->add_css_class("btn-success");
    closeBtn->set_halign(Gtk::Align::CENTER);
    closeBtn->signal_clicked().connect([dialog]() {
        dialog->close();
        delete dialog;
    });
 
    vbox->append(*titleLabel);
    vbox->append(*picture);
    vbox->append(*messageLabel);
    vbox->append(*closeBtn);
 
    dialog->set_child(*vbox);
    dialog->present();
}
 
 
 
 
void USBScanPage::start_monitor_thread() {
    monitor_thread_ = std::thread([this]() {
        std::vector<std::string> previous;
 
        while (monitor_running_) {
 
            auto list = detect_usb_devices();
            std::vector<std::string> current;
 
            for (auto& i : list)
                current.push_back(i.devnode);
 
            if (!initial_scan_done_) {
                previous = current;
                initial_scan_done_ = true;
            }
            else {
 
                for (auto& dev : current)
                if (std::find(previous.begin(), previous.end(), dev) == previous.end()) {
 
                    write_log(_("Collegata periferica: ") + dev);
 
                    auto alive = alive_;
                    Glib::signal_idle().connect([this, alive, dev]() {
                        if (!alive || !alive->load(std::memory_order_acquire))
                            return false;
 
                        auto *popup = new ScanPromptWindow(dev);
 
                        popup->set_modal(false);
                        popup->set_resizable(false);
 
                        popup->signal_scan_requested().connect([this, alive, dev]() {
                            if (!alive || !alive->load(std::memory_order_acquire)) return;
                            write_log(_("Avvio scansione richiesta dall’utente per: ") + dev);
                            run_clamdscan_async(dev);
                        });
 
                        popup->signal_cancel_requested().connect([this, alive, dev]() {
                            if (!alive || !alive->load(std::memory_order_acquire)) return;
                            write_log(_("Scansione USB annullata per: ") + dev);
                        });
 
                        popup->signal_hide().connect([popup]() {
                            delete popup;
                        });
 
                        popup->present();
                        return false;
                    });
 
                    Glib::signal_idle().connect([this, alive]() {
                        if (!alive || !alive->load(std::memory_order_acquire))
                            return false;
                        update_cards();
                        update_log_view();
                        return false;
                    });
                }
 
 
 
                for (auto& dev : previous)
                    if (std::find(current.begin(), current.end(), dev) == current.end()) {
 
                        write_log(_("Rimossa periferica: ") + dev);
 
                        auto alive = alive_;
                        Glib::signal_idle().connect([this, alive]() {
                            if (!alive || !alive->load(std::memory_order_acquire))
                                return false;
                            update_cards();
                            update_log_view();
                            return false;
                        });
                    }
            }
 
            previous = current;
            std::this_thread::sleep_for(std::chrono::seconds(2));
        }
    });
}
 
 
 
void USBScanPage::append_live_output(const std::string& line) {
    auto alive = alive_;
    Glib::signal_idle().connect([this, alive, line]() {
        if (!alive || !alive->load(std::memory_order_acquire)) return false;
 
        if (!live_scan_dialog_) return false;
        if (!live_scan_textview_) return false;
 
        auto buf = live_scan_textview_->get_buffer();
        if (!buf) return false;
 
        buf->insert(buf->end(), line);
 
        Gtk::TextBuffer::iterator iter = buf->end();
        live_scan_textview_->scroll_to(iter);
 
        return false;
    });
}
 
std::string USBScanPage::get_log_path() {
    std::string home = Glib::get_home_dir();
    return home + "/.bastionguard_usb.log";
}
 
void USBScanPage::write_log(const std::string& msg) {
    {
        std::lock_guard<std::mutex> lock(log_mtx_);
 
        std::ofstream f(get_log_path(), std::ios::app);
        if (!f) return;
 
        auto t = std::time(nullptr);
        std::tm tmbuf{};
        localtime_r(&t, &tmbuf);  // thread-safe
        char buf[64];
        std::strftime(buf, sizeof(buf), "[%Y-%m-%d %H:%M:%S] ", &tmbuf);
 
        f << buf << msg << "\n";
    }
 
    {
        std::lock_guard<std::mutex> lk(pending_log_mtx_);
        pending_log_lines_.push_back(msg);
    }
 
    if (!log_idle_connection_) {
        auto alive = alive_;
        log_idle_connection_ =
            Glib::signal_idle().connect([this, alive]() {
                if (!alive || !alive->load(std::memory_order_acquire))
                    return false;
 
                std::vector<std::string> lines;
                {
                    std::lock_guard<std::mutex> lk(pending_log_mtx_);
                    lines.swap(pending_log_lines_);
                }
 
                auto buf = txt_log_.get_buffer();
                Gtk::TextIter it = buf->end();
 
                for (auto& l : lines) {
                    auto t = std::time(nullptr);
                    std::tm tmbuf{};
                    localtime_r(&t, &tmbuf);  // thread-safe
                    char ts[64];
                    std::strftime(ts, sizeof(ts), "[%Y-%m-%d %H:%M:%S] ", &tmbuf);
 
                    buf->insert(it, std::string(ts) + l + "\n");
                    it = buf->end();
                }
 
                auto iter = buf->end();
                txt_log_.scroll_to(iter);
 
 
                log_idle_connection_.disconnect();
                return false;
            });
    }
}
 
 
void USBScanPage::update_log_view() {
    std::ifstream f(get_log_path());
    if (!f) {
        txt_log_.get_buffer()->set_text(_("(Nessun log disponibile)"));
        return;
    }
 
    std::string all((std::istreambuf_iterator<char>(f)),
                     std::istreambuf_iterator<char>());
 
    auto buf = txt_log_.get_buffer();
    buf->set_text(all);
 
    auto iter = buf->end();
    txt_log_.scroll_to(iter);
 
}
 
 
 
 
void USBScanPage::show_infected_dialog(const std::string& text)
{
    std::istringstream ss(text);
    std::string line;
 
    while (std::getline(ss, line))
    {
        if (line.find("FOUND") == std::string::npos)
            continue;
 
        std::string file, family;
 
        size_t col = line.find(':');
        if (col != std::string::npos)
            file = line.substr(0, col);
 
        size_t fpos = line.find("FOUND");
        if (fpos != std::string::npos) {
            std::string tmp = line.substr(col + 1, fpos - col - 1);
 
            auto trim = [](std::string& s) {
                s.erase(s.begin(), std::find_if(s.begin(), s.end(),
                    [](unsigned char c){ return !std::isspace(c); }));
                s.erase(std::find_if(s.rbegin(), s.rend(),
                    [](unsigned char c){ return !std::isspace(c); }).base(), s.end());
            };
 
            trim(tmp);
            family = tmp;
        }
 
        if (file.empty() || family.empty())
            continue;
 
        send_dbus_alert(file, family);
    }
}