BastionGuard-usbd.cpp File Reference

Go to the source code of this file.

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 sd_bus *	bus = nullptr

Function Documentation

detect_usb_devices()

std::vector< USBDevice > detect_usb_devices

(

)

Definition at line 135 of file BastionGuard-usbd.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.

handle_signal()

void handle_signal

(

int

)

Definition at line 260 of file BastionGuard-usbd.cpp.

{ running = false; }

References handle_signal(), and running.

load_lang_conf()

bool load_lang_conf ( )

static

Definition at line 262 of file BastionGuard-usbd.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 300 of file BastionGuard-usbd.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);
 
    // DBus init
    if (sd_bus_open_system(&bus) < 0) {
        std::cerr << _("Errore apertura system bus.\n");
        return 1;
    }
 
    if (sd_bus_request_name(bus, "org.BastionGuard.USBD", 0) < 0) {
        std::cerr << _("Errore registrazione nome DBus.\n");
        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();
 
    sd_bus_unref(bus);
    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 221 of file BastionGuard-usbd.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.cpp.

{
    if (!bus) return;
 
    sd_bus_message *m = nullptr;
    sd_bus_message_new_signal(bus, &m,
        "/org/BastionGuard/USBD",
        "org.BastionGuard.USBD",
        "DeviceAdded");
 
    sd_bus_message_append(m, "sss",
        dev.name.c_str(),
        dev.devnode.c_str(),
        dev.serial.c_str());
 
    sd_bus_send(bus, m, nullptr);
    sd_bus_message_unref(m);
}

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

send_device_removed()

void send_device_removed

(

const std::string &

devnode

)

Definition at line 119 of file BastionGuard-usbd.cpp.

{
    if (!bus) return;
 
    sd_bus_message *m = nullptr;
    sd_bus_message_new_signal(bus, &m,
        "/org/BastionGuard/USBD",
        "org.BastionGuard.USBD",
        "DeviceRemoved");
 
    sd_bus_message_append(m, "s", devnode.c_str());
 
    sd_bus_send(bus, m, nullptr);
    sd_bus_message_unref(m);
}

References bus, and send_device_removed().

write_log()

void write_log

(

const std::string &

msg

)

Definition at line 45 of file BastionGuard-usbd.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 (...) {}
}

References log_mutex, and write_log().

Variable Documentation

bus

sd_bus* bus = nullptr

static

Definition at line 43 of file BastionGuard-usbd.cpp.

Referenced by main(), send_device_added(), and send_device_removed().

log_mutex

std::mutex log_mutex

static

Definition at line 42 of file BastionGuard-usbd.cpp.

running

std::atomic<bool> running {true}

static

Definition at line 41 of file BastionGuard-usbd.cpp.