BastionGuard-privacyd.cpp File Reference

Go to the source code of this file.

Functions
void	write_log (const std::string &msg)
std::vector< std::string >	detect_active_devices ()
void	monitor_loop ()
void	handle_signal (int)
int	main (int argc, char **argv)

Variables
static std::atomic< bool >	running {true}
static std::mutex	log_mutex

Function Documentation

detect_active_devices()

std::vector< std::string > detect_active_devices

(

)

Definition at line 92 of file BastionGuard-privacyd.cpp.

                                             {
    std::vector<std::string> result;
    const std::vector<std::string> prefixes = {"/dev/video", "/dev/snd/pcm"};
 
    // /proc è race-y: i PID possono sparire in qualsiasi momento tra open e iter.
    // Usiamo l'overload con std::error_code per non lanciare eccezioni
    // (altrimenti std::terminate nel thread monitor_loop -> SIGABRT).
    std::error_code ec;
    fs::directory_iterator proc_it("/proc", ec);
    if (ec) return result;
 
    for (; proc_it != fs::directory_iterator(); proc_it.increment(ec)) {
        if (ec) break; // PID scomparso mentre iteravamo
 
        const auto& pid_entry = *proc_it;
        std::error_code ec_dir;
        if (!pid_entry.is_directory(ec_dir) || ec_dir) continue;
 
        const std::string pid_str = pid_entry.path().filename();
        if (!std::all_of(pid_str.begin(), pid_str.end(), ::isdigit)) continue;
 
        const std::string fd_path = "/proc/" + pid_str + "/fd";
        std::error_code ec_exists;
        if (!fs::exists(fd_path, ec_exists) || ec_exists) continue;
 
        std::error_code ec_fd;
        fs::directory_iterator fd_it(
            fd_path,
            fs::directory_options::skip_permission_denied,
            ec_fd);
        if (ec_fd) continue;
 
        for (; fd_it != fs::directory_iterator(); fd_it.increment(ec_fd)) {
            if (ec_fd) break; // processo terminato mentre iteravamo gli fd
 
            const auto& fd_entry = *fd_it;
            std::error_code ec_link;
            auto link = fs::read_symlink(fd_entry.path(), ec_link);
            if (ec_link) continue;
            const std::string target = link.string();
 
            for (const auto& prefix : prefixes) {
                if (target.find(prefix) == 0) {
                    std::ifstream comm("/proc/" + pid_str + "/comm");
                    std::string name;
                    std::getline(comm, name);
                    if (name.empty()) name = "(sconosciuto)";
                    result.push_back(name + " (PID=" + pid_str + ")");
                    break;
                }
            }
        }
    }
 
    std::sort(result.begin(), result.end());
    result.erase(std::unique(result.begin(), result.end()), result.end());
    return result;
}

References detect_active_devices().

Referenced by detect_active_devices(), and monitor_loop().

handle_signal()

void handle_signal

(

int

)

Definition at line 195 of file BastionGuard-privacyd.cpp.

{ running = false; }

References handle_signal(), and running.

Referenced by handle_signal(), handle_signal(), main(), main(), and main().

main()

int main	(	int	argc,
		char **	argv )

Definition at line 197 of file BastionGuard-privacyd.cpp.

                                {
    setlocale(LC_ALL, "");
    bindtextdomain("BastionGuard", LOCALEDIR);
    bind_textdomain_codeset("BastionGuard", "UTF-8");
    textdomain("BastionGuard");
 
    std::signal(SIGINT, handle_signal);
    std::signal(SIGTERM, handle_signal);
 
    write_log(_("=== Avvio BastionGuard-privacyd (headless) ==="));
 
    std::thread monitor(monitor_loop);
    while (running)
        std::this_thread::sleep_for(std::chrono::seconds(1));
 
    if (monitor.joinable()) monitor.join();
 
    write_log(_("=== Arresto BastionGuard-privacyd ==="));
    return 0;
}

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

monitor_loop()

void monitor_loop

(

)

Definition at line 152 of file BastionGuard-privacyd.cpp.

                    {
    std::set<std::string> known;
    write_log(_("[privacyd] Avviato monitoraggio webcam/microfono."));
 
    while (running) {
        try {
            auto active = detect_active_devices();
 
            for (const auto& proc : active) {
                if (!known.count(proc)) {
                    known.insert(proc);
                    write_log(_("Nuovo accesso: ") + proc);
                }
            }
 
            for (auto it = known.begin(); it != known.end();) {
                if (std::find(active.begin(), active.end(), *it) == active.end()) {
                    write_log(
                        Glib::ustring::compose(
                            _("Accesso terminato: %1"),
                            *it
                        )
                    );
                    it = known.erase(it);
                } else ++it;
            }
        } catch (const std::exception& e) {
            // Difesa in profondità: qualsiasi eccezione non catturata qui
            // ucciderebbe il daemon.
            try { write_log(std::string("[privacyd] Errore monitor_loop: ") + e.what()); }
            catch (...) {}
        } catch (...) {
            try { write_log("[privacyd] Errore sconosciuto in monitor_loop"); }
            catch (...) {}
        }
 
        std::this_thread::sleep_for(std::chrono::seconds(3));
    }
 
    write_log(_("[privacyd] Monitoraggio terminato."));
}

References _, detect_active_devices(), monitor_loop(), running, and write_log().

Referenced by main(), main(), and monitor_loop().

write_log()

void write_log

(

const std::string &

msg

)

Definition at line 40 of file BastionGuard-privacyd.cpp.

                                     {
    std::thread([msg]() {
        try {
            std::lock_guard<std::mutex> lock(log_mutex);
            std::string base_dir = Glib::get_home_dir() + "/.local/share/BastionGuard/logs";
            if (!fs::exists(base_dir))
                fs::create_directories(base_dir);
 
 
            auto t = std::time(nullptr);
            std::tm tm{};
            localtime_r(&t, &tm);  // thread-safe
            char datebuf[16];
            std::strftime(datebuf, sizeof(datebuf), "%Y-%m-%d", &tm);
            std::string log_path = base_dir + "/privacyd_" + std::string(datebuf) + ".log";
 
 
            std::ofstream f(log_path, std::ios::app);
            if (!f.is_open()) return;
 
            char timebuf[32];
            std::strftime(timebuf, sizeof(timebuf), "%H:%M:%S", &tm);
            f << "[" << timebuf << "] " << msg << std::endl;
 
 
            const auto now = std::chrono::system_clock::now();
            const auto seven_days = std::chrono::hours(24 * 7);
 
            for (const auto& entry : fs::directory_iterator(base_dir)) {
                if (entry.is_regular_file()) {
                    auto ftime = fs::last_write_time(entry);
                    auto sctp = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                        ftime - fs::file_time_type::clock::now()
                        + std::chrono::system_clock::now());
                    auto age = now - sctp;
 
                    if (age > seven_days) {
                        try {
                            fs::remove(entry.path());
                        } catch (...) {
 
                        }
                    }
                }
            }
        } catch (...) {
            std::cerr << _("[privacyd] Errore scrittura log.") << std::endl;
        }
    }).detach();
}

References _, log_mutex, and write_log().

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

Variable Documentation

log_mutex

std::mutex log_mutex

static

Definition at line 38 of file BastionGuard-privacyd.cpp.

Referenced by write_log().

running

std::atomic<bool> running {true}

static

Definition at line 37 of file BastionGuard-privacyd.cpp.

Referenced by handle_signal(), handle_signal(), main(), main(), main(), monitor_loop(), running(), signal_handler(), and signal_handler().