#include <PeerLink.h>

Collaboration diagram for PeerLink:

Public Member Functions
	PeerLink (const std::string &id, std::weak_ptr< NetworkManager > parent)

	PeerLink ()

void	close ()

void	createChannels ()

void	createDataChannel (const std::string &label)

rtc::Description	createOffer ()

rtc::Description	createAnswer ()

void	setRemoteDescription (const rtc::Description &desc)

void	addIceCandidate (const rtc::Candidate &candidate)

void	send (const std::string &msg)

bool	sendOn (const std::string &label, const std::vector< uint8_t > &bytes)

bool	sendOn (const std::string &label, std::string_view text)

bool	sendGame (const std::vector< uint8_t > &bytes)

bool	sendChat (const std::vector< uint8_t > &bytes)

bool	sendNote (const std::vector< uint8_t > &bytes)

bool	sendMarkerMove (const std::vector< uint8_t > &bytes)

void	sendChatJson (const std::string &jsonText)

void	setDisplayName (std::string n)

const std::string &	displayName () const

void	attachChannelHandlers (const std::shared_ptr< rtc::DataChannel > &ch, const std::string &label)

void	attachMarkerMoveChannelHandlers (const std::shared_ptr< rtc::DataChannel > &ch, const std::string &label)

bool	isDataChannelOpen () const

rtc::PeerConnection::State	pcState () const

const char *	pcStateString () const

bool	isClosedOrFailed () const

const char *	pcStateToStr (rtc::PeerConnection::State s)

bool	isConnected () const

bool	isPcConnectedOnly () const

void	setOpen (std::string label, bool open)

bool	allRequiredOpen () const

bool	bootstrapSent () const

void	markBootstrapSent ()

void	markBootstrapReset ()

std::shared_ptr< rtc::PeerConnection >	getPeerConnection ()

Private Member Functions
void	setupCallbacks ()

Private Attributes
std::string	peerId

std::string	displayName_

std::shared_ptr< rtc::PeerConnection >	pc

std::unordered_map< std::string, std::shared_ptr< rtc::DataChannel > >	dcs_

std::atomic< bool >	closing_ {false}

std::weak_ptr< NetworkManager >	network_manager

std::atomic< rtc::PeerConnection::State >	lastState_ {rtc::PeerConnection::State::New}

std::atomic< double >	lastStateAt_ {0.0}

std::atomic< bool >	remoteDescSet_ {false}

std::vector< rtc::Candidate >	pendingRemoteCandidates_

std::mutex	candMx_

bool	bootstrapSent_ = false

std::unordered_map< std::string, bool >	dcOpen_

Detailed Description

Definition at line 8 of file PeerLink.h.

Constructor & Destructor Documentation

◆ PeerLink() [1/2]

PeerLink::PeerLink	(	const std::string &	id,
		std::weak_ptr< NetworkManager >	parent )

Definition at line 7 of file PeerLink.cpp.

                                                                          :
    peerId(id), network_manager(parent)
{
    if (auto nm = network_manager.lock())
    {
        auto config = nm->getRTCConfig();
        config.iceServers.push_back({"stun:stun.l.google.com:19302"});    // Google
        config.iceServers.push_back({"stun:stun1.l.google.com:19302"});   // Google alt
        config.iceServers.push_back({"stun:stun.stunprotocol.org:3478"}); // Community server
        pc = std::make_shared<rtc::PeerConnection>(config);
        setupCallbacks();
    }
    else
    {
        throw std::runtime_error("NetworkManager expired");
    }
}

Here is the call graph for this function:

◆ PeerLink() [2/2]

PeerLink::PeerLink ( )

Member Function Documentation

◆ addIceCandidate()

void PeerLink::addIceCandidate ( const rtc::Candidate & candidate )

Definition at line 115 of file PeerLink.cpp.

{
    std::lock_guard<std::mutex> lk(candMx_);
    if (!remoteDescSet_.load(std::memory_order_acquire))
    {
        pendingRemoteCandidates_.push_back(candidate);
    }
    else
    {
        pc->addRemoteCandidate(candidate);
    }
}

◆ allRequiredOpen()

bool PeerLink::allRequiredOpen ( ) const

Definition at line 235 of file PeerLink.cpp.

{
    // minimal: only require the channel used for snapshots
    auto it = dcOpen_.find(msg::dc::name::Game);
    return it != dcOpen_.end() && it->second;
}

◆ attachChannelHandlers()

void PeerLink::attachChannelHandlers	(	const std::shared_ptr< rtc::DataChannel > &	ch,
		const std::string &	label )

Definition at line 242 of file PeerLink.cpp.

{
    if (!dc)
        return;
 
    dc->onOpen([this, id = peerId, label]()
               {
                   std::cout << "[PeerLink] DC open \"" << label << "\" to " << id << "\n";
                   if (auto nm = network_manager.lock())
                   {
                       msg::NetEvent ev{msg::NetEvent::Type::DcOpen, id, label};
                       nm->events_.push(std::move(ev)); // or nm->notifyDcOpen(id, label);
                   }
                   dcOpen_[label] = true; });
 
    dc->onClosed([this, id = peerId, label]()
                 {
        std::cout << "[PeerLink] DC closed \"" << label << "\" to " << id << "\n";
        dcOpen_[label] = false;
        bootstrapSent_ = false;
        if (auto nm = network_manager.lock()) {
            msg::NetEvent ev{msg::NetEvent::Type::DcClosed, id, label};
            nm->events_.push(std::move(ev));
        } });
 
    dc->onMessage([this, id = peerId, label](rtc::message_variant m)
                  {
                      Logger::instance().log("localtunnel", Logger::Level::Info, "MESSAGE RECEIVED!! FROM: "+label);
                      if (auto nm = network_manager.lock())
                      {
                          if (std::holds_alternative<std::string>(m))
                          {
                              const auto& s = std::get<std::string>(m);
                              std::vector<uint8_t> bytes(s.begin(), s.end());
                              nm->inboundRaw_.push(msg::InboundRaw{peerId, label, std::move(bytes)});
                          }
                          else
                          {
                              const auto& bin = std::get<rtc::binary>(m);
                              std::vector<uint8_t> bytes(bin.size());
                              std::memcpy(bytes.data(), bin.data(), bin.size());
                              nm->inboundRaw_.push(msg::InboundRaw{peerId, label, std::move(bytes)});
                          }
                      } });
}

Here is the caller graph for this function:

◆ attachMarkerMoveChannelHandlers()

void PeerLink::attachMarkerMoveChannelHandlers	(	const std::shared_ptr< rtc::DataChannel > &	ch,
		const std::string &	label )

◆ bootstrapSent()

bool PeerLink::bootstrapSent ( ) const

inline

Definition at line 62 of file PeerLink.h.

    {
        return bootstrapSent_;
    }

◆ close()

void PeerLink::close ( )

Definition at line 342 of file PeerLink.cpp.

{
    static std::atomic<uint64_t> guardSeq{0};
    const uint64_t seq = ++guardSeq;
 
    if (closing_.exchange(true))
    {
        Logger::instance().log("main", Logger::Level::Debug, "PeerLink::close() re-entry ignored");
        return;
    }
 
    Logger::instance().log("main", Logger::Level::Debug, "PeerLink::close() begin #" + std::to_string(seq));
 
    try
    {
        for (auto& [label, ch] : dcs_)
        {
            if (!ch)
                continue;
            ch->onOpen(nullptr);
            ch->onMessage(nullptr);
            ch->onBufferedAmountLow(nullptr);
            ch->onClosed(nullptr);
            ch->onError(nullptr);
        }
        if (pc)
        {
            pc->onStateChange(nullptr);
            pc->onGatheringStateChange(nullptr);
            pc->onLocalDescription(nullptr);
            pc->onDataChannel(nullptr);
            pc->onTrack(nullptr);
        }
    }
    catch (...)
    {
        // ignore
    }
 
    std::unordered_map<std::string, std::shared_ptr<rtc::DataChannel>> movedDcs;
    movedDcs.swap(dcs_);
 
    for (auto& kv : movedDcs)
    {
        NetworkUtilities::safeCloseDataChannel(kv.second);
    }
    movedDcs.clear();
 
    NetworkUtilities::safeClosePeerConnection(pc);
 
    Logger::instance().log("main", Logger::Level::Debug, "PeerLink::close() end #" + std::to_string(seq));
}

Here is the call graph for this function:

◆ createAnswer()

rtc::Description PeerLink::createAnswer ( )

Definition at line 91 of file PeerLink.cpp.

{
    auto answer = pc->createAnswer();
    rtc::LocalDescriptionInit init;
    init.icePwd = answer.icePwd();
    init.iceUfrag = answer.iceUfrag();
    pc->setLocalDescription(answer.type(), init);
    return answer; // Send this via signaling
}

◆ createChannels()

void PeerLink::createChannels ( )

Definition at line 50 of file PeerLink.cpp.

{
    if (!pc)
        return;
 
    rtc::DataChannelInit init;           // default reliable/ordered
    rtc::DataChannelInit markerMoveInit; //
    auto reliability = rtc::Reliability{};
    reliability.unordered = true;
    reliability.maxPacketLifeTime = std::chrono::milliseconds(500);
    //reliability.maxRetransmits = 0;
    markerMoveInit.reliability = reliability;
 
    // Offerer creates channels; answerer gets them in pc->onDataChannel
    auto dcGame = pc->createDataChannel(std::string(msg::dc::name::Game), init);
    dcs_[std::string(msg::dc::name::Game)] = dcGame;
    attachChannelHandlers(dcGame, std::string(msg::dc::name::Game));
 
    auto dcChat = pc->createDataChannel(std::string(msg::dc::name::Chat), init);
    dcs_[std::string(msg::dc::name::Chat)] = dcChat;
    attachChannelHandlers(dcChat, std::string(msg::dc::name::Chat));
 
    auto dcNotes = pc->createDataChannel(std::string(msg::dc::name::Notes), init);
    dcs_[std::string(msg::dc::name::Notes)] = dcNotes;
    attachChannelHandlers(dcNotes, std::string(msg::dc::name::Notes));
 
    auto dcMarkerMove = pc->createDataChannel(std::string(msg::dc::name::MarkerMove), markerMoveInit);
    dcs_[std::string(msg::dc::name::MarkerMove)] = dcMarkerMove;
    attachChannelHandlers(dcMarkerMove, std::string(msg::dc::name::MarkerMove));
}

Here is the call graph for this function:

◆ createDataChannel()

void PeerLink::createDataChannel ( const std::string & label )

◆ createOffer()

rtc::Description PeerLink::createOffer ( )

Definition at line 81 of file PeerLink.cpp.

{
    auto offer = pc->createOffer();
    rtc::LocalDescriptionInit init;
    init.icePwd = offer.icePwd();     // string
    init.iceUfrag = offer.iceUfrag(); // string
    pc->setLocalDescription(offer.type(), init);
    return offer;
}

◆ displayName()

const std::string & PeerLink::displayName ( ) const

Definition at line 31 of file PeerLink.cpp.

{
    return displayName_;
}

◆ getPeerConnection()

std::shared_ptr< rtc::PeerConnection > PeerLink::getPeerConnection ( )

inline

Definition at line 75 of file PeerLink.h.

    {
        return pc;
    }

◆ isClosedOrFailed()

bool PeerLink::isClosedOrFailed ( ) const

Definition at line 402 of file PeerLink.cpp.

{
    if (!pc)
        return true;
    auto s = pc->state();
    return s == rtc::PeerConnection::State::Closed ||
           s == rtc::PeerConnection::State::Failed;
}

◆ isConnected()

bool PeerLink::isConnected ( ) const

Definition at line 288 of file PeerLink.cpp.

{
    // â€œusableâ€ = PC connected AND at least Game channel open
    auto it = dcs_.find(std::string(msg::dc::name::Game));
    return isPcConnectedOnly() && it != dcs_.end() && it->second && it->second->isOpen();
}

Here is the call graph for this function:

◆ isDataChannelOpen()

bool PeerLink::isDataChannelOpen ( ) const

Definition at line 295 of file PeerLink.cpp.

{
    for (auto& [label, ch] : dcs_)
    {
        if (ch && ch->isOpen())
            return true;
    }
    return false;
}

◆ isPcConnectedOnly()

bool PeerLink::isPcConnectedOnly ( ) const

Definition at line 305 of file PeerLink.cpp.

{
    return pc && pc->state() == rtc::PeerConnection::State::Connected;
}

Here is the caller graph for this function:

◆ markBootstrapReset()

void PeerLink::markBootstrapReset ( )

inline

Definition at line 70 of file PeerLink.h.

    {
        bootstrapSent_ = false;
    }

◆ markBootstrapSent()

void PeerLink::markBootstrapSent ( )

inline

Definition at line 66 of file PeerLink.h.

    {
        bootstrapSent_ = true;
    }

◆ pcState()

rtc::PeerConnection::State PeerLink::pcState ( ) const

Definition at line 395 of file PeerLink.cpp.

{
    if (!pc)
        return rtc::PeerConnection::State::Closed;
    return pc->state();
}

Here is the caller graph for this function:

◆ pcStateString()

const char * PeerLink::pcStateString ( ) const

Definition at line 411 of file PeerLink.cpp.

{
    auto s = pcState();
    using S = rtc::PeerConnection::State;
    switch (s)
    {
        case S::New:
            return "New";
        case S::Connecting:
            return "Connecting";
        case S::Connected:
            return "Connected";
        case S::Disconnected:
            return "Disconnected";
        case S::Failed:
            return "Failed";
        case S::Closed:
            return "Closed";
    }
    return "Unknown";
}

Here is the call graph for this function:

◆ pcStateToStr()

const char * PeerLink::pcStateToStr ( rtc::PeerConnection::State s )

◆ send()

void PeerLink::send ( const std::string & msg )

◆ sendChat()

bool PeerLink::sendChat ( const std::vector< uint8_t > & bytes )

Definition at line 216 of file PeerLink.cpp.

{
    return sendOn(std::string(msg::dc::name::Chat), bytes);
}

Here is the call graph for this function:

◆ sendChatJson()

void PeerLink::sendChatJson ( const std::string & jsonText )

Definition at line 230 of file PeerLink.cpp.

{
    sendOn(msg::dc::name::Chat, jsonText);
}

Here is the call graph for this function:

◆ sendGame()

bool PeerLink::sendGame ( const std::vector< uint8_t > & bytes )

Definition at line 211 of file PeerLink.cpp.

{
    return sendOn(std::string(msg::dc::name::Game), bytes);
}

Here is the call graph for this function:

◆ sendMarkerMove()

bool PeerLink::sendMarkerMove ( const std::vector< uint8_t > & bytes )

Definition at line 226 of file PeerLink.cpp.

{
    return sendOn(std::string(msg::dc::name::MarkerMove), bytes);
}

Here is the call graph for this function:

◆ sendNote()

bool PeerLink::sendNote ( const std::vector< uint8_t > & bytes )

Definition at line 221 of file PeerLink.cpp.

{
    return sendOn(std::string(msg::dc::name::Notes), bytes);
}

Here is the call graph for this function:

◆ sendOn() [1/2]

bool PeerLink::sendOn	(	const std::string &	label,
		const std::vector< uint8_t > &	bytes )

Definition at line 187 of file PeerLink.cpp.

{
    auto it = dcs_.find(label);
    if (it == dcs_.end() || !it->second)
        return false;
    auto& ch = it->second;
    if (!ch->isOpen())
        return false;
 
    //if (ch->bufferedAmount() > kMaxBufferedBytes)
    //{
    //    // You can queue locally instead of dropping, if you want
    //    return false;
    //}
    rtc::binary b;
    b.resize(bytes.size());
    if (!bytes.empty())
    {
        std::memcpy(b.data(), bytes.data(), bytes.size()); // std::byte is trivially copyable
    }
    ch->send(b); // libdatachannel handles SCTP fragmentation
    return true;
}

Here is the caller graph for this function:

◆ sendOn() [2/2]

bool PeerLink::sendOn	(	const std::string &	label,
		std::string_view	text )

Definition at line 171 of file PeerLink.cpp.

{
    auto it = dcs_.find(label);
    if (it == dcs_.end() || !it->second)
        return false;
    auto& ch = it->second;
    if (!ch->isOpen())
        return false;
 
    // optional backpressure guard
    // if (ch->bufferedAmount() > kMaxBufferedBytes) return false;
 
    ch->send(std::string(text)); // TEXT frame over DC
    return true;
}

◆ setDisplayName()

void PeerLink::setDisplayName ( std::string n )

Definition at line 26 of file PeerLink.cpp.

{
    displayName_ = std::move(n);
}

◆ setOpen()

void PeerLink::setOpen	(	std::string	label,
		bool	open )

inline

Definition at line 56 of file PeerLink.h.

    {
        dcOpen_[label] = open;
    }

◆ setRemoteDescription()

void PeerLink::setRemoteDescription ( const rtc::Description & desc )

Definition at line 101 of file PeerLink.cpp.

{
    pc->setRemoteDescription(desc);
    {
        std::lock_guard<std::mutex> lk(candMx_);
        remoteDescSet_.store(true, std::memory_order_release);
        for (auto& c : pendingRemoteCandidates_)
        {
            pc->addRemoteCandidate(c);
        }
        pendingRemoteCandidates_.clear();
    }
}

◆ setupCallbacks()

void PeerLink::setupCallbacks ( )

private

Definition at line 128 of file PeerLink.cpp.

{
    pc->onStateChange([this](rtc::PeerConnection::State s)
                      {
        lastState_ = s;
        lastStateAt_ = std::chrono::seconds().count();
        std::cout << "[PeerLink] State(" << peerId << "): " << (int)s << "at " << lastStateAt_ << "\n";
 
        if (s == rtc::PeerConnection::State::Closed || s == rtc::PeerConnection::State::Failed) {
            if (auto nm = network_manager.lock()) {
                msg::NetEvent ev{msg::NetEvent::Type::PcClosed, peerId, "PC"};
                nm->events_.push(std::move(ev));
            } 
        }
        if (s == rtc::PeerConnection::State::Connected) {
            if (auto nm = network_manager.lock()) {
                msg::NetEvent ev{msg::NetEvent::Type::PcOpen, peerId, "PC"};
                nm->events_.push(std::move(ev));
            } 
        } });
 
    pc->onLocalDescription([wk = network_manager, id = peerId](rtc::Description desc)
                           {
        if (auto nm = wk.lock()) nm->onPeerLocalDescription(id, desc); });
 
    pc->onLocalCandidate([wk = network_manager, id = peerId](rtc::Candidate cand)
                         {
        if (auto nm = wk.lock()) nm->onPeerLocalCandidate(id, cand); });
 
    pc->onDataChannel([this](std::shared_ptr<rtc::DataChannel> ch)
                      {
        const std::string label = ch->label();
        dcs_[label] = ch;
        attachChannelHandlers(ch, label);
        std::cout << "[PeerLink] Received DC \"" << label << "\" from " << peerId << "\n"; });
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ bootstrapSent_

bool PeerLink::bootstrapSent_ = false

private

Definition at line 96 of file PeerLink.h.

◆ candMx_

std::mutex PeerLink::candMx_

private

Definition at line 94 of file PeerLink.h.

◆ closing_

std::atomic<bool> PeerLink::closing_ {false}

private

Definition at line 86 of file PeerLink.h.

86{false};

◆ dcOpen_

std::unordered_map<std::string, bool> PeerLink::dcOpen_

private

Definition at line 97 of file PeerLink.h.

◆ dcs_

std::unordered_map<std::string, std::shared_ptr<rtc::DataChannel> > PeerLink::dcs_

private

Definition at line 85 of file PeerLink.h.

◆ displayName_

std::string PeerLink::displayName_

private

Definition at line 82 of file PeerLink.h.

◆ lastState_

std::atomic<rtc::PeerConnection::State> PeerLink::lastState_ {rtc::PeerConnection::State::New}

private

Definition at line 89 of file PeerLink.h.

89{rtc::PeerConnection::State::New};

◆ lastStateAt_

std::atomic<double> PeerLink::lastStateAt_ {0.0}

private

Definition at line 90 of file PeerLink.h.

90{0.0};

◆ network_manager

std::weak_ptr<NetworkManager> PeerLink::network_manager

private

Definition at line 87 of file PeerLink.h.

◆ pc

std::shared_ptr<rtc::PeerConnection> PeerLink::pc

private

Definition at line 83 of file PeerLink.h.

◆ peerId

std::string PeerLink::peerId

private

Definition at line 81 of file PeerLink.h.

◆ pendingRemoteCandidates_

std::vector<rtc::Candidate> PeerLink::pendingRemoteCandidates_

private

Definition at line 93 of file PeerLink.h.

◆ remoteDescSet_

std::atomic<bool> PeerLink::remoteDescSet_ {false}

private

Definition at line 92 of file PeerLink.h.

92{false};

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

include/network/PeerLink.h
src/network/PeerLink.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PeerLink() [1/2]

◆ PeerLink() [2/2]

Member Function Documentation

◆ addIceCandidate()

◆ allRequiredOpen()

◆ attachChannelHandlers()

◆ attachMarkerMoveChannelHandlers()

◆ bootstrapSent()

◆ close()

◆ createAnswer()

◆ createChannels()

◆ createDataChannel()

◆ createOffer()

◆ displayName()

◆ getPeerConnection()

◆ isClosedOrFailed()

◆ isConnected()

◆ isDataChannelOpen()

◆ isPcConnectedOnly()

◆ markBootstrapReset()

◆ markBootstrapSent()

◆ pcState()

◆ pcStateString()

◆ pcStateToStr()

◆ send()

◆ sendChat()

◆ sendChatJson()

◆ sendGame()

◆ sendMarkerMove()

◆ sendNote()

◆ sendOn() [1/2]

◆ sendOn() [2/2]

◆ setDisplayName()

◆ setOpen()

◆ setRemoteDescription()

◆ setupCallbacks()

Member Data Documentation

◆ bootstrapSent_

◆ candMx_

◆ closing_

◆ dcOpen_

◆ dcs_

◆ displayName_

◆ lastState_

◆ lastStateAt_

◆ network_manager

◆ pc

◆ peerId

◆ pendingRemoteCandidates_

◆ remoteDescSet_