BastionGuard-usbd-gdbus.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "Resource.hpp"
#include <libudev.h>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <thread>
#include <set>
#include <atomic>
#include <mutex>
#include <chrono>
#include <csignal>
#include <algorithm>
#include <cstdlib>
#include <unistd.h>
#include <gio/gio.h>
#include <glibmm/miscutils.h>
#include <glibmm/i18n.h>
 
namespace fs = std::filesystem;
 
static std::atomic<bool> running{true};
static std::mutex log_mutex;
static GDBusConnection *bus = nullptr;
 
void write_log(const std::string& msg)
{
    std::lock_guard<std::mutex> lock(log_mutex);
 
    try {
        std::string base_dir;
 
        if (geteuid() == 0)
            base_dir = "/var/log/BastionGuard";
        else
            base_dir = Glib::get_home_dir() + "/.local/share/BastionGuard/logs";
 
        if (!fs::exists(base_dir))
            fs::create_directories(base_dir);
 
        auto now = std::time(nullptr);
        std::tm tm{};
        localtime_r(&now, &tm);  // thread-safe
 
        char datebuf[16];
        std::strftime(datebuf, sizeof(datebuf), "%Y-%m-%d", &tm);
 
        std::string log_path = base_dir + "/usbd_" + datebuf + ".log";
        std::ofstream f(log_path, std::ios::app);
        if (!f.is_open()) return;
 
        char timebuf[16];
        std::strftime(timebuf, sizeof(timebuf), "%H:%M:%S", &tm);
 
        f << "[" << timebuf << "] " << msg << std::endl;
 
        const auto sys_now = std::chrono::system_clock::now();
        const auto limit = std::chrono::hours(24 * 7);
 
        for (const auto& entry : fs::directory_iterator(base_dir)) {
            if (!entry.is_regular_file()) continue;
 
            auto ftime = entry.last_write_time();
            auto sys_time = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                ftime - fs::file_time_type::clock::now() + sys_now
            );
 
            if (sys_now - sys_time > limit)
                fs::remove(entry.path());
        }
 
    } catch (...) {}
}
 
struct USBDevice {
    std::string name;
    std::string devnode;
    std::string serial;
};
 
void send_device_added(const USBDevice &dev)
{
    if (!bus) return;
 
    GError* error = nullptr;
    g_dbus_connection_emit_signal(
        bus,
        nullptr,
        "/org/BastionGuard/USBD",
        "org.BastionGuard.USBD",
        "DeviceAdded",
        g_variant_new("(sss)",
            dev.name.c_str(),
            dev.devnode.c_str(),
            dev.serial.c_str()),
        &error);
 
    if (error) {
        write_log(std::string(_("Errore invio segnale DeviceAdded: ")) + error->message);
        g_error_free(error);
    }
}
 
void send_device_removed(const std::string &devnode)
{
    if (!bus) return;
 
    GError* error = nullptr;
    g_dbus_connection_emit_signal(
        bus,
        nullptr,
        "/org/BastionGuard/USBD",
        "org.BastionGuard.USBD",
        "DeviceRemoved",
        g_variant_new("(s)", devnode.c_str()),
        &error);
 
    if (error) {
        write_log(std::string(_("Errore invio segnale DeviceRemoved: ")) + error->message);
        g_error_free(error);
    }
}
 
std::vector<USBDevice> detect_usb_devices()
{
    std::vector<USBDevice> result;
 
    struct udev *udev = udev_new();
    if (!udev) return result;
 
    struct udev_enumerate *enumerate = udev_enumerate_new(udev);
    if (!enumerate) { udev_unref(udev); return result; }
 
    udev_enumerate_add_match_subsystem(enumerate, "block");
    udev_enumerate_scan_devices(enumerate);
 
    struct udev_list_entry *entries = udev_enumerate_get_list_entry(enumerate);
    struct udev_list_entry *entry;
 
    udev_list_entry_foreach(entry, entries)
    {
        const char *path = udev_list_entry_get_name(entry);
        struct udev_device *dev = udev_device_new_from_syspath(udev, path);
        if (!dev) continue;
        const char *devtype = udev_device_get_devtype(dev);
        if (!devtype || std::string(devtype) != "disk") {
            udev_device_unref(dev);
            continue;
        }
 
 
        struct udev_device *usb =
            udev_device_get_parent_with_subsystem_devtype(
                dev, "usb", "usb_device");
 
        if (!usb) {
            udev_device_unref(dev);
            continue;
        }
 
        const char *size = udev_device_get_sysattr_value(dev, "size");
        if (!size || std::strtoull(size, nullptr, 10) == 0) {
            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;
        }
 
        USBDevice info;
 
        const char *devnode = udev_device_get_devnode(dev);
        if (!devnode) {
            udev_device_unref(dev);
            continue;
        }
 
        info.devnode = devnode;
 
        const char *vendor  = udev_device_get_sysattr_value(usb, "manufacturer");
        const char *product = udev_device_get_sysattr_value(usb, "product");
        const char *serial  = udev_device_get_sysattr_value(usb, "serial");
 
        if (vendor) info.name += vendor;
        if (product) {
            if (!info.name.empty()) info.name += " ";
            info.name += product;
        }
 
        if (info.name.empty())
            info.name = info.devnode;
 
        if (serial) info.serial = serial;
 
        result.push_back(info);
 
        udev_device_unref(dev);
    }
 
    udev_enumerate_unref(enumerate);
    udev_unref(udev);
 
    return result;
}
 
 
void monitor_loop()
{
    write_log(_("Monitor USB avviato."));
 
    std::set<std::string> known;
 
    while (running)
    {
        auto list = detect_usb_devices();
 
        for (auto &d : list) {
            if (!known.count(d.devnode)) {
                known.insert(d.devnode);
                write_log(_("Collegato USB: ") + d.name + " (" + d.devnode + ")");
                send_device_added(d);
            }
        }
 
        for (auto it = known.begin(); it != known.end(); ) {
            bool still = false;
            for (auto &d : list)
                if (d.devnode == *it) still = true;
 
            if (!still) {
                write_log(_("Rimosso USB: ") + *it);
                send_device_removed(*it);
                it = known.erase(it);
            } else {
                ++it;
            }
        }
 
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
 
    write_log(_("Monitor USB terminato."));
}
 
 
void handle_signal(int) { running = false; }
 
static bool load_lang_conf()
{
    const std::string lang_conf = Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    std::ifstream f(lang_conf);
    if (!f.is_open())
        return false;
 
    std::string line;
    bool any = false;
 
    while (std::getline(f, line)) {
        if (line.empty() || line[0] == '#')
            continue;
 
        auto pos = line.find('=');
        if (pos == std::string::npos)
            continue;
 
        std::string key = line.substr(0, pos);
        std::string val = line.substr(pos + 1);
 
        auto ltrim = [](std::string& s){
            s.erase(0, s.find_first_not_of(" \t\r\n"));
        };
        auto rtrim = [](std::string& s){
            s.erase(s.find_last_not_of(" \t\r\n") + 1);
        };
        ltrim(key); rtrim(key);
        ltrim(val); rtrim(val);
 
        if (!key.empty() && !val.empty()) {
            setenv(key.c_str(), val.c_str(), 1);
            any = true;
        }
    }
 
    return any;
}
int main()
{
    bool loaded = load_lang_conf();
 
 
    std::setlocale(LC_ALL, "");
    bindtextdomain("BastionGuard", LOCALEDIR);
    bind_textdomain_codeset("BastionGuard", "UTF-8");
    textdomain("BastionGuard");
 
    if (loaded) {
        std::cerr << _("[Lang] Config caricata da ~/.config/BastionGuard/lang.conf") << "\n";
    } else {
        std::cerr << _("[Lang] Nessuna config trovata, uso locale di sistema") << "\n";
    }
 
    std::signal(SIGINT, handle_signal);
    std::signal(SIGTERM, handle_signal);
 
    // D-Bus init through GLib/GIO, independent from the init system.
    GError* dbus_error = nullptr;
    bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, &dbus_error);
    if (!bus) {
        std::cerr << _("Errore apertura system bus: ")
                  << (dbus_error ? dbus_error->message : _("errore sconosciuto"))
                  << "\n";
        if (dbus_error) g_error_free(dbus_error);
        return 1;
    }
 
    GVariant* request_reply = g_dbus_connection_call_sync(
        bus,
        "org.freedesktop.DBus",
        "/org/freedesktop/DBus",
        "org.freedesktop.DBus",
        "RequestName",
        g_variant_new("(su)", "org.BastionGuard.USBD", 0u),
        G_VARIANT_TYPE("(u)"),
        G_DBUS_CALL_FLAGS_NONE,
        -1,
        nullptr,
        &dbus_error);
 
    if (!request_reply) {
        std::cerr << _("Errore registrazione nome DBus: ")
                  << (dbus_error ? dbus_error->message : _("errore sconosciuto"))
                  << "\n";
        if (dbus_error) g_error_free(dbus_error);
        g_object_unref(bus);
        bus = nullptr;
        return 1;
    }
 
    guint32 request_result = 0;
    g_variant_get(request_reply, "(u)", &request_result);
    g_variant_unref(request_reply);
    if (request_result != 1u && request_result != 4u) {
        std::cerr << _("Nome DBus org.BastionGuard.USBD già occupato.\n");
        g_object_unref(bus);
        bus = nullptr;
        return 1;
    }
 
    write_log(_("BastionGuard-usbd avviato."));
 
    std::thread th(monitor_loop);
 
    while (running)
        std::this_thread::sleep_for(std::chrono::seconds(1));
 
    if (th.joinable()) th.join();
 
    g_object_unref(bus);
    bus = nullptr;
    write_log(_("BastionGuard-usbd terminato."));
 
    return 0;
}