USBScanPage Class Reference

#include <USBScanPage.hpp>

Inheritance diagram for USBScanPage:

Public Member Functions
	USBScanPage ()
virtual	~USBScanPage ()

Private Member Functions
std::vector< USBDeviceInfo >	detect_usb_devices ()
void	update_cards ()
Gtk::Widget *	build_usb_card (const USBDeviceInfo &dev)
std::string	find_mountpoint (const std::string &devnode)
std::string	mount_partition (const std::string &devnode, bool &auto_mounted)
void	run_clamdscan_async (const std::string &devnode)
bool	try_start_scan (const std::string &uid)
void	show_scan_result (const std::string &text)
void	show_infected_dialog (const std::string &text)
std::string	build_scan_report (const std::string &raw)
void	write_log (const std::string &msg)
void	update_log_view ()
std::string	get_log_path ()
void	start_monitor_thread ()
void	append_live_output (const std::string &line)
void	send_dbus_alert (const std::string &file, const std::string &family)

Static Private Member Functions
static std::string	human_readable_size (uint64_t bytes)

Private Attributes
Gtk::FlowBox	flowbox_devices_
Gtk::Button	btn_refresh_
Gtk::CheckButton	chk_auto_refresh_
Gtk::Label	lbl_title_
Gtk::Label	lbl_status_
Gtk::TextView	txt_log_
Gtk::ScrolledWindow	scroller_log_
std::thread	monitor_thread_
std::atomic< bool >	monitor_running_ {false}
bool	initial_scan_done_ {false}
bool	ignore_existing_devices_ {true}
std::mutex	scan_mtx_
std::unordered_map< std::string, ScanState >	device_state_
std::mutex	log_mtx_
std::mutex	pending_log_mtx_
std::vector< std::string >	pending_log_lines_
sigc::connection	log_idle_connection_
sigc::connection	auto_refresh_conn_
class LiveScanDialog *	live_scan_dialog_ = nullptr
Gtk::TextView *	live_scan_textview_ = nullptr
BastionGuard::AliveFlag	alive_ = BastionGuard::make_alive_flag()

Detailed Description

Definition at line 51 of file USBScanPage.hpp.

Constructor & Destructor Documentation

USBScanPage()

USBScanPage::USBScanPage

(

)

Definition at line 114 of file USBScanPage.cpp.

: 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();
 
}

References _, auto_refresh_conn_, btn_refresh_, chk_auto_refresh_, flowbox_devices_, ignore_existing_devices_, initial_scan_done_, load_usb_autoscan(), monitor_running_, save_usb_autoscan(), scroller_log_, start_monitor_thread(), txt_log_, update_cards(), update_log_view(), and write_log().

~USBScanPage()

USBScanPage::~USBScanPage ( )

virtual

Definition at line 104 of file USBScanPage.cpp.

{
    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();
}

References alive_, auto_refresh_conn_, log_idle_connection_, monitor_running_, and monitor_thread_.

Member Function Documentation

append_live_output()

void USBScanPage::append_live_output ( const std::string & line )

private

Definition at line 865 of file USBScanPage.cpp.

                                                          {
    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;
    });
}

References alive_, live_scan_dialog_, and live_scan_textview_.

build_scan_report()

std::string USBScanPage::build_scan_report ( const std::string & raw )

private

Definition at line 627 of file USBScanPage.cpp.

{
    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();
}

References _.

build_usb_card()

Gtk::Widget * USBScanPage::build_usb_card ( const USBDeviceInfo & dev )

private

Definition at line 315 of file USBScanPage.cpp.

                                                               {
 
    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;
}

References _, USBDeviceInfo::devnode, human_readable_size(), USBDeviceInfo::name, resource(), run_clamdscan_async(), USBDeviceInfo::serial, USBDeviceInfo::size_bytes, and write_log().

Referenced by update_cards().

detect_usb_devices()

std::vector< USBDeviceInfo > USBScanPage::detect_usb_devices ( )

private

Definition at line 229 of file USBScanPage.cpp.

{
    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;
}

References USBDeviceInfo::devnode, USBDeviceInfo::name, USBDeviceInfo::size_bytes, and USBDeviceInfo::uid.

Referenced by run_clamdscan_async(), start_monitor_thread(), and update_cards().

find_mountpoint()

std::string USBScanPage::find_mountpoint ( const std::string & devnode )

private

Definition at line 374 of file USBScanPage.cpp.

                                                               {
    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 "";
}

Referenced by mount_partition().

get_log_path()

std::string USBScanPage::get_log_path ( )

private

Definition at line 885 of file USBScanPage.cpp.

                                    {
    std::string home = Glib::get_home_dir();
    return home + "/.bastionguard_usb.log";
}

Referenced by update_log_view(), and write_log().

human_readable_size()

std::string USBScanPage::human_readable_size ( uint64_t bytes )

staticprivate

Definition at line 82 of file USBScanPage.cpp.

                                                         {
    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;
}

Referenced by build_usb_card().

mount_partition()

std::string USBScanPage::mount_partition ( const std::string & devnode, bool & auto_mounted )

private

Definition at line 388 of file USBScanPage.cpp.

{
    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 "";
    }
}

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

Referenced by run_clamdscan_async().

run_clamdscan_async()

void USBScanPage::run_clamdscan_async ( const std::string & devnode )

private

Definition at line 470 of file USBScanPage.cpp.

{
    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)();
}

References _, alive_, detect_usb_devices(), device_state_, USBDeviceInfo::devnode, BastionGuard::if_alive(), mount_partition(), scan_mtx_, Scanning, show_infected_dialog(), show_scan_result(), try_start_scan(), USBDeviceInfo::uid, and write_log().

Referenced by build_usb_card(), and start_monitor_thread().

send_dbus_alert()

void USBScanPage::send_dbus_alert ( const std::string & file, const std::string & family )

private

Definition at line 599 of file USBScanPage.cpp.

{
    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()));
    }
}

References _, and write_log().

Referenced by show_infected_dialog().

show_infected_dialog()

void USBScanPage::show_infected_dialog ( const std::string & text )

private

Definition at line 970 of file USBScanPage.cpp.

{
    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);
    }
}

References send_dbus_alert(), and trim().

Referenced by run_clamdscan_async().

show_scan_result()

void USBScanPage::show_scan_result ( const std::string & text )

private

Definition at line 672 of file USBScanPage.cpp.

{
    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();
}

References _, and resource().

Referenced by run_clamdscan_async().

start_monitor_thread()

void USBScanPage::start_monitor_thread ( )

private

Definition at line 778 of file USBScanPage.cpp.

                                       {
    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));
        }
    });
}

References _, alive_, detect_usb_devices(), initial_scan_done_, monitor_running_, monitor_thread_, run_clamdscan_async(), ScanPromptWindow::ScanPromptWindow(), update_cards(), update_log_view(), and write_log().

Referenced by USBScanPage().

try_start_scan()

bool USBScanPage::try_start_scan ( const std::string & uid )

private

Definition at line 302 of file USBScanPage.cpp.

{
    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;
}

References device_state_, Mounting, scan_mtx_, and Scanning.

Referenced by run_clamdscan_async().

update_cards()

void USBScanPage::update_cards ( )

private

Definition at line 361 of file USBScanPage.cpp.

                               {
    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();
}

References build_usb_card(), detect_usb_devices(), and flowbox_devices_.

Referenced by start_monitor_thread(), and USBScanPage().

update_log_view()

void USBScanPage::update_log_view ( )

private

Definition at line 949 of file USBScanPage.cpp.

                                  {
    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);
 
}

References _, get_log_path(), and txt_log_.

Referenced by start_monitor_thread(), and USBScanPage().

write_log()

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

private

Definition at line 890 of file USBScanPage.cpp.

                                                {
    {
        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;
            });
    }
}

References alive_, get_log_path(), log_idle_connection_, log_mtx_, pending_log_lines_, pending_log_mtx_, and txt_log_.

Referenced by build_usb_card(), mount_partition(), run_clamdscan_async(), send_dbus_alert(), start_monitor_thread(), and USBScanPage().

Member Data Documentation

alive_

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

private

Definition at line 107 of file USBScanPage.hpp.

Referenced by append_live_output(), run_clamdscan_async(), start_monitor_thread(), write_log(), and ~USBScanPage().

auto_refresh_conn_

sigc::connection USBScanPage::auto_refresh_conn_

private

Definition at line 100 of file USBScanPage.hpp.

Referenced by USBScanPage(), and ~USBScanPage().

btn_refresh_

Gtk::Button USBScanPage::btn_refresh_

private

Definition at line 81 of file USBScanPage.hpp.

Referenced by USBScanPage().

chk_auto_refresh_

Gtk::CheckButton USBScanPage::chk_auto_refresh_

private

Definition at line 82 of file USBScanPage.hpp.

Referenced by USBScanPage().

device_state_

std::unordered_map<std::string, ScanState> USBScanPage::device_state_

private

Definition at line 94 of file USBScanPage.hpp.

Referenced by run_clamdscan_async(), and try_start_scan().

flowbox_devices_

Gtk::FlowBox USBScanPage::flowbox_devices_

private

Definition at line 80 of file USBScanPage.hpp.

Referenced by update_cards(), and USBScanPage().

ignore_existing_devices_

bool USBScanPage::ignore_existing_devices_ {true}

private

Definition at line 91 of file USBScanPage.hpp.

Referenced by USBScanPage().

initial_scan_done_

bool USBScanPage::initial_scan_done_ {false}

private

Definition at line 90 of file USBScanPage.hpp.

Referenced by start_monitor_thread(), and USBScanPage().

lbl_status_

Gtk::Label USBScanPage::lbl_status_

private

Definition at line 84 of file USBScanPage.hpp.

lbl_title_

Gtk::Label USBScanPage::lbl_title_

private

Definition at line 83 of file USBScanPage.hpp.

live_scan_dialog_

class LiveScanDialog* USBScanPage::live_scan_dialog_ = nullptr

private

Definition at line 102 of file USBScanPage.hpp.

Referenced by append_live_output().

live_scan_textview_

Gtk::TextView* USBScanPage::live_scan_textview_ = nullptr

private

Definition at line 103 of file USBScanPage.hpp.

Referenced by append_live_output().

log_idle_connection_

sigc::connection USBScanPage::log_idle_connection_

private

Definition at line 99 of file USBScanPage.hpp.

Referenced by write_log(), and ~USBScanPage().

log_mtx_

std::mutex USBScanPage::log_mtx_

private

Definition at line 96 of file USBScanPage.hpp.

Referenced by write_log().

monitor_running_

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

private

Definition at line 89 of file USBScanPage.hpp.

Referenced by start_monitor_thread(), USBScanPage(), and ~USBScanPage().

monitor_thread_

std::thread USBScanPage::monitor_thread_

private

Definition at line 88 of file USBScanPage.hpp.

Referenced by start_monitor_thread(), and ~USBScanPage().

pending_log_lines_

std::vector<std::string> USBScanPage::pending_log_lines_

private

Definition at line 98 of file USBScanPage.hpp.

Referenced by write_log().

pending_log_mtx_

std::mutex USBScanPage::pending_log_mtx_

private

Definition at line 97 of file USBScanPage.hpp.

Referenced by write_log().

scan_mtx_

std::mutex USBScanPage::scan_mtx_

private

Definition at line 93 of file USBScanPage.hpp.

Referenced by run_clamdscan_async(), and try_start_scan().

scroller_log_

Gtk::ScrolledWindow USBScanPage::scroller_log_

private

Definition at line 86 of file USBScanPage.hpp.

Referenced by USBScanPage().

txt_log_

Gtk::TextView USBScanPage::txt_log_

private

Definition at line 85 of file USBScanPage.hpp.

Referenced by update_log_view(), USBScanPage(), and write_log().

---

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

• BastionGuard/src/usb/USBScanPage.hpp
• BastionGuard/src/usb/USBScanPage.cpp