RootGuardClient.hpp

Go to the documentation of this file.

/*
 * BastionGuard™ RootGuard GTK integration
 * Copyright (C) 2025–2026 Calogero Scarnà
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
#pragma once
 
#include "RootGuardEvent.hpp"
 
#include <glibmm/dispatcher.h>
#include <sigc++/sigc++.h>
 
#include <condition_variable>
#include <cstddef>
#include <deque>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <vector>
 
namespace BastionGuard::RootGuard {
 
struct ServiceStatus {
    bool active{};
    bool immediateProtection{};
    bool autoBlockServices{};
    bool blockUserHome{};
    std::string init_system{"unknown"};
    std::string state{"unknown"};
    std::string mode{"unknown"};
    std::string metadata_action{"unknown"};
    std::string global_metadata_action{"unknown"};
    std::string pid;
};
 
struct ApplicationRules {
    std::vector<std::string> trustedApplications;
    std::vector<std::string> trustedExecutables;
    std::vector<std::string> deniedExecutables;
};
 
struct Snapshot {
    ServiceStatus service;
    std::vector<Event> events;
    ApplicationRules application_rules;
    std::string operation_message;
    bool operation_success{true};
};
 
class Client {
public:
    Client();
    ~Client();
 
    Client(const Client&) = delete;
    Client& operator=(const Client&) = delete;
 
    sigc::signal<void(const Snapshot&)>& signal_updated() noexcept;
 
    void refresh();
    void start_service();
    void stop_service();
    void reload_policy();
    void restart_service();
    void set_immediate_protection(bool enabled);
    void restore_event(const Event& event);
    void remove_event(const Event& event);
    void save_application_rules(ApplicationRules rules);
 
private:
    enum class Action {
        Refresh,
        Start,
        Stop,
        Reload,
        Restart,
        SetProtection,
        Restore,
        Remove,
        SaveApplicationRules,
        Quit,
    };
 
    struct Request {
        Action action{Action::Refresh};
        bool enabled{};
        std::optional<Event> event;
        ApplicationRules application_rules;
    };
 
    void enqueue(Request request);
    void worker_loop();
    void on_dispatch();
    Snapshot collect_snapshot(const std::string& operation_message,
                              bool operation_success) const;
    bool run_request(const Request& request, std::string& message) const;
 
    Glib::Dispatcher dispatcher_;
    sigc::signal<void(const Snapshot&)> signal_updated_;
 
    mutable std::mutex mutex_;
    std::condition_variable condition_;
    std::deque<Request> requests_;
    Snapshot pending_snapshot_;
    bool snapshot_ready_{};
    bool stopping_{};
    std::thread worker_;
};
 
} // namespace BastionGuard::RootGuard