bsc::ui::UIClient::Impl Class Reference

Classes
struct	PendingAsk

Public Member Functions
	Impl (std::string uri)
	~Impl ()
void	start ()
void	stop ()
bool	is_connected () const noexcept
int	connect_once () const
void	reconnect_loop ()
bool	write_frame (const std::string &payload)
bool	read_exact (int fd, std::uint8_t *buf, std::size_t n)
void	read_until_eof ()
void	dispatch_incoming (const json &j)
bool	send_hello ()
void	flush_queued_alerts ()
bool	send_or_queue_alert (const json &j)

Public Attributes
std::string	socket_path_
std::atomic_bool	running_ {false}
std::atomic_int	fd_ {-1}
std::atomic_bool	handshake_done_ {false}
std::thread	reader_thread_
std::mutex	write_mutex_
std::atomic_uint64_t	next_id_ {1}
std::mutex	pending_mutex_
std::unordered_map< std::uint64_t, std::shared_ptr< PendingAsk > >	pending_asks_
std::mutex	handler_mutex_
std::function< void(const NotificationEvent &)>	notif_handler_
std::mutex	alerts_mutex_
std::deque< std::string >	queued_alerts_

Detailed Description

Definition at line 97 of file UIClient.cpp.

Constructor & Destructor Documentation

Impl()

bsc::ui::UIClient::Impl::Impl ( std::string uri )

inlineexplicit

Definition at line 99 of file UIClient.cpp.

        : socket_path_(bsc::proto::resolve_socket_path(std::move(uri))) {}

References socket_path_.

~Impl()

bsc::ui::UIClient::Impl::~Impl ( )

inline

Definition at line 102 of file UIClient.cpp.

{ stop(); }

References stop().

Member Function Documentation

connect_once()

int bsc::ui::UIClient::Impl::connect_once ( ) const

inline

Definition at line 171 of file UIClient.cpp.

                             {
        int fd = ::socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
        if (fd < 0) return -1;
        sockaddr_un addr{};
        addr.sun_family = AF_UNIX;
        if (socket_path_.size() >= sizeof(addr.sun_path)) { ::close(fd); return -1; }
        std::memcpy(addr.sun_path, socket_path_.c_str(), socket_path_.size());
        if (::connect(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
            ::close(fd);
            return -1;
        }
        return fd;
    }

References socket_path_.

Referenced by reconnect_loop().

dispatch_incoming()

void bsc::ui::UIClient::Impl::dispatch_incoming ( const json & j )

inline

Definition at line 287 of file UIClient.cpp.

                                          {
        const std::string type = j.value("type", std::string{});
        if (type == bsc::proto::msg::kPong) {
            // Nothing to do: e' una conferma di heartbeat.
            return;
        }
        if (type == bsc::proto::msg::kAskRuleReply) {
            const auto id = j.value("id", std::uint64_t{0});
            std::shared_ptr<PendingAsk> p;
            {
                std::lock_guard<std::mutex> lk(pending_mutex_);
                auto it = pending_asks_.find(id);
                if (it == pending_asks_.end()) return;
                p = it->second;
            }
            {
                std::lock_guard<std::mutex> l2(p->mu);
                p->reply = j;
                p->ready = true;
            }
            p->cv.notify_all();
            return;
        }
        if (type == bsc::proto::msg::kNotification) {
            NotificationEvent ev;
            ev.id   = j.value("id", std::uint64_t{0});
            ev.type = j.value("kind", std::string{});
            ev.data = j.value("data", std::string{});
            if (j.contains("rules") && j["rules"].is_array()) {
                for (const auto& r : j["rules"]) ev.rules.push_back(rule_from_json(r));
            }
            std::function<void(const NotificationEvent&)> cb;
            {
                std::lock_guard<std::mutex> lk(handler_mutex_);
                cb = notif_handler_;
            }
            if (cb) cb(ev);
            return;
        }
        bsc::logging::Logger::instance().warning(
            "UIClient: messaggio di tipo sconosciuto: " + type);
    }

References bsc::ui::NotificationEvent::data, handler_mutex_, bsc::ui::NotificationEvent::id, bsc::logging::Logger::instance(), bsc::proto::msg::kAskRuleReply, bsc::proto::msg::kNotification, bsc::proto::msg::kPong, notif_handler_, pending_asks_, pending_mutex_, bsc::ui::NotificationEvent::rules, bsc::ui::NotificationEvent::type, and bsc::logging::Logger::warning().

Referenced by read_until_eof().

flush_queued_alerts()

void bsc::ui::UIClient::Impl::flush_queued_alerts ( )

inline

Definition at line 341 of file UIClient.cpp.

                               {
        std::deque<std::string> q;
        {
            std::lock_guard<std::mutex> lk(alerts_mutex_);
            q.swap(queued_alerts_);
        }
        for (const auto& payload : q) {
            if (!write_frame(payload)) {
                // Rimetti in coda quello che non siamo riusciti a spedire
                std::lock_guard<std::mutex> lk(alerts_mutex_);
                queued_alerts_.push_front(payload);
                break;
            }
        }
    }

References alerts_mutex_, queued_alerts_, and write_frame().

Referenced by reconnect_loop().

is_connected()

bool bsc::ui::UIClient::Impl::is_connected ( ) const

inlinenoexcept

Definition at line 164 of file UIClient.cpp.

                                       {
        return fd_.load() >= 0 && handshake_done_.load();
    }

References fd_, and handshake_done_.

Referenced by send_or_queue_alert().

read_exact()

bool bsc::ui::UIClient::Impl::read_exact ( int fd, std::uint8_t * buf, std::size_t n )

inline

Definition at line 247 of file UIClient.cpp.

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

Referenced by read_until_eof().

read_until_eof()

void bsc::ui::UIClient::Impl::read_until_eof ( )

inline

Definition at line 262 of file UIClient.cpp.

                          {
        auto& log = bsc::logging::Logger::instance();
        int fd = fd_.load();
        while (fd >= 0 && running_) {
            std::uint8_t len_buf[4];
            if (!read_exact(fd, len_buf, 4)) break;
            const std::int64_t len = bsc::proto::frame_peek_length(len_buf, 4);
            if (len < 0 || static_cast<std::size_t>(len) > bsc::proto::kMaxFrameSize) {
                log.warning("UIClient: frame invalido, chiudo connessione");
                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());
                dispatch_incoming(j);
            } catch (const std::exception& e) {
                log.warning(std::string("UIClient: JSON invalido: ") + e.what());
            }
            fd = fd_.load();
        }
    }

References dispatch_incoming(), fd_, bsc::proto::frame_peek_length(), bsc::logging::Logger::instance(), bsc::proto::kMaxFrameSize, read_exact(), and running_.

Referenced by reconnect_loop().

reconnect_loop()

void bsc::ui::UIClient::Impl::reconnect_loop ( )

inline

Definition at line 185 of file UIClient.cpp.

                          {
        auto& log = bsc::logging::Logger::instance();
        bool previously_connected = false;
        while (running_) {
            int fd = connect_once();
            if (fd < 0) {
                if (previously_connected) {
                    log.warning("UI disconnessa, tento la riconnessione...");
                    previously_connected = false;
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
                continue;
            }
 
            fd_ = fd;
            handshake_done_ = false;
 
            // Invia hello immediatamente
            if (!send_hello()) {
                ::close(fd);
                fd_ = -1;
                std::this_thread::sleep_for(std::chrono::seconds(1));
                continue;
            }
 
            handshake_done_ = true;
            previously_connected = true;
            log.info("UI connessa su " + socket_path_);
            flush_queued_alerts();
 
            // Loop di lettura finche' il socket non si chiude
            read_until_eof();
 
            // Disconnesso: pulisci
            int old = fd_.exchange(-1);
            if (old >= 0) ::close(old);
            handshake_done_ = false;
        }
    }

References connect_once(), fd_, flush_queued_alerts(), handshake_done_, bsc::logging::Logger::instance(), read_until_eof(), running_, send_hello(), and socket_path_.

Referenced by start().

send_hello()

bool bsc::ui::UIClient::Impl::send_hello ( )

inline

Definition at line 332 of file UIClient.cpp.

                      {
        json j = {
            {"type", bsc::proto::msg::kHello},
            {"id",   next_id_++},
            {"daemon_version", "bsc-daemon-cpp"}
        };
        return write_frame(j.dump());
    }

References bsc::proto::msg::kHello, next_id_, and write_frame().

Referenced by reconnect_loop().

send_or_queue_alert()

bool bsc::ui::UIClient::Impl::send_or_queue_alert ( const json & j )

inline

Definition at line 358 of file UIClient.cpp.

                                            {
        const std::string payload = j.dump();
        if (is_connected() && write_frame(payload)) return true;
        std::lock_guard<std::mutex> lk(alerts_mutex_);
        if (queued_alerts_.size() >= 128) queued_alerts_.pop_front();
        queued_alerts_.push_back(payload);
        return true;
    }

References alerts_mutex_, is_connected(), queued_alerts_, and write_frame().

start()

void bsc::ui::UIClient::Impl::start ( )

inline

Definition at line 138 of file UIClient.cpp.

                 {
        if (running_.exchange(true)) return;
        reader_thread_ = std::thread([this]() { reconnect_loop(); });
    }

References reader_thread_, reconnect_loop(), and running_.

stop()

void bsc::ui::UIClient::Impl::stop ( )

inline

Definition at line 143 of file UIClient.cpp.

                {
        running_ = false;
        int fd = fd_.exchange(-1);
        if (fd >= 0) {
            ::shutdown(fd, SHUT_RDWR);
            ::close(fd);
        }
        // Sblocca qualunque ask_rule bloccato
        {
            std::lock_guard<std::mutex> lk(pending_mutex_);
            for (auto& [id, p] : pending_asks_) {
                std::lock_guard<std::mutex> l2(p->mu);
                p->ready = true;
                p->reply = json::object();   // risposta vuota = timeout
                p->cv.notify_all();
            }
            pending_asks_.clear();
        }
        if (reader_thread_.joinable()) reader_thread_.join();
    }

References fd_, pending_asks_, pending_mutex_, reader_thread_, and running_.

Referenced by ~Impl().

write_frame()

bool bsc::ui::UIClient::Impl::write_frame ( const std::string & payload )

inline

Definition at line 228 of file UIClient.cpp.

                                               {
        int fd = 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 fd_, bsc::proto::frame_encode(), and write_mutex_.

Referenced by flush_queued_alerts(), send_hello(), and send_or_queue_alert().

Member Data Documentation

alerts_mutex_

std::mutex bsc::ui::UIClient::Impl::alerts_mutex_

Definition at line 133 of file UIClient.cpp.

Referenced by flush_queued_alerts(), and send_or_queue_alert().

fd_

std::atomic_int bsc::ui::UIClient::Impl::fd_ {-1}

Definition at line 108 of file UIClient.cpp.

Referenced by is_connected(), read_until_eof(), reconnect_loop(), stop(), and write_frame().

handler_mutex_

std::mutex bsc::ui::UIClient::Impl::handler_mutex_

Definition at line 129 of file UIClient.cpp.

Referenced by dispatch_incoming().

handshake_done_

std::atomic_bool bsc::ui::UIClient::Impl::handshake_done_ {false}

Definition at line 109 of file UIClient.cpp.

Referenced by is_connected(), and reconnect_loop().

next_id_

std::atomic_uint64_t bsc::ui::UIClient::Impl::next_id_ {1}

Definition at line 116 of file UIClient.cpp.

Referenced by send_hello().

notif_handler_

std::function<void(const NotificationEvent&)> bsc::ui::UIClient::Impl::notif_handler_

Definition at line 130 of file UIClient.cpp.

Referenced by dispatch_incoming().

pending_asks_

std::unordered_map<std::uint64_t, std::shared_ptr<PendingAsk> > bsc::ui::UIClient::Impl::pending_asks_

Definition at line 126 of file UIClient.cpp.

Referenced by dispatch_incoming(), and stop().

pending_mutex_

std::mutex bsc::ui::UIClient::Impl::pending_mutex_

Definition at line 125 of file UIClient.cpp.

Referenced by dispatch_incoming(), and stop().

queued_alerts_

std::deque<std::string> bsc::ui::UIClient::Impl::queued_alerts_

Definition at line 134 of file UIClient.cpp.

Referenced by flush_queued_alerts(), and send_or_queue_alert().

reader_thread_

std::thread bsc::ui::UIClient::Impl::reader_thread_

Definition at line 110 of file UIClient.cpp.

Referenced by start(), and stop().

running_

std::atomic_bool bsc::ui::UIClient::Impl::running_ {false}

Definition at line 107 of file UIClient.cpp.

Referenced by read_until_eof(), reconnect_loop(), start(), and stop().

socket_path_

std::string bsc::ui::UIClient::Impl::socket_path_

Definition at line 104 of file UIClient.cpp.

Referenced by connect_once(), Impl(), and reconnect_loop().

write_mutex_

std::mutex bsc::ui::UIClient::Impl::write_mutex_

Definition at line 113 of file UIClient.cpp.

Referenced by write_frame().

---

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

• BastionGuard/thirdparty/bastionguard-secure-connection/daemon/src/ui/UIClient.cpp