SignalingServer Class Reference

#include <SignalingServer.h>

Collaboration diagram for SignalingServer:

Public Member Functions
	SignalingServer (std::weak_ptr< NetworkManager > parent)
	~SignalingServer ()
void	start (unsigned short port)
void	stop ()
void	onConnect (std::string clientId, std::shared_ptr< rtc::WebSocket > client)
void	onMessage (const std::string &clientId, const std::string &text)
void	sendTo (const std::string &clientId, const std::string &message)
void	broadcast (const std::string &message)
void	broadcastShutdown ()
void	disconnectAllClients ()
void	setPendingAuthTimeout (std::chrono::seconds s)
void	moveToAuthenticated (const std::string &clientId)
bool	isAuthenticated (const std::string &clientId) const
void	disconnectClient (const std::string &clientId)
const std::unordered_map< std::string, std::shared_ptr< rtc::WebSocket > > &	authClients () const
bool	isRunning () const

Private Attributes
std::shared_ptr< rtc::WebSocketServer >	server
std::weak_ptr< NetworkManager >	network_manager
bool	is_running = false
std::unordered_map< std::string, std::shared_ptr< rtc::WebSocket > >	pendingClients_
std::unordered_map< std::string, std::string >	pendingUsernames_
std::unordered_map< std::string, std::string >	authUsernames_
std::unordered_map< std::string, std::shared_ptr< rtc::WebSocket > >	authClients_
std::chrono::seconds	pendingTimeout_ {60}

Detailed Description

Definition at line 10 of file SignalingServer.h.

Constructor & Destructor Documentation

SignalingServer()

SignalingServer::SignalingServer

(

std::weak_ptr< NetworkManager >

parent

)

Definition at line 13 of file SignalingServer.cpp.

                                                                   :
    network_manager(parent)
{
}

~SignalingServer()

SignalingServer::~SignalingServer

(

)

Definition at line 18 of file SignalingServer.cpp.

{
    this->stop();
}

Here is the call graph for this function:

Member Function Documentation

authClients()

const std::unordered_map< std::string, std::shared_ptr< rtc::WebSocket > > & SignalingServer::authClients ( ) const

inline

Definition at line 39 of file SignalingServer.h.

    {
        return authClients_;
    }

broadcast()

void SignalingServer::broadcast

(

const std::string &

message

)

Definition at line 231 of file SignalingServer.cpp.

{
    for (auto& [id, ws] : authClients_)
    {
        if (ws && !ws->isClosed())
            ws->send(message);
    }
}

Here is the caller graph for this function:

broadcastShutdown()

void SignalingServer::broadcastShutdown

(

)

Definition at line 240 of file SignalingServer.cpp.

{
    nlohmann::json j = msg::makeBroadcastShutdown();
    broadcast(j.dump());
}

Here is the call graph for this function:

disconnectAllClients()

void SignalingServer::disconnectAllClients

(

)

Definition at line 246 of file SignalingServer.cpp.

{
    // Move out both maps to avoid erase while inside callbacks
    auto auth = std::move(authClients_);
    auto pend = std::move(pendingClients_);
    authClients_.clear();
    pendingClients_.clear();
 
    auto closer = [](auto& map)
    {
        for (auto& [id, ws] : map)
        {
            if (!ws)
                continue;
            try
            {
                ws->onOpen(nullptr);
                ws->onMessage(nullptr);
                ws->onClosed(nullptr);
                ws->onError(nullptr);
                ws->close();
            }
            catch (...)
            {
                Logger::instance().log("main", Logger::Level::Warn, "WS close failed for " + id);
            }
        }
        map.clear();
    };
 
    closer(auth);
    closer(pend);
}

Here is the call graph for this function:

disconnectClient()

void SignalingServer::disconnectClient

(

const std::string &

clientId

)

Definition at line 296 of file SignalingServer.cpp.

{
    auto it = authClients_.find(clientId);
    if (it != authClients_.end() && it->second)
    {
        if (!it->second->isClosed())
            it->second->close();
    }
}

isAuthenticated()

bool SignalingServer::isAuthenticated

(

const std::string &

clientId

)

const

Definition at line 291 of file SignalingServer.cpp.

{
    return authClients_.find(clientId) != authClients_.end();
}

Here is the caller graph for this function:

isRunning()

bool SignalingServer::isRunning ( ) const

inline

Definition at line 43 of file SignalingServer.h.

    {
        return is_running;
    }

moveToAuthenticated()

void SignalingServer::moveToAuthenticated

(

const std::string &

clientId

)

Definition at line 280 of file SignalingServer.cpp.

{
    auto it = pendingClients_.find(clientId);
    if (it == pendingClients_.end())
        return;
    authClients_[clientId] = it->second;
    pendingClients_.erase(it);
    //pendingSince_.erase(clientId);
    std::cout << "[SignalingServer] Authenticated: " << clientId << "\n";
}

Here is the caller graph for this function:

onConnect()

void SignalingServer::onConnect	(	std::string	clientId,
		std::shared_ptr< rtc::WebSocket >	client )

Definition at line 86 of file SignalingServer.cpp.

{
    pendingClients_[clientId] = std::move(ws);
    //pendingSince_[clientId] = Clock::now();
}

Here is the caller graph for this function:

onMessage()

void SignalingServer::onMessage	(	const std::string &	clientId,
		const std::string &	text )

Definition at line 92 of file SignalingServer.cpp.

{
 
    json j;
    try
    {
        j = json::parse(text);
    }
    catch (...)
    {
        return;
    }
 
    const std::string type = j.value(msg::key::Type, "");
    if (type.empty())
        return;
 
    if (type == msg::signaling::Auth)
    {
        auto nm = network_manager.lock();
        if (!nm)
            throw std::runtime_error("NetworkManager expired");
 
        const std::string provided = j.value(std::string(msg::key::AuthToken), "");
        const std::string expected = nm->getNetworkPassword();
 
        const bool ok = (expected.empty() || provided == expected);
        const std::string username = j.value(std::string(msg::key::Username), "guest" + clientId);
        const std::string clientUniqueId = j.value(std::string(msg::key::UniqueId), "");
 
        if (ok)
        {
            moveToAuthenticated(clientId);
 
            std::vector<std::string> others;
            others.reserve(authClients_.size());
            for (auto& [id, _] : authClients_)
                if (id != clientId)
                    others.emplace_back(id);
 
            // IMPORTANT: GM id in response must be GM UNIQUE ID
            const std::string gmUniqueId = nm->getMyUniqueId();
 
            // you may optionally echo client uniqueId back (makeAuthResponse supports uniqueId param)
            auto resp = msg::makeAuthResponse(msg::value::True, "welcome",
                                              clientId, username,
                                              others,
                                              /*gmPeerId=*/gmUniqueId,
                                              /*uniqueId=*/clientUniqueId);
            sendTo(clientId, resp.dump());
        }
        else
        {
            auto resp = msg::makeAuthResponse(msg::value::False, "invalid password",
                                              clientId, username);
            sendTo(clientId, resp.dump());
 
            if (auto it = pendingClients_.find(clientId); it != pendingClients_.end() && it->second)
                it->second->close();
            else if (auto it2 = authClients_.find(clientId); it2 != authClients_.end() && it2->second)
                it2->second->close();
        }
        return;
    }
 
    // for all other types, require auth
    if (!isAuthenticated(clientId))
    {
        auto resp = msg::makeAuthResponse(msg::value::False, "unauthenticated",
                                          clientId, "guest" + clientId);
        sendTo(clientId, resp.dump());
        return;
    }
 
    // Router: overwrite from with server-trusted clientId
    j[msg::key::From] = clientId;
 
    // In SignalingServer::onMessage (after auth checks)
    if (type == msg::signaling::PeerDisconnect)
    {
        const std::string target = j.value(std::string(msg::key::Target), "");
        if (target.empty())
            return;
 
        // Broadcast to all authed clients (including target)
        const std::string dump = j.dump();
        for (auto& [id, ws] : authClients_)
        {
            if (ws && !ws->isClosed())
                ws->send(dump);
        }
 
        // Optionally kick the target at signaling level
        if (auto it = authClients_.find(target); it != authClients_.end())
        {
            if (it->second)
                it->second->close();
        }
        return;
    }
 
    // Broadcast to authenticated only
    if (j.value(msg::key::Broadcast, msg::value::False) == msg::value::True)
    {
        const std::string dump = j.dump();
        for (auto& [id, ws] : authClients_)
        {
            if (id == clientId)
                continue; // don't echo to sender
            if (ws && !ws->isClosed())
                ws->send(dump);
        }
        return;
    }
 
    // Direct
    const std::string to = j.value(msg::key::To, "");
    if (to.empty())
        return;
    auto it = authClients_.find(to);
    if (it != authClients_.end() && it->second && !it->second->isClosed())
    {
        it->second->send(j.dump());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendTo()

void SignalingServer::sendTo	(	const std::string &	clientId,
		const std::string &	message )

Definition at line 218 of file SignalingServer.cpp.

{
    if (auto it = authClients_.find(clientId); it != authClients_.end() && it->second && !it->second->isClosed())
    {
        it->second->send(message);
        return;
    }
    if (auto it = pendingClients_.find(clientId); it != pendingClients_.end() && it->second && !it->second->isClosed())
    {
        it->second->send(message);
    }
}

Here is the caller graph for this function:

setPendingAuthTimeout()

void SignalingServer::setPendingAuthTimeout ( std::chrono::seconds s )

inline

Definition at line 28 of file SignalingServer.h.

    {
        pendingTimeout_ = s;
    }

start()

void SignalingServer::start

(

unsigned short

port

)

Definition at line 23 of file SignalingServer.cpp.

{
    rtc::WebSocketServerConfiguration cfg;
    cfg.bindAddress = "0.0.0.0";
    cfg.port = port;
    cfg.connectionTimeout = std::chrono::milliseconds(0);
 
    server = std::make_shared<rtc::WebSocketServer>(cfg);
 
    server->onClient([this](std::shared_ptr<rtc::WebSocket> ws)
                     {
        auto addrOpt = ws->remoteAddress();
        if (!addrOpt) { std::cout << "[SignalingServer] Client connected (no addr)\n"; return; }
        std::string clientId = *addrOpt;
        std::cout << "[SignalingServer] Client Connected: " << clientId << "\n";
 
        onConnect(clientId, ws);
 
        ws->onMessage([this, clientId](std::variant<rtc::binary, rtc::string> msg) {
            std::cout << "[SignalingServer] MESSAGE RECEIVED" <<"\n";
            if (!std::holds_alternative<rtc::string>(msg)) return;
            const auto& s = std::get<rtc::string>(msg);
            std::cout << "[SignalingServer] MESSAGE: " << s <<"\n";
            //prunePending();
            onMessage(clientId, s);
        });
 
        ws->onError([clientId](std::string err) {
            std::cout << "[SignalingServer] Client Error (" << clientId << "): " << err << "\n";
            });
 
        ws->onClosed([this, clientId]() {
            std::cout << "[SignalingServer] Client disconnected: " << clientId << "\n";
            pendingClients_.erase(clientId);
            //pendingSince_.erase(clientId);
            authClients_.erase(clientId);
            }); });
 
    is_running = true;
    std::cout << "[SignalingServer] Listening at ws://0.0.0.0:" << port << "\n";
}

Here is the call graph for this function:

stop()

void SignalingServer::stop

(

)

Definition at line 65 of file SignalingServer.cpp.

{
    if (server)
    {
        server->stop();
        server.reset();
        is_running = false;
    }
    for (auto [id, ws] : pendingClients_)
    {
        NetworkUtilities::safeCloseWebSocket(ws);
    }
 
    for (auto [id, ws] : authClients_)
    {
        NetworkUtilities::safeCloseWebSocket(ws);
    }
    pendingClients_.clear();
    authClients_.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

authClients_

std::unordered_map<std::string, std::shared_ptr<rtc::WebSocket> > SignalingServer::authClients_

private

Definition at line 59 of file SignalingServer.h.

authUsernames_

std::unordered_map<std::string, std::string> SignalingServer::authUsernames_

private

Definition at line 58 of file SignalingServer.h.

is_running

bool SignalingServer::is_running = false

private

Definition at line 51 of file SignalingServer.h.

network_manager

std::weak_ptr<NetworkManager> SignalingServer::network_manager

private

Definition at line 50 of file SignalingServer.h.

pendingClients_

std::unordered_map<std::string, std::shared_ptr<rtc::WebSocket> > SignalingServer::pendingClients_

private

Definition at line 53 of file SignalingServer.h.

pendingTimeout_

std::chrono::seconds SignalingServer::pendingTimeout_ {60}

private

Definition at line 60 of file SignalingServer.h.

{60}; // default: 60s to auth

pendingUsernames_

std::unordered_map<std::string, std::string> SignalingServer::pendingUsernames_

private

Definition at line 55 of file SignalingServer.h.

server

std::shared_ptr<rtc::WebSocketServer> SignalingServer::server

private

Definition at line 49 of file SignalingServer.h.

---

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

• include/network/SignalingServer.h
• src/network/SignalingServer.cpp