Classes
struct	USBDevice

Functions
void	write_log (const std::string &msg)
void	send_device_added (const USBDevice &dev)
void	send_device_removed (const std::string &devnode)
std::vector< USBDevice >	detect_usb_devices ()
void	monitor_loop ()
void	handle_signal (int)
static bool	load_lang_conf ()
int	main ()

Variables
static std::atomic< bool >	running {true}
static std::mutex	log_mutex
static GDBusConnection *	bus = nullptr

Function Documentation

◆ detect_usb_devices()

std::vector< USBDevice > detect_usb_devices ( )

Definition at line 143 of file BastionGuard-usbd-gdbus.cpp.

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

References detect_usb_devices(), USBDevice::devnode, USBDevice::name, and USBDevice::serial.

Referenced by detect_usb_devices(), and monitor_loop().

◆ handle_signal()

void handle_signal ( int )

Definition at line 268 of file BastionGuard-usbd-gdbus.cpp.

268{ running = false; }

running

static std::atomic< bool > running

Definition BastionGuard-privacyd.cpp:37

References handle_signal(), and running.

◆ load_lang_conf()

bool load_lang_conf ( )

static

Definition at line 270 of file BastionGuard-usbd-gdbus.cpp.

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

References load_lang_conf().

◆ main()

int main ( void )

Definition at line 308 of file BastionGuard-usbd-gdbus.cpp.

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

References _, bus, handle_signal(), load_lang_conf(), LOCALEDIR, main(), monitor_loop(), running, and write_log().

◆ monitor_loop()

void monitor_loop ( )

Definition at line 229 of file BastionGuard-usbd-gdbus.cpp.

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

References _, detect_usb_devices(), monitor_loop(), running, send_device_added(), send_device_removed(), and write_log().

◆ send_device_added()

void send_device_added ( const USBDevice & dev )

Definition at line 100 of file BastionGuard-usbd-gdbus.cpp.

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

References _, bus, USBDevice::devnode, USBDevice::name, send_device_added(), USBDevice::serial, and write_log().

Referenced by monitor_loop(), and send_device_added().

◆ send_device_removed()

void send_device_removed ( const std::string & devnode )

Definition at line 123 of file BastionGuard-usbd-gdbus.cpp.

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

References _, bus, send_device_removed(), and write_log().

Referenced by monitor_loop(), and send_device_removed().

◆ write_log()

void write_log ( const std::string & msg )

Definition at line 45 of file BastionGuard-usbd-gdbus.cpp.

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