Public Member Functions
	Impl (UIServer *owner)
	~Impl ()
bool	start (const std::string &socketPath)
void	stop ()
void	accept_loop ()
bool	read_exact (int fd, std::uint8_t *buf, std::size_t n)
void	client_session (int fd)
bool	send_frame (const std::string &payload)
void	flush_pending_notifs ()
void	send_reply (ReplyAction action)
void	queue_notification (int type, const std::string &data)
void	dispatch_connected ()
void	dispatch_disconnected ()
void	dispatch_new_connection (const ConnectionInfo &info)
void	dispatch_alert (const AlertInfo &a)

Public Attributes
UIServer *	owner_
int	listen_fd_ {-1}
std::string	socket_file_
std::atomic_int	client_fd_ {-1}
std::thread	accept_thread_
std::atomic_bool	running_ {false}
std::thread	reader_thread_
std::mutex	write_mutex_
std::atomic_uint64_t	next_id_ {1}
std::mutex	notif_mutex_
std::deque< json >	pending_notifs_
std::mutex	reply_mutex_
std::condition_variable	reply_cv_
bool	reply_ready_ {false}
ReplyAction	reply_action_ {ReplyAction::DENY_ONCE}
std::uint64_t	current_ask_id_ {0}

Detailed Description

Definition at line 63 of file UIServer.cpp.

Constructor & Destructor Documentation

◆ Impl()

UIServer::Impl::Impl ( UIServer * owner )

inline

Definition at line 65 of file UIServer.cpp.

65: owner_(owner) {}

UIServer::Impl::owner_

UIServer * owner_

Definition UIServer.cpp:68

References owner_, and UIServer::UIServer().

◆ ~Impl()

UIServer::Impl::~Impl ( )

inline

Definition at line 66 of file UIServer.cpp.

66{ stop(); }

UIServer::Impl::stop

void stop()

Definition UIServer.cpp:144

References stop().

Member Function Documentation

◆ accept_loop()

void UIServer::Impl::accept_loop ( )

inline

Definition at line 168 of file UIServer.cpp.

                       {
        while (running_) {
            int fd = ::accept4(listen_fd_, nullptr, nullptr, SOCK_CLOEXEC);
            if (fd < 0) {
                if (errno == EINTR) continue;
                if (!running_) break;
                std::cerr << "[UIServer] accept fallita: " << std::strerror(errno) << "\n";
                std::this_thread::sleep_for(std::chrono::milliseconds(200));
                continue;
            }
 
            // Chiudi client precedente se c'e' (un solo daemon alla volta)
            int old = client_fd_.exchange(fd);
            if (old >= 0) { ::shutdown(old, SHUT_RDWR); ::close(old); }
            if (reader_thread_.joinable()) reader_thread_.join();
 
            reader_thread_ = std::thread([this, fd]() { client_session(fd); });
        }
    }

References client_fd_, client_session(), listen_fd_, reader_thread_, and running_.

Referenced by start().

◆ client_session()

void UIServer::Impl::client_session ( int fd )

inline

Definition at line 201 of file UIServer.cpp.

                                {
        // Emetti "connected" al primo frame ricevuto (hello) — non subito,
        // cosi' non segnaliamo client che si connettono e rompono il socket
        // senza inviare niente. La pratica: appena ci arriva un hello
        // dispatchiamo connected.
        bool announced = false;
 
        while (running_ && fd == client_fd_.load()) {
            std::uint8_t lenbuf[4];
            if (!read_exact(fd, lenbuf, 4)) break;
            const std::int64_t len = bsc::proto::frame_peek_length(lenbuf, 4);
            if (len < 0 || static_cast<std::size_t>(len) > bsc::proto::kMaxFrameSize) break;
            std::vector<std::uint8_t> payload(static_cast<std::size_t>(len));
            if (!read_exact(fd, payload.data(), payload.size())) break;
 
            try {
                json j = json::parse(payload.begin(), payload.end());
                const std::string type = j.value("type", std::string{});
 
                if (type == bsc::proto::msg::kHello) {
                    if (!announced) {
                        announced = true;
                        dispatch_connected();
                        // Spedisci eventuali notifiche accodate prima della
                        // connessione.
                        flush_pending_notifs();
                    }
                    continue;
                }
 
                if (!announced) {
                    // Pazienza: il daemon non ci ha mandato hello, ma
                    // accettiamo messaggi comunque.
                    announced = true;
                    dispatch_connected();
                }
 
                if (type == bsc::proto::msg::kPing) {
                    // Rispondi con pong; il payload stats lo ignoriamo per ora
                    json pong = { {"type", bsc::proto::msg::kPong}, {"id", j.value("id", std::uint64_t{0})} };
                    send_frame(pong.dump());
                    continue;
                }
 
                if (type == bsc::proto::msg::kAskRule) {
                    const auto id = j.value("id", std::uint64_t{0});
                    ConnectionInfo info;
                    if (j.contains("connection")) info = connection_info_from_json(j["connection"]);
 
                    // Registra l'id come "corrente"; sendReply verra' chiamato
                    // dalla UI (thread GTK) e spedira' il reply.
                    {
                        std::lock_guard<std::mutex> lk(reply_mutex_);
                        reply_ready_  = false;
                        current_ask_id_ = id;
                    }
 
                    dispatch_new_connection(info);
 
                    // Aspetta sendReply (timeout 20s)
                    std::unique_lock<std::mutex> lk(reply_mutex_);
                    const bool got = reply_cv_.wait_for(lk, std::chrono::seconds(20),
                                                        [this]() { return reply_ready_; });
                    const ReplyAction action = got ? reply_action_ : ReplyAction::DENY_ONCE;
                    reply_ready_ = false;
                    lk.unlock();
 
                    json reply = {
                        {"type", bsc::proto::msg::kAskRuleReply},
                        {"id",   id},
                    };
                    switch (action) {
                        case ReplyAction::ALLOW_ONCE:   reply["action"] = "allow"; reply["duration"] = "once";   break;
                        case ReplyAction::ALLOW_ALWAYS: reply["action"] = "allow"; reply["duration"] = "always"; break;
                        case ReplyAction::DENY_ONCE:    reply["action"] = "deny";  reply["duration"] = "once";   break;
                        case ReplyAction::DENY_ALWAYS:  reply["action"] = "deny";  reply["duration"] = "always"; break;
                    }
                    send_frame(reply.dump());
                    continue;
                }
 
                if (type == bsc::proto::msg::kAlert) {
                    AlertInfo ai;
                    ai.id       = j.value("id", std::uint64_t{0});
                    const std::string level = j.value("level", std::string{"info"});
                    ai.type     = level == "error"   ? 0
                                : level == "warning" ? 1
                                : 2;
                    const std::string what = j.value("what", std::string{"generic"});
                    ai.what     = what == "firewall"   ? 2
                                : what == "connection" ? 3
                                : 0;
                    ai.action   = 1;  // show_alert
                    ai.priority = 1;
                    ai.text     = j.value("text", std::string{});
                    if (j.contains("connection")) {
                        ai.connection = connection_info_from_json(j["connection"]);
                        ai.has_connection = true;
                    }
                    if (j.contains("rule")) {
                        ai.rule_name = j["rule"].value("name", std::string{});
                    }
                    if (ai.text.empty() && ai.has_connection) {
                        const auto host = !ai.connection.dest_host.empty()
                                              ? ai.connection.dest_host
                                              : ai.connection.dest_ip;
                        ai.text = ai.connection.protocol + " " + display_app_name(ai.connection)
                                  + " -> " + host + ":" + std::to_string(ai.connection.dest_port);
                    }
                    dispatch_alert(ai);
                    continue;
                }
 
                // tipo sconosciuto: ignora
            } catch (const std::exception& e) {
                std::cerr << "[UIServer] JSON parse error: " << e.what() << "\n";
            }
        }
 
        // Disconnessione
        if (announced) dispatch_disconnected();
        int expected = fd;
        client_fd_.compare_exchange_strong(expected, -1);
        ::close(fd);
 
        // Sblocca eventuale sendReply pendente
        {
            std::lock_guard<std::mutex> lk(reply_mutex_);
            reply_ready_ = true;
            reply_action_ = ReplyAction::DENY_ONCE;
        }
        reply_cv_.notify_all();
    }

References AlertInfo::action, ALLOW_ALWAYS, ALLOW_ONCE, client_fd_, AlertInfo::connection, connection_info_from_json(), current_ask_id_, DENY_ALWAYS, DENY_ONCE, ConnectionInfo::dest_host, ConnectionInfo::dest_ip, ConnectionInfo::dest_port, dispatch_alert(), dispatch_connected(), dispatch_disconnected(), dispatch_new_connection(), display_app_name(), flush_pending_notifs(), bsc::proto::frame_peek_length(), AlertInfo::has_connection, AlertInfo::id, bsc::proto::msg::kAlert, bsc::proto::msg::kAskRule, bsc::proto::msg::kAskRuleReply, bsc::proto::msg::kHello, bsc::proto::kMaxFrameSize, bsc::proto::msg::kPing, bsc::proto::msg::kPong, AlertInfo::priority, ConnectionInfo::protocol, read_exact(), reply_action_, reply_cv_, reply_mutex_, reply_ready_, AlertInfo::rule_name, running_, send_frame(), AlertInfo::text, AlertInfo::type, and AlertInfo::what.

Referenced by accept_loop().

◆ dispatch_alert()

void UIServer::Impl::dispatch_alert ( const AlertInfo & a )

inline

Definition at line 408 of file UIServer.cpp.

                                            {
        Glib::signal_idle().connect_once([this, a]() { owner_->signal_alert.emit(a); });
    }

References owner_, and UIServer::signal_alert.

Referenced by client_session().

◆ dispatch_connected()

void UIServer::Impl::dispatch_connected ( )

inline

Definition at line 403 of file UIServer.cpp.

403{ Glib::signal_idle().connect_once([this]() { owner_->signal_daemon_connected.emit(); }); }

UIServer::signal_daemon_connected

sigc::signal< void()> signal_daemon_connected

Definition UIServer.hpp:89

References owner_, and UIServer::signal_daemon_connected.

Referenced by client_session().

◆ dispatch_disconnected()

void UIServer::Impl::dispatch_disconnected ( )

inline

Definition at line 404 of file UIServer.cpp.

404{ Glib::signal_idle().connect_once([this]() { owner_->signal_daemon_disconnected.emit(); }); }

UIServer::signal_daemon_disconnected

sigc::signal< void()> signal_daemon_disconnected

Definition UIServer.hpp:90

References owner_, and UIServer::signal_daemon_disconnected.

Referenced by client_session().

◆ dispatch_new_connection()

void UIServer::Impl::dispatch_new_connection ( const ConnectionInfo & info )

inline

Definition at line 405 of file UIServer.cpp.

                                                             {
        Glib::signal_idle().connect_once([this, info]() { owner_->signal_new_connection.emit(info); });
    }

References owner_, and UIServer::signal_new_connection.

Referenced by client_session().

◆ flush_pending_notifs()

void UIServer::Impl::flush_pending_notifs ( )

inline

Definition at line 352 of file UIServer.cpp.

                                {
        std::deque<json> q;
        {
            std::lock_guard<std::mutex> lk(notif_mutex_);
            q.swap(pending_notifs_);
        }
        for (const auto& j : q) {
            if (!send_frame(j.dump())) {
                std::lock_guard<std::mutex> lk(notif_mutex_);
                pending_notifs_.push_front(j);
                break;
            }
        }
    }

References notif_mutex_, pending_notifs_, and send_frame().

Referenced by client_session().

◆ queue_notification()

void UIServer::Impl::queue_notification	(	int	type,
		const std::string &	data )

inline

Definition at line 380 of file UIServer.cpp.

                                                             {
        static const char* kinds[] = {
            "none", "enable_interception", "disable_interception",
            "enable_firewall", "disable_firewall", "reload_fw_rules",
            "change_config", "enable_rule", "disable_rule", "delete_rule",
            "change_rule", "log_level", "stop", "task_start", "task_stop",
            "desktop_active", "desktop_idle"
        };
        const std::string kind = (type >= 0 && type < 17) ? kinds[type] : "none";
        json j = {
            {"type", bsc::proto::msg::kNotification},
            {"id",   next_id_++},
            {"kind", kind},
            {"data", data}
        };
        if (client_fd_.load() >= 0 && send_frame(j.dump())) return;
        std::lock_guard<std::mutex> lk(notif_mutex_);
        if (pending_notifs_.size() > 128) pending_notifs_.pop_front();
        pending_notifs_.push_back(std::move(j));
    }

References client_fd_, bsc::proto::msg::kNotification, next_id_, notif_mutex_, pending_notifs_, and send_frame().

◆ read_exact()

bool UIServer::Impl::read_exact	(	int	fd,
		std::uint8_t *	buf,
		std::size_t	n )

inline

Definition at line 190 of file UIServer.cpp.

                                                          {
        std::size_t got = 0;
        while (got < n) {
            ssize_t r = ::recv(fd, buf + got, n - got, 0);
            if (r == 0) return false;
            if (r < 0) { if (errno == EINTR) continue; return false; }
            got += static_cast<std::size_t>(r);
        }
        return true;
    }

Referenced by client_session().

◆ send_frame()

bool UIServer::Impl::send_frame ( const std::string & payload )

inline

Definition at line 337 of file UIServer.cpp.

                                              {
        int fd = client_fd_.load();
        if (fd < 0) return false;
        std::vector<std::uint8_t> frame;
        bsc::proto::frame_encode(payload, frame);
        std::lock_guard<std::mutex> lk(write_mutex_);
        std::size_t total = 0;
        while (total < frame.size()) {
            ssize_t n = ::send(fd, frame.data() + total, frame.size() - total, MSG_NOSIGNAL);
            if (n < 0) { if (errno == EINTR) continue; return false; }
            total += static_cast<std::size_t>(n);
        }
        return true;
    }

References client_fd_, bsc::proto::frame_encode(), and write_mutex_.

Referenced by client_session(), flush_pending_notifs(), and queue_notification().

◆ send_reply()

void UIServer::Impl::send_reply ( ReplyAction action )

inline

Definition at line 369 of file UIServer.cpp.

                                        {
        {
            std::lock_guard<std::mutex> lk(reply_mutex_);
            reply_action_ = action;
            reply_ready_  = true;
        }
        reply_cv_.notify_one();
    }

References reply_action_, reply_cv_, reply_mutex_, and reply_ready_.

◆ start()

bool UIServer::Impl::start ( const std::string & socketPath )

inline

Definition at line 103 of file UIServer.cpp.

                                            {
        if (running_.exchange(true)) return false;
 
        socket_file_ = bsc::proto::resolve_socket_path(socketPath);
        try {
            fs::path p(socket_file_);
            if (p.has_parent_path()) fs::create_directories(p.parent_path());
            if (fs::exists(p)) fs::remove(p);
        } catch (const std::exception& e) {
            std::cerr << "[UIServer] prep socket: " << e.what() << "\n";
        }
 
        listen_fd_ = ::socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
        if (listen_fd_ < 0) { running_ = false; return false; }
 
        sockaddr_un addr{};
        addr.sun_family = AF_UNIX;
        if (socket_file_.size() >= sizeof(addr.sun_path)) {
            ::close(listen_fd_); listen_fd_ = -1; running_ = false; return false;
        }
        std::memcpy(addr.sun_path, socket_file_.c_str(), socket_file_.size());
 
        if (::bind(listen_fd_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
            std::cerr << "[UIServer] bind fallita: " << std::strerror(errno) << "\n";
            ::close(listen_fd_); listen_fd_ = -1; running_ = false; return false;
        }
 
        // Permessi: il daemon gira come root, la UI come utente. Il socket
        // deve essere accessibile da entrambi → 0666.
        ::chmod(socket_file_.c_str(), 0666);
 
        if (::listen(listen_fd_, 4) < 0) {
            ::close(listen_fd_); listen_fd_ = -1; running_ = false; return false;
        }
 
        std::cout << "[UIServer] in ascolto su " << socket_file_ << "\n";
 
        accept_thread_ = std::thread([this]() { accept_loop(); });
        return true;
    }

References accept_loop(), accept_thread_, listen_fd_, bsc::proto::resolve_socket_path(), running_, and socket_file_.

◆ stop()

void UIServer::Impl::stop ( )

inline

Definition at line 144 of file UIServer.cpp.

                {
        if (!running_.exchange(false)) return;
 
        // Chiudi listen e client
        int lfd = listen_fd_; listen_fd_ = -1;
        if (lfd >= 0) { ::shutdown(lfd, SHUT_RDWR); ::close(lfd); }
        int cfd = client_fd_.exchange(-1);
        if (cfd >= 0) { ::shutdown(cfd, SHUT_RDWR); ::close(cfd); }
 
        // Sblocca eventuali sendReply in attesa
        {
            std::lock_guard<std::mutex> lk(reply_mutex_);
            reply_ready_ = true;
        }
        reply_cv_.notify_all();
 
        if (accept_thread_.joinable()) accept_thread_.join();
        if (reader_thread_.joinable()) reader_thread_.join();
 
        try { if (!socket_file_.empty()) fs::remove(socket_file_); } catch (...) {}
    }

References accept_thread_, client_fd_, listen_fd_, reader_thread_, reply_cv_, reply_mutex_, reply_ready_, running_, and socket_file_.

Referenced by ~Impl().

Member Data Documentation

◆ accept_thread_

std::thread UIServer::Impl::accept_thread_

Definition at line 78 of file UIServer.cpp.

Referenced by start(), and stop().

◆ client_fd_

std::atomic_int UIServer::Impl::client_fd_ {-1}

Definition at line 75 of file UIServer.cpp.

Referenced by accept_loop(), client_session(), queue_notification(), send_frame(), and stop().

◆ current_ask_id_

std::uint64_t UIServer::Impl::current_ask_id_ {0}

Definition at line 99 of file UIServer.cpp.

Referenced by client_session().

◆ listen_fd_

int UIServer::Impl::listen_fd_ {-1}

Definition at line 71 of file UIServer.cpp.

Referenced by accept_loop(), start(), and stop().

◆ next_id_

std::atomic_uint64_t UIServer::Impl::next_id_ {1}

Definition at line 88 of file UIServer.cpp.

Referenced by queue_notification().

◆ notif_mutex_

std::mutex UIServer::Impl::notif_mutex_

Definition at line 91 of file UIServer.cpp.

Referenced by flush_pending_notifs(), and queue_notification().

◆ owner_

UIServer* UIServer::Impl::owner_

Definition at line 68 of file UIServer.cpp.

Referenced by dispatch_alert(), dispatch_connected(), dispatch_disconnected(), dispatch_new_connection(), and Impl().

◆ pending_notifs_

std::deque<json> UIServer::Impl::pending_notifs_

Definition at line 92 of file UIServer.cpp.

Referenced by flush_pending_notifs(), and queue_notification().

◆ reader_thread_

std::thread UIServer::Impl::reader_thread_

Definition at line 82 of file UIServer.cpp.

Referenced by accept_loop(), and stop().

◆ reply_action_

ReplyAction UIServer::Impl::reply_action_ {ReplyAction::DENY_ONCE}

Definition at line 98 of file UIServer.cpp.

Referenced by client_session(), and send_reply().

◆ reply_cv_

std::condition_variable UIServer::Impl::reply_cv_

Definition at line 96 of file UIServer.cpp.

Referenced by client_session(), send_reply(), and stop().

◆ reply_mutex_

std::mutex UIServer::Impl::reply_mutex_

Definition at line 95 of file UIServer.cpp.

Referenced by client_session(), send_reply(), and stop().

◆ reply_ready_

bool UIServer::Impl::reply_ready_ {false}

Definition at line 97 of file UIServer.cpp.

Referenced by client_session(), send_reply(), and stop().

◆ running_

std::atomic_bool UIServer::Impl::running_ {false}

Definition at line 79 of file UIServer.cpp.

Referenced by accept_loop(), client_session(), start(), and stop().

◆ socket_file_

std::string UIServer::Impl::socket_file_

Definition at line 72 of file UIServer.cpp.

Referenced by start(), and stop().

◆ write_mutex_

std::mutex UIServer::Impl::write_mutex_

Definition at line 85 of file UIServer.cpp.

Referenced by send_frame().

The documentation for this class was generated from the following file:

BastionGuard/thirdparty/bastionguard-secure-connection/ui/src/ipc/UIServer.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Impl()

◆ ~Impl()

Member Function Documentation

◆ accept_loop()

◆ client_session()

◆ dispatch_alert()

◆ dispatch_connected()

◆ dispatch_disconnected()

◆ dispatch_new_connection()

◆ flush_pending_notifs()

◆ queue_notification()

◆ read_exact()

◆ send_frame()

◆ send_reply()

◆ start()

◆ stop()

Member Data Documentation

◆ accept_thread_

◆ client_fd_

◆ current_ask_id_

◆ listen_fd_

◆ next_id_

◆ notif_mutex_

◆ owner_

◆ pending_notifs_

◆ reader_thread_

◆ reply_action_

◆ reply_cv_

◆ reply_mutex_

◆ reply_ready_

◆ running_

◆ socket_file_

◆ write_mutex_