#include <C4Network2IO.h>

Inheritance diagram for C4Network2IO:

Collaboration diagram for C4Network2IO:

Classes
struct	AutoAccept

struct	NetEvPacketData

Public Member Functions
	C4Network2IO ()

	~C4Network2IO () override

bool	hasTCP () const

bool	hasUDP () const

bool	Init (int16_t iPortTCP, int16_t iPortUDP, int16_t iPortDiscovery=-1, int16_t iPortRefServer=-1, bool fBroadcast=false, bool enable_upnp=true)

void	Clear ()

void	SetLocalCCore (const C4ClientCore &CCore)

C4NetIO *	MsgIO ()

C4NetIO *	DataIO ()

bool	Connect (const C4NetIO::addr_t &addr, C4Network2IOProtocol eProt, const C4ClientCore &nCCore, const char *szPassword=nullptr)

bool	ConnectWithSocket (const C4NetIO::addr_t &addr, C4Network2IOProtocol eProt, const C4ClientCore &nCCore, std::unique_ptr< C4NetIOTCP::Socket > socket, const char *szPassword=nullptr)

void	SetAcceptMode (bool fAcceptAll)

void	SetExclusiveConnMode (bool fExclusiveConn)

int	getConnectionCount ()

void	ClearAutoAccept ()

void	AddAutoAccept (const C4ClientCore &CCore)

void	RemoveAutoAccept (const C4ClientCore &CCore)

C4Network2IOConnection *	GetMsgConnection (int iClientID)

C4Network2IOConnection *	GetDataConnection (int iClientID)

void	BeginBroadcast (bool fSelectAll=false)

void	EndBroadcast ()

bool	Broadcast (const C4NetIOPacket &rPkt)

bool	SendMsgToClient (C4NetIOPacket &rPkt, int iClient)

bool	BroadcastMsg (const C4NetIOPacket &rPkt)

bool	InitPuncher (C4NetIO::addr_t PuncherAddr)

void	SendPuncherPacket (const C4NetpuncherPacket &, C4NetIO::HostAddress::AddressFamily family)

void	Punch (const C4NetIO::addr_t &)

C4NetIO *	getNetIO (C4Network2IOProtocol eProt)

const char *	getNetIOName (C4NetIO *pNetIO)

C4Network2IOProtocol	getNetIOProt (C4NetIO *pNetIO)

int	getProtIRate (C4Network2IOProtocol eProt) const

int	getProtORate (C4Network2IOProtocol eProt) const

int	getProtBCRate (C4Network2IOProtocol eProt) const

void	SetReference (class C4Network2Reference *pReference)

bool	IsReferenceNeeded ()

Protected Member Functions
bool	IsPuncherAddr (const C4NetIO::addr_t &addr) const

bool	OnConn (const C4NetIO::addr_t &addr, const C4NetIO::addr_t &AddrConnect, const C4NetIO::addr_t pOwnAddr, C4NetIO pNetIO) override

void	OnDisconn (const C4NetIO::addr_t &addr, C4NetIO pNetIO, const char szReason) override

void	OnPacket (const C4NetIOPacket &rPacket, C4NetIO *pNetIO) override

virtual void	OnError (const char strError, C4NetIO pNetIO)

bool	Execute (int iTimeout, pollfd *) override

C4TimeMilliseconds	GetNextTick (C4TimeMilliseconds tNow) override

void	OnThreadEvent (C4InteractiveEventType eEvent, void *pEventData) override

void	AddConnection (C4Network2IOConnection *pConn)

void	RemoveConnection (C4Network2IOConnection *pConn)

C4Network2IOConnection *	GetConnection (const C4NetIO::addr_t &addr, C4NetIO *pNetIO)

C4Network2IOConnection *	GetConnectionByConnAddr (const C4NetIO::addr_t &addr, C4NetIO *pNetIO)

C4Network2IOConnection *	GetConnectionByID (uint32_t iConnID)

bool	doAutoAccept (const C4ClientCore &CCore, const C4Network2IOConnection &Conn)

bool	HandlePacket (const C4NetIOPacket &rPacket, C4Network2IOConnection *pConn, bool fThread)

void	CallHandlers (int iHandlers, const class C4IDPacket pPacket, C4Network2IOConnection pConn, bool fThread)

void	HandlePacket (char cStatus, const C4PacketBase pPacket, C4Network2IOConnection pConn)

void	HandleFwdReq (const class C4PacketFwd &rFwd, C4Network2IOConnection *pBy)

void	HandlePuncherPacket (const C4NetIOPacket &rPacket)

bool	Ping ()

void	CheckTimeout ()

void	GenerateStatistics (int iInterval)

void	SendConnPackets ()

virtual void	OnPacket (const class C4NetIOPacket &rPacket, C4NetIO *pNetIO)=0

void	Changed ()

bool	ExecuteUntil (int iTimeout=-1)

virtual void	GetFDs (std::vector< struct pollfd > &)

bool	IsSignaled ()

virtual bool	IsLowPriority ()

virtual bool	IsNotify ()

virtual uint32_t	TimerInterval ()

Protected Attributes
C4NetIO *	pNetIO_TCP {nullptr}

C4NetIO *	pNetIO_UDP {nullptr}

class C4Network2IODiscover *	pNetIODiscover {nullptr}

class C4Network2RefServer *	pRefServer {nullptr}

class C4Network2UPnP *	UPnPMgr {nullptr}

C4ClientCore	LCCore

CStdCSec	LCCoreCSec

C4Network2IOConnection *	pConnList {nullptr}

CStdCSec	ConnListCSec

CStdCSec	BroadcastCSec

uint32_t	iNextConnID {0}

bool	fAllowConnect {false}

struct C4Network2IO::AutoAccept	nullptr

CStdCSec	AutoAcceptCSec

bool	fExclusiveConn {false}

C4TimeMilliseconds	tLastExecute

C4TimeMilliseconds	tLastPing

C4TimeMilliseconds	tLastStatistic

int	iTCPIRate {0}

int	iTCPORate {0}

int	iTCPBCRate {0}

int	iUDPIRate {0}

int	iUDPORate {0}

int	iUDPBCRate {0}

C4NetIO::addr_t	PuncherAddrIPv4

C4NetIO::addr_t	PuncherAddrIPv6

Detailed Description

Definition at line 43 of file C4Network2IO.h.

Class Documentation

◆ C4Network2IO::AutoAccept

struct C4Network2IO::AutoAccept

Definition at line 81 of file C4Network2IO.h.

Collaboration diagram for C4Network2IO::AutoAccept:

[legend]

Class Members
C4ClientCore	CCore
AutoAccept *	Next

◆ C4Network2IO::NetEvPacketData

struct C4Network2IO::NetEvPacketData

Definition at line 32 of file C4Network2IO.cpp.

Collaboration diagram for C4Network2IO::NetEvPacketData:

[legend]

Class Members
C4Network2IOConnection *	Conn
C4NetIOPacket	Packet

Constructor & Destructor Documentation

◆ C4Network2IO()

C4Network2IO::C4Network2IO ( )

Definition at line 43 of file C4Network2IO.cpp.

         : tLastExecute(0), tLastPing(0), tLastStatistic(0) 
 {
 }

◆ ~C4Network2IO()

C4Network2IO::~C4Network2IO ( )

override

Definition at line 48 of file C4Network2IO.cpp.

 {
     Clear();
 }

References Clear().

Here is the call graph for this function:

Member Function Documentation

◆ AddAutoAccept()

void C4Network2IO::AddAutoAccept ( const C4ClientCore & CCore )

Definition at line 320 of file C4Network2IO.cpp.

 {
     CStdLock AALock(&AutoAcceptCSec);
     // create
     AutoAccept *pAcc = new AutoAccept();
     pAcc->CCore = CCore;
     // add
     pAcc->Next = pAutoAcceptList;
     pAutoAcceptList = pAcc;
 }

References AutoAcceptCSec, C4Network2IO::AutoAccept::CCore, and C4Network2IO::AutoAccept::Next.

Referenced by C4Network2ClientList::RegClient().

Here is the caller graph for this function:

◆ AddConnection()

void C4Network2IO::AddConnection ( C4Network2IOConnection * pConn )

protected

Definition at line 738 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     // add reference
     pConn->AddRef();
     // add to list
     pConn->pNext = pConnList; pConnList = pConn;
 }

References C4Network2IOConnection::AddRef(), ConnListCSec, pConnList, and C4Network2IOConnection::pNext.

Referenced by ConnectWithSocket(), and OnConn().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginBroadcast()

void C4Network2IO::BeginBroadcast ( bool fSelectAll = false )

Definition at line 382 of file C4Network2IO.cpp.

 {
     // lock
     BroadcastCSec.Enter();
     // reset all broadcast flags
     CStdLock ConnListLock(&ConnListCSec);
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isOpen())
             pConn->SetBroadcastTarget(fSelectAll);
 }

References BroadcastCSec, ConnListCSec, CStdCSec::Enter(), pConnList, and C4Network2IOConnection::pNext.

Referenced by BroadcastMsg(), C4Network2ClientList::BroadcastMsgToClients(), C4Network2ClientList::BroadcastMsgToConnClients(), and HandleFwdReq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Broadcast()

bool C4Network2IO::Broadcast ( const C4NetIOPacket & rPkt )

Definition at line 399 of file C4Network2IO.cpp.

 {
     bool fSuccess = true;
     // There is no broadcasting atm, emulate it
     CStdLock ConnListLock(&ConnListCSec);
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isOpen() && pConn->isBroadcastTarget())
             fSuccess &= pConn->Send(rPkt);
     if(!fSuccess)
         Log("Network: Warning! Broadcast failed.");
     return fSuccess;
 }

References ConnListCSec, Log(), pConnList, and C4Network2IOConnection::pNext.

Referenced by BroadcastMsg(), C4Network2ClientList::BroadcastMsgToClients(), C4Network2ClientList::BroadcastMsgToConnClients(), and HandleFwdReq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BroadcastMsg()

bool C4Network2IO::BroadcastMsg ( const C4NetIOPacket & rPkt )

Definition at line 423 of file C4Network2IO.cpp.

 {
     // TODO: ugly algorithm. do better
  
     // begin broadcast
     BeginBroadcast(false);
     // select one connection per reachable client
     CStdLock ConnListLock(&ConnListCSec);
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isAccepted())
         {
             if (pConn->getProtocol() == P_UDP)
                 pConn->SetBroadcastTarget(true);
             else if (pConn->getProtocol() == P_TCP)
             {
                 C4Network2IOConnection *pConn2 = GetMsgConnection(pConn->getClientID());
                 if (pConn == pConn2)
                     pConn->SetBroadcastTarget(true);
                 pConn2->DelRef();
             }
         }
     // send
     bool fSuccess = Broadcast(rPkt);
     // end broadcast
     EndBroadcast();
     // return
     return fSuccess;
 }

References BeginBroadcast(), Broadcast(), ConnListCSec, C4Network2IOConnection::DelRef(), EndBroadcast(), GetMsgConnection(), P_TCP, P_UDP, pConnList, and C4Network2IOConnection::pNext.

Referenced by C4Network2Res::FinishDerive(), C4Network2ResList::SendDiscover(), and C4Network2Res::SendStatus().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallHandlers()

void C4Network2IO::CallHandlers	(	int	iHandlers,
		const class C4IDPacket *	pPacket,
		C4Network2IOConnection *	pConn,
		bool	fThread
	)

protected

Definition at line 931 of file C4Network2IO.cpp.

 {
     // emulate old callbacks
     char cStatus = pPkt->getPktType();
     const C4PacketBase *pPacket = pPkt->getPkt();
     // this class (network thread)
     if (iHandlerID & PH_C4Network2IO)
     {
         assert(fThread);
         HandlePacket(cStatus, pPacket, pConn);
     }
     // main network class (main thread)
     if (iHandlerID & PH_C4Network2)
     {
         assert(!fThread);
         ::Network.HandlePacket(cStatus, pPacket, pConn);
     }
     // fullscreen lobby
     if (iHandlerID & PH_C4GUIMainDlg)
     {
         assert(!fThread);
         ::Network.HandleLobbyPacket(cStatus, pPacket, pConn);
     }
     // client list class (main thread)
     if (iHandlerID & PH_C4Network2ClientList)
     {
         assert(!fThread);
         ::Network.Clients.HandlePacket(cStatus, pPacket, pConn);
     }
     // player list class (main thread)
     if (iHandlerID & PH_C4Network2Players)
     {
         assert(!fThread);
         ::Network.Players.HandlePacket(cStatus, pPacket, pConn);
     }
     // resource list class (network thread)
     if (iHandlerID & PH_C4Network2ResList)
     {
         assert(fThread);
         ::Network.ResList.HandlePacket(cStatus, pPacket, pConn);
     }
     // network control (mixed)
     if (iHandlerID & PH_C4GameControlNetwork)
     {
         ::Control.Network.HandlePacket(cStatus, pPacket, pConn);
     }
 }

References C4Network2::Clients, Control, C4IDPacket::getPkt(), C4IDPacket::getPktType(), C4Network2::HandleLobbyPacket(), C4Network2::HandlePacket(), C4Network2ClientList::HandlePacket(), C4GameControlNetwork::HandlePacket(), C4Network2ResList::HandlePacket(), C4Network2Players::HandlePacket(), HandlePacket(), Network, C4GameControl::Network, PH_C4GameControlNetwork, PH_C4GUIMainDlg, PH_C4Network2, PH_C4Network2ClientList, PH_C4Network2IO, PH_C4Network2Players, PH_C4Network2ResList, C4Network2::Players, and C4Network2::ResList.

Referenced by HandlePacket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Changed()

void StdSchedulerProc::Changed ( )

protectedinherited

Definition at line 108 of file StdScheduler.cpp.

 {
     auto s = scheduler;
     if (s)
         s->Changed(this);
 }

References s.

Referenced by C4NetIOTCP::Accept(), C4NetIOTCP::AddConnectWait(), C4NetIOUDP::AddPeer(), C4NetIOTCP::Listen(), and CStdTimerProc::SetDelay().

Here is the caller graph for this function:

◆ CheckTimeout()

void C4Network2IO::CheckTimeout ( )

protected

Definition at line 1186 of file C4Network2IO.cpp.

 {
     // acquire lock
     CStdLock ConnListLock(&ConnListCSec);
     // check all connections for timeout (use deletion-safe iteration method just in case)
     for (C4Network2IOConnection *pConn = pConnList, *pNext; pConn; pConn = pNext)
     {
         pNext = pConn->pNext;
         // status timeout
         if (!pConn->isClosed() && !pConn->isAccepted())
             if (difftime(time(nullptr), pConn->getTimestamp()) > C4NetAcceptTimeout)
             {
                 Application.InteractiveThread.ThreadLogS("Network: connection accept timeout to %s", pConn->getPeerAddr().ToString().getData());
                 pConn->Close();
             }
         // ping timeout
         if (pConn->isAccepted())
             if ((pConn->getLag() != -1 ? pConn->getLag() : 1000 * difftime(time(nullptr), pConn->getTimestamp()))
                 > C4NetPingTimeout)
             {
                 Application.InteractiveThread.ThreadLogS("%d %d %d", (int)pConn->getLag(), (int)time(nullptr), (int)pConn->getTimestamp());
                 Application.InteractiveThread.ThreadLogS("Network: ping timeout to %s", pConn->getPeerAddr().ToString().getData());
                 pConn->Close();
             }
         // delayed connection removal
         if (pConn->isClosed())
             if (difftime(time(nullptr), pConn->getTimestamp()) > C4NetAcceptTimeout)
                 RemoveConnection(pConn);
     }
 }

References Application, C4NetAcceptTimeout, C4NetPingTimeout, ConnListCSec, C4Application::InteractiveThread, pConnList, RemoveConnection(), and C4InteractiveThread::ThreadLogS().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clear()

void C4Network2IO::Clear ( )

Definition at line 177 of file C4Network2IO.cpp.

 {
     // process remaining events
     C4InteractiveThread &Thread = Application.InteractiveThread;
     Thread.ProcessEvents();
     // clear event callbacks
     Thread.ClearCallback(Ev_Net_Conn, this);
     Thread.ClearCallback(Ev_Net_Disconn, this);
     Thread.ClearCallback(Ev_Net_Packet, this);
     // close all connections
     CStdLock ConnListLock(&ConnListCSec);
     for (C4Network2IOConnection *pConn = pConnList, *pNext; pConn; pConn = pNext)
     {
         pNext = pConn->pNext;
         // close
         pConn->Close();
         RemoveConnection(pConn);
     }
     // reset list
     pConnList = nullptr;
     ConnListLock.Clear();
     // close net i/o classes
     Thread.RemoveProc(this);
     if (pNetIODiscover) { Thread.RemoveProc(pNetIODiscover); delete pNetIODiscover; pNetIODiscover = nullptr; }
     if (pNetIO_TCP) { Thread.RemoveProc(pNetIO_TCP); delete pNetIO_TCP; pNetIO_TCP = nullptr; }
     if (pNetIO_UDP) { Thread.RemoveProc(pNetIO_UDP); delete pNetIO_UDP; pNetIO_UDP = nullptr; }
     if (pRefServer) { Thread.RemoveProc(pRefServer); delete pRefServer; pRefServer = nullptr; }
     if (UPnPMgr) { delete UPnPMgr; UPnPMgr = nullptr; }
     // remove auto-accepts
     ClearAutoAccept();
     // reset flags
     fAllowConnect = fExclusiveConn = false;
     // reset connection ID
     iNextConnID = 0;
 }

References Application, CStdLock::Clear(), ClearAutoAccept(), C4InteractiveThread::ClearCallback(), ConnListCSec, Ev_Net_Conn, Ev_Net_Disconn, Ev_Net_Packet, fAllowConnect, fExclusiveConn, iNextConnID, C4Application::InteractiveThread, pConnList, pNetIO_TCP, pNetIO_UDP, pNetIODiscover, pRefServer, C4InteractiveThread::ProcessEvents(), RemoveConnection(), C4InteractiveThread::RemoveProc(), and UPnPMgr.

Referenced by C4Network2::Clear(), Init(), C4Network2::InitNetIO(), and ~C4Network2IO().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearAutoAccept()

void C4Network2IO::ClearAutoAccept ( )

Definition at line 306 of file C4Network2IO.cpp.

 {
     CStdLock AALock(&AutoAcceptCSec);
     // delete
     while (pAutoAcceptList)
     {
         // remove
         AutoAccept *pAcc = pAutoAcceptList;
         pAutoAcceptList = pAcc->Next;
         // delete
         delete pAcc;
     }
 }

References AutoAcceptCSec, and C4Network2IO::AutoAccept::Next.

Referenced by Clear().

Here is the caller graph for this function:

◆ Connect()

bool C4Network2IO::Connect	(	const C4NetIO::addr_t &	addr,
		C4Network2IOProtocol	eProt,
		const C4ClientCore &	nCCore,
		const char *	szPassword = `nullptr`
	)

Definition at line 233 of file C4Network2IO.cpp.

 {
     return ConnectWithSocket(addr, eProt, nCCore, nullptr, szPassword);
 }

References ConnectWithSocket().

Referenced by C4Network2Client::DoConnectAttempt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConnectWithSocket()

bool C4Network2IO::ConnectWithSocket	(	const C4NetIO::addr_t &	addr,
		C4Network2IOProtocol	eProt,
		const C4ClientCore &	nCCore,
		std::unique_ptr< C4NetIOTCP::Socket >	socket,
		const char *	szPassword = `nullptr`
	)

Definition at line 239 of file C4Network2IO.cpp.

 {
     // get network class
     C4NetIO *pNetIO = getNetIO(eProt);
     if (!pNetIO) return false;
     // already connected/connecting?
     if (GetConnectionByConnAddr(addr, pNetIO)) return true;
     // assign new connection ID, peer address isn't known yet
     uint32_t iConnID = iNextConnID++;
     C4NetIO::addr_t paddr;
     // create connection object and add to list
     C4Network2IOConnection *pConn = new C4Network2IOConnection();
     pConn->Set(pNetIO, eProt, paddr, addr, CS_Connect, szPassword, iConnID);
     pConn->SetCCore(nCCore);
     if (socket)
         pConn->SetSocket(std::move(socket));
     AddConnection(pConn);
     // connect
     if (!pConn->Connect())
     {
         // show error
         LogSilentF("Network: could not connect to %s using %s: %s", addr.ToString().getData(),
              getNetIOName(pNetIO), pNetIO->GetError() ? pNetIO->GetError() : "");
         pNetIO->ResetError();
         // remove class
         RemoveConnection(pConn);
         return false;
     }
     // ok, wait for connection
     return true;
 }

References AddConnection(), C4Network2IOConnection::Connect(), CS_Connect, GetConnectionByConnAddr(), StdStrBuf::getData(), C4NetIO::GetError(), getNetIO(), getNetIOName(), iNextConnID, LogSilentF(), RemoveConnection(), C4NetIO::ResetError(), C4Network2IOConnection::Set(), C4Network2IOConnection::SetCCore(), C4Network2IOConnection::SetSocket(), and C4NetIO::EndpointAddress::ToString().

Referenced by Connect(), and C4Network2Client::DoTCPSimultaneousOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DataIO()

C4NetIO * C4Network2IO::DataIO ( )

Definition at line 226 of file C4Network2IO.cpp.

 {
     if (pNetIO_TCP) return pNetIO_TCP;
     if (pNetIO_UDP) return pNetIO_UDP;
     return nullptr;
 }

References pNetIO_TCP, and pNetIO_UDP.

Referenced by C4Network2::DrawStatus(), and C4Network2::HandleConnRe().

Here is the caller graph for this function:

◆ doAutoAccept()

bool C4Network2IO::doAutoAccept	(	const C4ClientCore &	CCore,
		const C4Network2IOConnection &	Conn
	)

protected

Definition at line 811 of file C4Network2IO.cpp.

 {
     CStdLock AALock(&AutoAcceptCSec);
     // check if connection with the given client should be allowed
     for (AutoAccept *pAcc = pAutoAcceptList; pAcc; pAcc = pAcc->Next)
         // core match?
         if (CCore.getDiffLevel(pAcc->CCore) <= C4ClientCoreDL_IDMatch)
         {
             // check: already got another connection for this client? Peer IP must match, then.
             for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
                 if (pConn->isAccepted() &&
                     pConn->getCCore().getDiffLevel(CCore) <= C4ClientCoreDL_IDMatch &&
                     pConn->getPeerAddr().GetHost() != Conn.getPeerAddr().GetHost())
                     return false;
             // not found or IP matches? Let pass
             return true;
         }
     return false;
 }

References AutoAcceptCSec, C4ClientCoreDL_IDMatch, C4ClientCore::getDiffLevel(), C4NetIO::EndpointAddress::GetHost(), C4Network2IOConnection::getPeerAddr(), C4Network2IO::AutoAccept::Next, pConnList, and C4Network2IOConnection::pNext.

Referenced by HandlePacket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndBroadcast()

void C4Network2IO::EndBroadcast ( )

Definition at line 393 of file C4Network2IO.cpp.

 {
     // unlock
     BroadcastCSec.Leave();
 }

References BroadcastCSec, and CStdCSec::Leave().

Referenced by BroadcastMsg(), C4Network2ClientList::BroadcastMsgToClients(), C4Network2ClientList::BroadcastMsgToConnClients(), and HandleFwdReq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Execute()

bool C4Network2IO::Execute	(	int	iTimeout,
		pollfd *
	)

overrideprotectedvirtual

Implements StdSchedulerProc.

Definition at line 637 of file C4Network2IO.cpp.

 {
     tLastExecute = C4TimeMilliseconds::Now();
  
     // check for timeout
     CheckTimeout();
  
     // ping all open connections
     if (!Inside(tLastPing, tLastExecute - C4NetPingFreq, tLastExecute))
     {
         Ping();
         tLastPing = tLastExecute;
     }
  
     // do statistics
     if (!Inside(tLastStatistic, tLastExecute - C4NetStatisticsFreq, tLastExecute))
     {
         GenerateStatistics(tLastExecute - tLastStatistic);
         tLastStatistic = tLastExecute;
     }
  
     // resources
     ::Network.ResList.OnTimer();
  
     // ok
     return true;
 }

References C4NetPingFreq, C4NetStatisticsFreq, CheckTimeout(), GenerateStatistics(), Inside(), Network, C4TimeMilliseconds::Now(), C4Network2ResList::OnTimer(), Ping(), C4Network2::ResList, tLastExecute, tLastPing, and tLastStatistic.

Here is the call graph for this function:

◆ ExecuteUntil()

bool StdSchedulerProc::ExecuteUntil ( int iTimeout = -1 )

inherited

Definition at line 33 of file StdScheduler.cpp.

 {
     // Infinite?
     if (iTimeout < 0)
         for (;;)
             if (!Execute())
                 return false;
     // Calculate endpoint
     C4TimeMilliseconds tStopTime = C4TimeMilliseconds::Now() + iTimeout;
     for (;;)
     {
         // Call execute with given timeout
         if (!Execute(std::max(iTimeout, 0)))
             return false;
         // Calculate timeout
         C4TimeMilliseconds tTime = C4TimeMilliseconds::Now();
         if (tTime >= tStopTime)
             break;
         iTimeout = tStopTime - tTime;
     }
     // All ok.
     return true;
 }

References StdSchedulerProc::Execute(), and C4TimeMilliseconds::Now().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateStatistics()

void C4Network2IO::GenerateStatistics ( int iInterval )

protected

Definition at line 1217 of file C4Network2IO.cpp.

 {
     int iTCPIRateSum = 0, iTCPORateSum = 0, iUDPIRateSum = 0, iUDPORateSum = 0;
  
     // acquire lock, get connection statistics
     CStdLock ConnListLock(&ConnListCSec);
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isOpen())
         {
             bool fTCP = pConn->getNetClass() == pNetIO_TCP;
             pConn->DoStatistics(iInterval, fTCP ? &iTCPIRateSum : &iUDPIRateSum,
                                 fTCP ? &iTCPORateSum : &iUDPORateSum);
         }
     ConnListLock.Clear();
  
     // get broadcast statistics
     int inTCPBCRate = 0, inUDPBCRate = 0;
     if (pNetIO_TCP) pNetIO_TCP->GetStatistic(&inTCPBCRate);
     if (pNetIO_UDP) pNetIO_UDP->GetStatistic(&inUDPBCRate);
  
     // normalize everything
     iTCPIRateSum = iTCPIRateSum * 1000 / iInterval;
     iTCPORateSum = iTCPORateSum * 1000 / iInterval;
     iUDPIRateSum = iUDPIRateSum * 1000 / iInterval;
     iUDPORateSum = iUDPORateSum * 1000 / iInterval;
     inTCPBCRate = inTCPBCRate * 1000 / iInterval;
     inUDPBCRate = inUDPBCRate * 1000 / iInterval;
  
     // clear
     if (pNetIO_TCP) pNetIO_TCP->ClearStatistic();
     if (pNetIO_UDP) pNetIO_UDP->ClearStatistic();
  
     // save back
     iTCPIRate = iTCPIRateSum; iTCPORate = iTCPORateSum; iTCPBCRate = inTCPBCRate;
     iUDPIRate = iUDPIRateSum; iUDPORate = iUDPORateSum; iUDPBCRate = inUDPBCRate;
 }

References CStdLock::Clear(), C4NetIO::ClearStatistic(), ConnListCSec, C4NetIO::GetStatistic(), iTCPBCRate, iTCPIRate, iTCPORate, iUDPBCRate, iUDPIRate, iUDPORate, pConnList, pNetIO_TCP, pNetIO_UDP, and C4Network2IOConnection::pNext.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetConnection()

C4Network2IOConnection * C4Network2IO::GetConnection	(	const C4NetIO::addr_t &	addr,
		C4NetIO *	pNetIO
	)

protected

Definition at line 768 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     // search
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->getNetClass() == pNetIO && pConn->getPeerAddr() == addr)
             return pConn;
     return nullptr;
 }

References ConnListCSec, pConnList, and C4Network2IOConnection::pNext.

Referenced by OnDisconn(), and OnPacket().

Here is the caller graph for this function:

◆ GetConnectionByConnAddr()

C4Network2IOConnection * C4Network2IO::GetConnectionByConnAddr	(	const C4NetIO::addr_t &	addr,
		C4NetIO *	pNetIO
	)

protected

Definition at line 778 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     // search
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->getNetClass() == pNetIO && pConn->getConnectAddr() == addr)
             return pConn;
     return nullptr;
 }

References ConnListCSec, pConnList, and C4Network2IOConnection::pNext.

Referenced by ConnectWithSocket(), OnConn(), and OnDisconn().

Here is the caller graph for this function:

◆ GetConnectionByID()

C4Network2IOConnection * C4Network2IO::GetConnectionByID ( uint32_t iConnID )

protected

Definition at line 788 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     // search
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->getID() == iConnID)
             return pConn;
     return nullptr;
 }

References ConnListCSec, pConnList, and C4Network2IOConnection::pNext.

Referenced by HandlePacket().

Here is the caller graph for this function:

◆ getConnectionCount()

int C4Network2IO::getConnectionCount ( )

Definition at line 296 of file C4Network2IO.cpp.

 {
     int iCount = 0;
     CStdLock ConnListLock(&ConnListCSec);
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (!pConn->isClosed())
             iCount++;
     return iCount;
 }

References ConnListCSec, pConnList, and C4Network2IOConnection::pNext.

Referenced by C4Network2::OnDisconn().

Here is the caller graph for this function:

◆ GetDataConnection()

C4Network2IOConnection * C4Network2IO::GetDataConnection ( int iClientID )

Definition at line 368 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     C4Network2IOConnection *pRes = nullptr;
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isAccepted())
             if (pConn->getClientID() == iClientID)
                 if (pConn->getProtocol() == P_TCP || !pRes)
                     pRes = pConn;
     // add reference
     if (pRes) pRes->AddRef();
     return pRes;
 }

References C4Network2IOConnection::AddRef(), ConnListCSec, P_TCP, pConnList, and C4Network2IOConnection::pNext.

Referenced by C4Network2Res::SendChunk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetFDs()

virtual void StdSchedulerProc::GetFDs ( std::vector< struct pollfd > & )

inlinevirtualinherited

Reimplemented in C4FileMonitor, C4NetIOSimpleUDP, C4NetIOTCP, CStdNotifyProc, C4StdInProc, and C4HTTPClient.

Definition at line 72 of file StdScheduler.h.

72 { }

◆ GetMsgConnection()

C4Network2IOConnection * C4Network2IO::GetMsgConnection ( int iClientID )

Definition at line 354 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     C4Network2IOConnection *pRes = nullptr;
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isAccepted())
             if (pConn->getClientID() == iClientID)
                 if (pConn->getProtocol() == P_UDP || !pRes)
                     pRes = pConn;
     // add reference
     if (pRes) pRes->AddRef();
     return pRes;
 }

References C4Network2IOConnection::AddRef(), ConnListCSec, P_UDP, pConnList, and C4Network2IOConnection::pNext.

Referenced by BroadcastMsg(), HandleFwdReq(), SendMsgToClient(), and C4Network2Res::StartLoad().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getNetIO()

C4NetIO * C4Network2IO::getNetIO ( C4Network2IOProtocol eProt )

Definition at line 712 of file C4Network2IO.cpp.

 {
     switch (eProt)
     {
     case P_UDP: return pNetIO_UDP;
     case P_TCP: return pNetIO_TCP;
     default: return nullptr;
     }
 }

References P_TCP, P_UDP, pNetIO_TCP, and pNetIO_UDP.

Referenced by ConnectWithSocket(), C4Network2Client::DoConnectAttempt(), and C4Network2Client::DoTCPSimultaneousOpen().

Here is the caller graph for this function:

◆ getNetIOName()

const char * C4Network2IO::getNetIOName ( C4NetIO * pNetIO )

Definition at line 722 of file C4Network2IO.cpp.

 {
     if (!pNetIO) return "nullptr";
     if (pNetIO == pNetIO_TCP) return "TCP";
     if (pNetIO == pNetIO_UDP) return "UDP";
     return "UNKNOWN";
 }

References pNetIO_TCP, and pNetIO_UDP.

Referenced by ConnectWithSocket(), C4Network2::DrawStatus(), OnConn(), C4Network2::OnConnect(), C4Network2::OnConnectFail(), OnDisconn(), C4Network2::OnDisconnect(), OnError(), OnPacket(), and C4Network2ClientDlg::UpdateText().

Here is the caller graph for this function:

◆ getNetIOProt()

C4Network2IOProtocol C4Network2IO::getNetIOProt ( C4NetIO * pNetIO )

Definition at line 730 of file C4Network2IO.cpp.

 {
     if (!pNetIO) return P_NONE;
     if (pNetIO == pNetIO_TCP) return P_TCP;
     if (pNetIO == pNetIO_UDP) return P_UDP;
     return P_NONE;
 }

References P_NONE, P_TCP, P_UDP, pNetIO_TCP, and pNetIO_UDP.

Referenced by C4Network2::DrawStatus(), and OnConn().

Here is the caller graph for this function:

◆ GetNextTick()

C4TimeMilliseconds C4Network2IO::GetNextTick ( C4TimeMilliseconds tNow )

overrideprotectedvirtual

Reimplemented from StdSchedulerProc.

Definition at line 665 of file C4Network2IO.cpp.

 {
     return tLastExecute + C4NetTimer;
 }

References C4NetTimer, and tLastExecute.

◆ getProtBCRate()

int C4Network2IO::getProtBCRate ( C4Network2IOProtocol eProt ) const

inline

Definition at line 155 of file C4Network2IO.h.

155 { return eProt == P_TCP ? iTCPBCRate : iUDPBCRate; }

References iTCPBCRate, iUDPBCRate, and P_TCP.

Referenced by C4Network2::DrawStatus().

Here is the caller graph for this function:

◆ getProtIRate()

int C4Network2IO::getProtIRate ( C4Network2IOProtocol eProt ) const

inline

Definition at line 153 of file C4Network2IO.h.

153 { return eProt == P_TCP ? iTCPIRate : iUDPIRate; }

References iTCPIRate, iUDPIRate, and P_TCP.

Referenced by C4Network2::DrawStatus(), and C4Network2Stats::ExecuteSecond().

Here is the caller graph for this function:

◆ getProtORate()

int C4Network2IO::getProtORate ( C4Network2IOProtocol eProt ) const

inline

Definition at line 154 of file C4Network2IO.h.

154 { return eProt == P_TCP ? iTCPORate : iUDPORate; }

References iTCPORate, iUDPORate, and P_TCP.

Referenced by C4Network2::DrawStatus(), and C4Network2Stats::ExecuteSecond().

Here is the caller graph for this function:

◆ HandleFwdReq()

void C4Network2IO::HandleFwdReq	(	const class C4PacketFwd &	rFwd,
		C4Network2IOConnection *	pBy
	)

protected

Definition at line 1105 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     // init packet
     C4PacketFwd nFwd;
     nFwd.SetListType(false);
     // find all clients the message should be forwarded to
     int iClientID; C4Network2IOConnection *pConn;
     for (pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isAccepted())
             if ((iClientID = pConn->getClientID()) >= 0)
                 if (iClientID != pBy->getClientID())
                     if (rFwd.DoFwdTo(iClientID) && !nFwd.DoFwdTo(iClientID))
                         nFwd.AddClient(iClientID);
     // check count (hardcoded: broadcast for > 2 clients)
     if (nFwd.getClientCnt() <= 2)
     {
         C4NetIOPacket Pkt(rFwd.getData(), C4NetIO::addr_t());
         for (int i = 0; i < nFwd.getClientCnt(); i++)
             if ((pConn = GetMsgConnection(nFwd.getClient(i))))
             {
                 pConn->Send(Pkt);
                 pConn->DelRef();
             }
     }
     else
     {
         // Temporarily unlock connection list for getting broadcast lock
         // (might lead to deathlocks otherwise, as the lock is often taken
         //  in the opposite order)
         ConnListLock.Clear();
  
         BeginBroadcast();
         nFwd.SetData(rFwd.getData());
         // add all clients
         CStdLock ConnListLock(&ConnListCSec);
         for (int i = 0; i < nFwd.getClientCnt(); i++)
             if ((pConn = GetMsgConnection(nFwd.getClient(i))))
             {
                 pConn->SetBroadcastTarget(true);
                 pConn->DelRef();
             }
         // broadcast
         Broadcast(MkC4NetIOPacket(PID_Fwd, nFwd));
         EndBroadcast();
     }
     // doing a callback here; don't lock!
     ConnListLock.Clear();
     // forward to self?
     if (rFwd.DoFwdTo(LCCore.getID()))
     {
         C4NetIOPacket Packet(rFwd.getData(), pBy->getPeerAddr());
         HandlePacket(Packet, pBy, true);
     }
 }

References C4PacketFwd::AddClient(), BeginBroadcast(), Broadcast(), CStdLock::Clear(), ConnListCSec, C4Network2IOConnection::DelRef(), C4PacketFwd::DoFwdTo(), EndBroadcast(), C4PacketFwd::getClient(), C4PacketFwd::getClientCnt(), C4Network2IOConnection::getClientID(), C4PacketFwd::getData(), C4ClientCore::getID(), GetMsgConnection(), C4Network2IOConnection::getPeerAddr(), HandlePacket(), C4Network2IOConnection::isAccepted(), LCCore, MkC4NetIOPacket(), pConnList, PID_Fwd, C4Network2IOConnection::pNext, C4Network2IOConnection::Send(), C4Network2IOConnection::SetBroadcastTarget(), C4PacketFwd::SetData(), and C4PacketFwd::SetListType().

Referenced by HandlePacket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandlePacket() [1/2]

void C4Network2IO::HandlePacket	(	char	cStatus,
		const C4PacketBase *	pPacket,
		C4Network2IOConnection *	pConn
	)

protected

Definition at line 979 of file C4Network2IO.cpp.

 {
     // security
     if (!pConn) return;
  
 #define GETPKT(type, name) \
     assert(pPacket); const type &name = \
      static_cast<const type &>(*pPacket);
  
     switch (cStatus)
     {
  
     case PID_Conn: // connection request
     {
         if (!pConn->isOpen()) break;
         // get packet
         GETPKT(C4PacketConn, rPkt)
         // set connection ID
         pConn->SetRemoteID(rPkt.getConnID());
         // check auto-accept
         if (doAutoAccept(rPkt.getCCore(), *pConn))
         {
             // send answer back
             C4PacketConnRe pcr(true, false, "auto accept");
             if (!pConn->Send(MkC4NetIOPacket(PID_ConnRe, pcr)))
                 pConn->Close();
             // accept
             pConn->SetStatus(CS_HalfAccepted);
             pConn->SetCCore(rPkt.getCCore());
             pConn->SetAutoAccepted();
         }
         // note that this packet will get processed by C4Network2, too (main thread)
     }
     break;
  
     case PID_ConnRe: // connection request reply
     {
         if (!pConn->isOpen()) break;
         // conn not sent? That's fishy.
         // FIXME: Note this happens if the peer has exclusive connection mode on.
         if (!pConn->isConnSent())
         {
             pConn->Close();
             break;
         }
         // get packet
         GETPKT(C4PacketConnRe, rPkt)
         // auto accept connection
         if (rPkt.isOK())
         {
             if (pConn->isHalfAccepted() && pConn->isAutoAccepted())
                 pConn->SetAccepted();
         }
     }
     break;
  
     case PID_Ping:
     {
         if (!pConn->isOpen()) break;
         GETPKT(C4PacketPing, rPkt)
         // pong
         C4PacketPing PktPong = rPkt;
         pConn->Send(MkC4NetIOPacket(PID_Pong, PktPong));
         // remove received packets from log
         pConn->ClearPacketLog(rPkt.getPacketCounter());
     }
     break;
  
     case PID_Pong:
     {
         if (!pConn->isOpen()) break;
         GETPKT(C4PacketPing, rPkt);
         // save
         pConn->SetPingTime(rPkt.getTravelTime());
     }
     break;
  
     case PID_FwdReq:
     {
         GETPKT(C4PacketFwd, rPkt);
         HandleFwdReq(rPkt, pConn);
     }
     break;
  
     case PID_Fwd:
     {
         GETPKT(C4PacketFwd, rPkt);
         // only received accidently?
         if (!rPkt.DoFwdTo(LCCore.getID())) break;
         // handle
         C4NetIOPacket Packet(rPkt.getData(), pConn->getPeerAddr());
         HandlePacket(Packet, pConn, true);
     }
     break;
  
     case PID_PostMortem:
     {
         GETPKT(C4PacketPostMortem, rPkt);
         // Get connection
         C4Network2IOConnection *pConn = GetConnectionByID(rPkt.getConnID());
         if (!pConn) return;
         // Handle all packets
         uint32_t iCounter;
         for (iCounter = pConn->getInPacketCounter(); ; iCounter++)
         {
             // Get packet
             const C4NetIOPacket *pPkt = rPkt.getPacket(iCounter);
             if (!pPkt) break;
             // Handle it
             HandlePacket(*pPkt, pConn, true);
         }
         // Log
         if (iCounter > pConn->getInPacketCounter())
             Application.InteractiveThread.ThreadLogS("Network: Recovered %d packets", iCounter - pConn->getInPacketCounter());
         // Remove the connection from our list
         if (!pConn->isClosed())
             pConn->Close();
         RemoveConnection(pConn);
     }
     break;
  
     }
  
 #undef GETPKT
 }

Here is the call graph for this function:

◆ HandlePacket() [2/2]

bool C4Network2IO::HandlePacket	(	const C4NetIOPacket &	rPacket,
		C4Network2IOConnection *	pConn,
		bool	fThread
	)

protected

Definition at line 831 of file C4Network2IO.cpp.

 {
     // security: add connection reference
     if (!pConn) return false;
     pConn->AddRef();
     
     // accept only PID_Conn and PID_Ping on non-accepted connections
     if(!pConn->isHalfAccepted())
         if(rPacket.getStatus() != PID_Conn && rPacket.getStatus() != PID_Ping && rPacket.getStatus() != PID_ConnRe)
             return false;
  
     // unpack packet (yet another no-idea-why-it's-needed-cast)
     C4IDPacket Pkt; C4PacketBase &PktB = Pkt;
     try
     {
         PktB.unpack(rPacket);
     }
     catch (StdCompiler::Exception *pExc)
     {
         Application.InteractiveThread.ThreadLog("Network: error: Failed to unpack packet id %02x: %s", rPacket.getStatus(), pExc->Msg.getData());
         delete pExc;
 #ifndef _DEBUG
         pConn->Close();
 #endif
         return false;
     }
  
     // dump packet (network thread only)
 #if(C4NET2IO_DUMP_LEVEL > 0)
     if (Config.Network.PacketLogging && fThread && Pkt.getPktType() != PID_Ping && Pkt.getPktType() != PID_Pong && Pkt.getPktType() != PID_NetResData)
     {
         // StdStrBuf PacketDump = DecompileToBuf<StdCompilerINIWrite>(mkNamingAdaptrPacket);
         StdStrBuf PacketHeader = FormatString("HandlePacket: %s by %s (%lu bytes, counter %d)",
                                               C4TimeMilliseconds::Now().AsString().getData(),
                                               pConn->getPeerAddr().ToString().getData(),
                                               static_cast<unsigned long>(rPacket.getSize()), pConn->getInPacketCounter());
         StdStrBuf Dump = DecompileToBuf<StdCompilerINIWrite>(mkNamingAdapt(Pkt, PacketHeader.getData()));
         // Put it directly. The standard functions behind StdBuf.Format seem to choke when you pass them too much data.
         Application.InteractiveThread.PushEvent(Ev_LogSilent, Dump.GrabPointer());
     }
 #endif
  
     // search packet handling data
     bool fSendToMainThread = false, fHandled = false;
     for (const C4PktHandlingData *pHData = PktHandlingData; pHData->ID != PID_None; pHData++)
         if (pHData->ID == rPacket.getStatus())
         {
             // correct thread?
             if (!pHData->ProcByThread == !fThread)
             {
                 // connection accepted?
                 if (pHData->AcceptedOnly || pConn->isAccepted() || pConn->isClosed())
                 {
                     fHandled = true;
 #if(C4NET2IO_DUMP_LEVEL > 2)
                     C4TimeMilliseconds tStart = C4TimeMilliseconds::Now();
 #endif
  
                     // call handler(s)
                     CallHandlers(pHData->HandlerID, &Pkt, pConn, fThread);
  
 #if(C4NET2IO_DUMP_LEVEL > 2)
                     uint32_t iBlockedTime = C4TimeMilliseconds::Now() - tStart;
                     if (fThread && iBlockedTime > 100)
                     {
                         Application.InteractiveThread.ThreadLogS("HandlePacket: ... blocked for %u ms!", iBlockedTime);
                     }
 #endif
  
                 }
             }
             // transfer to main thread?
             else if (!pHData->ProcByThread && fThread)
             {
                 fHandled = true;
                 fSendToMainThread = true;
             }
         }
  
     // send to main thread?
     if (fSendToMainThread)
     {
         // create data
         NetEvPacketData *pEvData = new NetEvPacketData;
         pEvData->Packet.Take(rPacket.Duplicate());
         pEvData->Conn = pConn; pConn->AddRef();
         // trigger event
         if (!Application.InteractiveThread.PushEvent(Ev_Net_Packet, pEvData))
             Application.InteractiveThread.ThreadLogS("...push event ");
     }
  
     // unhandled?
     if (!fHandled && !pConn->isClosed())
         Application.InteractiveThread.ThreadLog("Network: Unhandled packet (status %02x)", rPacket.getStatus());
  
     // remove connection reference
     pConn->DelRef();
     return fHandled;
 }

Referenced by CallHandlers(), HandleFwdReq(), HandlePacket(), OnPacket(), and OnThreadEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandlePuncherPacket()

void C4Network2IO::HandlePuncherPacket ( const C4NetIOPacket & rPacket )

protected

Definition at line 1161 of file C4Network2IO.cpp.

 {
     auto pkt = C4NetpuncherPacket::Construct(rPacket);
     if (pkt && ::Network.HandlePuncherPacket(move(pkt), rPacket.getAddr().GetFamily()));
     else
     {
         assert(pNetIO_UDP);
         pNetIO_UDP->Close(rPacket.getAddr());
     }
 }

References C4NetIO::Close(), C4NetpuncherPacket::Construct(), C4NetIOPacket::getAddr(), C4NetIO::HostAddress::GetFamily(), C4Network2::HandlePuncherPacket(), Network, and pNetIO_UDP.

Referenced by OnPacket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasTCP()

bool C4Network2IO::hasTCP ( ) const

inline

Definition at line 107 of file C4Network2IO.h.

107 { return !! pNetIO_TCP; }

References pNetIO_TCP.

Referenced by C4Network2::InitNetIO().

Here is the caller graph for this function:

◆ hasUDP()

bool C4Network2IO::hasUDP ( ) const

inline

Definition at line 108 of file C4Network2IO.h.

108 { return !! pNetIO_UDP; }

References pNetIO_UDP.

Referenced by C4Network2::InitNetIO().

Here is the caller graph for this function:

◆ Init()

bool C4Network2IO::Init	(	int16_t	iPortTCP,
		int16_t	iPortUDP,
		int16_t	iPortDiscovery = `-1`,
		int16_t	iPortRefServer = `-1`,
		bool	fBroadcast = `false`,
		bool	enable_upnp = `true`
	)

Definition at line 53 of file C4Network2IO.cpp.

 {
     // Already initialized? Clear first
     if (pNetIO_TCP || pNetIO_UDP) Clear();
  
     // init members
     tLastPing = tLastStatistic = C4TimeMilliseconds::Now();
     iTCPIRate = iTCPORate = iTCPBCRate = 0;
     iUDPIRate = iUDPORate = iUDPBCRate = 0;
  
     // init event callback
     C4InteractiveThread &Thread = Application.InteractiveThread;
     Thread.SetCallback(Ev_Net_Conn, this);
     Thread.SetCallback(Ev_Net_Disconn, this);
     Thread.SetCallback(Ev_Net_Packet, this);
  
     // initialize UPnP manager
     if (enable_upnp && (iPortTCP > 0 || iPortUDP > 0))
     {
         assert(!UPnPMgr);
         UPnPMgr = new C4Network2UPnP;
     }
  
     // initialize net i/o classes: TCP first
     if (iPortTCP > 0)
     {
         // create
         pNetIO_TCP = new C4NetIOTCP();
         // init
         if (!pNetIO_TCP->Init(iPortTCP))
         {
             LogF("Network: could not init TCP i/o (%s)", pNetIO_TCP->GetError() ? pNetIO_TCP->GetError() : "");
             delete pNetIO_TCP; pNetIO_TCP = nullptr;
         }
         else
             LogSilentF("Network: TCP initialized on port %d", iPortTCP);
  
         // add to thread, set callback
         if (pNetIO_TCP)
         {
             Thread.AddProc(pNetIO_TCP);
             pNetIO_TCP->SetCallback(this);
             if (UPnPMgr) UPnPMgr->AddMapping(P_TCP, iPortTCP, iPortTCP);
         }
  
     }
     // then UDP
     if (iPortUDP > 0)
     {
         // create
         pNetIO_UDP = new C4NetIOUDP();
         // init
         if (!pNetIO_UDP->Init(iPortUDP))
         {
             LogF("Network: could not init UDP i/o (%s)", pNetIO_UDP->GetError() ? pNetIO_UDP->GetError() : "");
             delete pNetIO_UDP; pNetIO_UDP = nullptr;
         }
         else
             LogSilentF("Network: UDP initialized on port %d", iPortUDP);
  
         // add to thread, set callback
         if (pNetIO_UDP)
         {
             Thread.AddProc(pNetIO_UDP);
             pNetIO_UDP->SetCallback(this);
             if (UPnPMgr) UPnPMgr->AddMapping(P_UDP, iPortUDP, iPortUDP);
         }
     }
  
     // no protocols?
     if (!pNetIO_TCP && !pNetIO_UDP)
     {
         LogFatal("Network: fatal - no protocols available!");
         Thread.ClearCallback(Ev_Net_Conn, this);
         Thread.ClearCallback(Ev_Net_Disconn, this);
         Thread.ClearCallback(Ev_Net_Packet, this);
         return false;
     }
  
     // discovery last
     if (iPortDiscover > 0)
     {
         // create
         pNetIODiscover = new C4Network2IODiscover(iPortRefServer);
         pNetIODiscover->SetDiscoverable(false);
         // init
         if (!pNetIODiscover->Init(iPortDiscover))
         {
             LogF("Network: could not init discovery (%s)", pNetIODiscover->GetError() ? pNetIODiscover->GetError() : "");
             delete pNetIODiscover; pNetIODiscover = nullptr;
         }
         else
             LogSilentF("Network: discovery initialized on port %d", iPortDiscover);
         // add to thread
         if (pNetIODiscover)
             Thread.AddProc(pNetIODiscover);
     }
  
     // plus reference server
     if (iPortRefServer > 0)
     {
         // create
         pRefServer = new C4Network2RefServer();
         // init
         if (!pRefServer->Init(iPortRefServer))
         {
             LogF("Network: could not init reference server (%s)", pNetIO_UDP->GetError() ? pNetIO_UDP->GetError() : "");
             delete pRefServer; pRefServer = nullptr;
         }
         else
             LogSilentF("Network: reference server initialized on port %d", iPortRefServer);
         // add to thread
         if (pRefServer)
             Thread.AddProc(pRefServer);
     }
  
     // own timer
     tLastExecute = C4TimeMilliseconds::Now();
     Thread.AddProc(this);
  
     // ok
     return true;
 }

References C4Network2UPnP::AddMapping(), C4InteractiveThread::AddProc(), Application, Clear(), C4InteractiveThread::ClearCallback(), Ev_Net_Conn, Ev_Net_Disconn, Ev_Net_Packet, C4NetIO::GetError(), C4NetIOTCP::Init(), C4NetIO::Init(), C4Network2IODiscover::Init(), C4Application::InteractiveThread, iTCPBCRate, iTCPIRate, iTCPORate, iUDPBCRate, iUDPIRate, iUDPORate, LogF(), LogFatal(), LogSilentF(), C4TimeMilliseconds::Now(), P_TCP, P_UDP, pNetIO_TCP, pNetIO_UDP, pNetIODiscover, pRefServer, C4InteractiveThread::SetCallback(), C4NetIO::SetCallback(), C4Network2IODiscover::SetDiscoverable(), tLastExecute, tLastPing, tLastStatistic, and UPnPMgr.

Referenced by C4Network2::InitNetIO().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitPuncher()

bool C4Network2IO::InitPuncher ( C4NetIO::addr_t PuncherAddr )

Definition at line 452 of file C4Network2IO.cpp.

 {
     // UDP must be initialized
     if (!pNetIO_UDP)
         return false;
     // save address
     switch (nPuncherAddr.GetFamily())
     {
     case C4NetIO::HostAddress::IPv4:
         PuncherAddrIPv4 = nPuncherAddr;
         break;
     case C4NetIO::HostAddress::IPv6:
         PuncherAddrIPv6 = nPuncherAddr;
         break;
     case C4NetIO::HostAddress::UnknownFamily:
         assert(!"Unexpected address family");
     }
     // let's punch
     return pNetIO_UDP->Connect(nPuncherAddr);
 }

References C4NetIO::Connect(), C4NetIO::HostAddress::GetFamily(), C4NetIO::HostAddress::IPv4, C4NetIO::HostAddress::IPv6, pNetIO_UDP, PuncherAddrIPv4, PuncherAddrIPv6, and C4NetIO::HostAddress::UnknownFamily.

Referenced by C4Network2::InitPuncher().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsLowPriority()

virtual bool StdSchedulerProc::IsLowPriority ( )

inlinevirtualinherited

Definition at line 82 of file StdScheduler.h.

82 { return false; }

◆ IsNotify()

virtual bool StdSchedulerProc::IsNotify ( )

inlinevirtualinherited

Reimplemented in CStdNotifyProc, and C4NetIO.

Definition at line 83 of file StdScheduler.h.

83 { return false; }

◆ IsPuncherAddr()

bool C4Network2IO::IsPuncherAddr ( const C4NetIO::addr_t & addr ) const

protected

Definition at line 490 of file C4Network2IO.cpp.

 {
     return (!PuncherAddrIPv4.IsNull() && PuncherAddrIPv4 == addr)
         || (!PuncherAddrIPv6.IsNull() && PuncherAddrIPv6 == addr);
 }

References C4NetIO::EndpointAddress::IsNull(), PuncherAddrIPv4, and PuncherAddrIPv6.

Referenced by OnConn(), OnDisconn(), and OnPacket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsReferenceNeeded()

bool C4Network2IO::IsReferenceNeeded ( )

Definition at line 806 of file C4Network2IO.cpp.

 {
     return !!pRefServer;
 }

References pRefServer.

Referenced by C4Network2::Execute().

Here is the caller graph for this function:

◆ IsSignaled()

bool StdSchedulerProc::IsSignaled ( )

inherited

◆ MsgIO()

C4NetIO * C4Network2IO::MsgIO ( )

Definition at line 219 of file C4Network2IO.cpp.

 {
     if (pNetIO_UDP) return pNetIO_UDP;
     if (pNetIO_TCP) return pNetIO_TCP;
     return nullptr;
 }

References pNetIO_TCP, and pNetIO_UDP.

Referenced by C4Network2::DrawStatus(), and C4Network2::HandleConnRe().

Here is the caller graph for this function:

◆ OnConn()

bool C4Network2IO::OnConn	(	const C4NetIO::addr_t &	addr,
		const C4NetIO::addr_t &	AddrConnect,
		const C4NetIO::addr_t *	pOwnAddr,
		C4NetIO *	pNetIO
	)

overrideprotectedvirtual

Reimplemented from C4NetIO::CBClass.

Definition at line 497 of file C4Network2IO.cpp.

 {
     // puncher answer?
     if (pNetIO == pNetIO_UDP && IsPuncherAddr(ConnectAddr))
     {
         // got an address?
         if (pOwnAddr)
             ::Network.OnPuncherConnect(*pOwnAddr);
         return true;
     }
  
 #if(C4NET2IO_DUMP_LEVEL > 1)
     Application.InteractiveThread.ThreadLogS("OnConn: %s %s",
                C4TimeMilliseconds::Now().AsString().getData(),
                getNetIOName(pNetIO));
 #endif
     // search connection
     C4Network2IOConnection *pConn = nullptr;
     if (!ConnectAddr.IsNull())
         pConn = GetConnectionByConnAddr(ConnectAddr, pNetIO);
     // not found?
     if (!pConn)
     {
         // allow connect?
         if (!fAllowConnect) return false;
         // create new connection object
         uint32_t iConnID = iNextConnID++;
         pConn = new C4Network2IOConnection();
         pConn->Set(pNetIO, getNetIOProt(pNetIO), PeerAddr, ConnectAddr, CS_Connected, nullptr, iConnID);
         // add to list
         AddConnection(pConn);
     }
     else
     {
         // already closed this connection (attempt)?
         if (pConn->isClosed())
             return false;
         if (!pConn->isOpen())
         {
             // change status
             pConn->SetStatus(CS_Connected);
             pConn->SetPeerAddr(PeerAddr);
         }
     }
     // send welcome packet, if appropriate
     SendConnPackets();
 #if(C4NET2IO_DUMP_LEVEL > 0)
     // log
     Application.InteractiveThread.ThreadLogS("Network: got %s connection from %s", getNetIOName(pNetIO), PeerAddr.ToString().getData());
 #endif
     // do event (disabled - unused)
     // pConn->AddRef(); PushNetEv(NE_Conn, pConn);
     // ok
     return true;
 }

References AddConnection(), Application, CS_Connected, fAllowConnect, GetConnectionByConnAddr(), StdStrBuf::getData(), getNetIOName(), getNetIOProt(), iNextConnID, C4Application::InteractiveThread, C4Network2IOConnection::isClosed(), C4NetIO::EndpointAddress::IsNull(), C4Network2IOConnection::isOpen(), IsPuncherAddr(), Network, C4TimeMilliseconds::Now(), C4Network2::OnPuncherConnect(), pNetIO_UDP, SendConnPackets(), C4Network2IOConnection::Set(), C4Network2IOConnection::SetPeerAddr(), C4Network2IOConnection::SetStatus(), C4InteractiveThread::ThreadLogS(), and C4NetIO::EndpointAddress::ToString().

Here is the call graph for this function:

◆ OnDisconn()

void C4Network2IO::OnDisconn	(	const C4NetIO::addr_t &	addr,
		C4NetIO *	pNetIO,
		const char *	szReason
	)

overrideprotectedvirtual

Reimplemented from C4NetIO::CBClass.

Definition at line 553 of file C4Network2IO.cpp.

 {
     // punch?
     if (pNetIO == pNetIO_UDP && IsPuncherAddr(addr))
     {
         if (PuncherAddrIPv4 == addr)
             PuncherAddrIPv4.Clear();
         else
             PuncherAddrIPv6.Clear();
         return;
     }
 #if(C4NET2IO_DUMP_LEVEL > 1)
     Application.InteractiveThread.ThreadLogS("OnDisconn: %s %s",
                C4TimeMilliseconds::Now().AsString().getData(),
                getNetIOName(pNetIO));
 #endif
     // find connection
     C4Network2IOConnection *pConn = GetConnection(addr, pNetIO);
     if (!pConn) pConn = GetConnectionByConnAddr(addr, pNetIO);
     if (!pConn) return;
 #if(C4NET2IO_DUMP_LEVEL > 0)
     // log
     Application.InteractiveThread.ThreadLogS("Network: %s connection to %s %s (%s)",
         getNetIOName(pNetIO), addr.ToString().getData(), pConn->isConnecting() ? "failed" : "closed" , szReason);
 #endif
     // already closed? ignore
     if (!pConn->isClosed())
         // not accepted yet? count as connection failure
         pConn->SetStatus(pConn->isHalfAccepted() ? CS_Closed : CS_ConnectFail);
     // keep connection for main thread message
     pConn->AddRef();
     // check for pending welcome packets
     SendConnPackets();
     // signal to main thread
     Application.InteractiveThread.PushEvent(Ev_Net_Disconn, pConn);
     // don't remove connection from list - wait for postmortem or timeout
 }

References C4Network2IOConnection::AddRef(), Application, C4NetIO::EndpointAddress::Clear(), CS_Closed, CS_ConnectFail, Ev_Net_Disconn, GetConnection(), GetConnectionByConnAddr(), StdStrBuf::getData(), getNetIOName(), C4Application::InteractiveThread, C4Network2IOConnection::isClosed(), C4Network2IOConnection::isConnecting(), C4Network2IOConnection::isHalfAccepted(), IsPuncherAddr(), C4TimeMilliseconds::Now(), pNetIO_UDP, PuncherAddrIPv4, PuncherAddrIPv6, C4InteractiveThread::PushEvent(), SendConnPackets(), C4Network2IOConnection::SetStatus(), C4InteractiveThread::ThreadLogS(), and C4NetIO::EndpointAddress::ToString().

Here is the call graph for this function:

◆ OnError()

void C4Network2IO::OnError	(	const char *	strError,
		C4NetIO *	pNetIO
	)

protectedvirtual

Definition at line 631 of file C4Network2IO.cpp.

 {
     // let's log it
     Application.InteractiveThread.ThreadLog("Network: %s error: %s", getNetIOName(pNetIO), strError);
 }

References Application, getNetIOName(), C4Application::InteractiveThread, and C4InteractiveThread::ThreadLog().

Here is the call graph for this function:

◆ OnPacket() [1/2]

void C4Network2IO::OnPacket	(	const C4NetIOPacket &	rPacket,
		C4NetIO *	pNetIO
	)

overrideprotected

Definition at line 591 of file C4Network2IO.cpp.

 {
 #if C4NET2IO_DUMP_LEVEL > 1
     auto tTime = C4TimeMilliseconds::Now();
 #endif
 #if(C4NET2IO_DUMP_LEVEL > 1)
     Application.InteractiveThread.ThreadLogS("OnPacket: %s status %02x %s",
                C4TimeMilliseconds::Now().AsString().getData(),
                rPacket.getStatus(), getNetIOName(pNetIO));
 #endif
     if (pNetIO == pNetIO_UDP && IsPuncherAddr(rPacket.getAddr()))
     {
         HandlePuncherPacket(rPacket);
         return;
     }
     if (!rPacket.getSize()) return;
     // find connection
     C4Network2IOConnection *pConn = GetConnection(rPacket.getAddr(), pNetIO);
     if (!pConn)
     {
         Application.InteractiveThread.ThreadLog("Network: could not find connection for %s packet (status %02x) from %s!", getNetIOName(pNetIO), rPacket.getStatus(), rPacket.getAddr().ToString().getData());
         return;
     }
 #if(C4NET2IO_DUMP_LEVEL > 2)
     uint32_t iFindConnectionBlocked = C4TimeMilliseconds::Now() - tTime;
     if (iFindConnectionBlocked > 100)
         Application.InteractiveThread.ThreadLogS("OnPacket: ... blocked %d ms for finding the connection!", iFindConnectionBlocked);
 #endif
     // notify
     pConn->OnPacketReceived(rPacket.getStatus());
     // handle packet
     HandlePacket(rPacket, pConn, true);
     // log time
 #if(C4NET2IO_DUMP_LEVEL > 1)
     uint32_t iHandlingBlocked = C4TimeMilliseconds::Now() - tTime;
     if (iHandlingBlocked > 100)
         Application.InteractiveThread.ThreadLogS("OnPacket: ... blocked %d ms for handling!", iHandlingBlocked);
 #endif
 }

References Application, C4NetIOPacket::getAddr(), GetConnection(), StdStrBuf::getData(), getNetIOName(), StdBuf::getSize(), C4NetIOPacket::getStatus(), HandlePacket(), HandlePuncherPacket(), C4Application::InteractiveThread, IsPuncherAddr(), C4TimeMilliseconds::Now(), C4Network2IOConnection::OnPacketReceived(), pNetIO_UDP, C4InteractiveThread::ThreadLog(), C4InteractiveThread::ThreadLogS(), and C4NetIO::EndpointAddress::ToString().

Here is the call graph for this function:

◆ OnPacket() [2/2]

virtual void C4NetIO::CBClass::OnPacket	(	const class C4NetIOPacket &	rPacket,
		C4NetIO *	pNetIO
	)

pure virtualinherited

Implemented in C4Network2IODiscoverClient, C4Network2IODiscover, C4NetIO::CBProxy< T >, and MyCBClass.

Referenced by C4NetIOSimpleUDP::Execute(), and C4NetIOTCP::UnpackPacket().

Here is the caller graph for this function:

◆ OnThreadEvent()

void C4Network2IO::OnThreadEvent	(	C4InteractiveEventType	eEvent,
		void *	pEventData
	)

overrideprotectedvirtual

Implements C4InteractiveThread::Callback.

Definition at line 670 of file C4Network2IO.cpp.

 {
     switch (eEvent)
     {
     case Ev_Net_Conn: // got a connection
     {
         C4Network2IOConnection *pConn = reinterpret_cast<C4Network2IOConnection *>(pEventData);
         // do callback
         ::Network.OnConn(pConn);
         // remove reference
         pConn->DelRef();
     }
     break;
  
     case Ev_Net_Disconn: // connection closed
     {
         C4Network2IOConnection *pConn = reinterpret_cast<C4Network2IOConnection *>(pEventData);
         assert(pConn->isClosed());
         // do callback
         ::Network.OnDisconn(pConn);
         // remove reference
         pConn->DelRef();
     }
     break;
  
     case Ev_Net_Packet: // got packet
     {
         NetEvPacketData *pData = reinterpret_cast<NetEvPacketData *>(pEventData);
         // handle
         HandlePacket(pData->Packet, pData->Conn, false);
         // clear up
         pData->Conn->DelRef();
         delete pData;
     }
     break;
  
     default:
         // TODO
         break;
     }
 }

References C4Network2IO::NetEvPacketData::Conn, C4Network2IOConnection::DelRef(), Ev_Net_Conn, Ev_Net_Disconn, Ev_Net_Packet, HandlePacket(), C4Network2IOConnection::isClosed(), Network, C4Network2::OnConn(), C4Network2::OnDisconn(), and C4Network2IO::NetEvPacketData::Packet.

Here is the call graph for this function:

◆ Ping()

bool C4Network2IO::Ping ( )

protected

Definition at line 1172 of file C4Network2IO.cpp.

 {
     bool fSuccess = true;
     // ping all connections
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isOpen())
         {
             C4PacketPing Ping(pConn->getInPacketCounter(), pConn->getOutPacketCounter());
             fSuccess &= pConn->Send(MkC4NetIOPacket(PID_Ping, Ping));
             pConn->OnPing();
         }
     return fSuccess;
 }

References MkC4NetIOPacket(), pConnList, PID_Ping, and C4Network2IOConnection::pNext.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Punch()

void C4Network2IO::Punch ( const C4NetIO::addr_t & punchee_addr )

Definition at line 473 of file C4Network2IO.cpp.

 {
     if (!pNetIO_UDP)
         return;
     C4PacketPing PktPeng;
     dynamic_cast<C4NetIOUDP*>(pNetIO_UDP)->SendDirect(MkC4NetIOPacket(PID_Pong, PktPeng, punchee_addr));
 }

References MkC4NetIOPacket(), PID_Pong, and pNetIO_UDP.

Referenced by C4Network2::HandlePuncherPacket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveAutoAccept()

void C4Network2IO::RemoveAutoAccept ( const C4ClientCore & CCore )

Definition at line 331 of file C4Network2IO.cpp.

 {
     CStdLock AALock(&AutoAcceptCSec);
     // find & remove
     AutoAccept *pAcc = pAutoAcceptList, *pLast = nullptr;
     while (pAcc)
         if (pAcc->CCore.getDiffLevel(CCore) <= C4ClientCoreDL_IDMatch)
         {
             // unlink
             AutoAccept *pDelete = pAcc;
             pAcc = pAcc->Next;
             (pLast ? pLast->Next : pAutoAcceptList) = pAcc;
             // delete
             delete pDelete;
         }
         else
         {
             // next peer
             pLast = pAcc;
             pAcc = pAcc->Next;
         }
 }

References AutoAcceptCSec, C4ClientCoreDL_IDMatch, C4Network2IO::AutoAccept::CCore, C4ClientCore::getDiffLevel(), and C4Network2IO::AutoAccept::Next.

Referenced by C4Network2ClientList::DeleteClient().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveConnection()

void C4Network2IO::RemoveConnection ( C4Network2IOConnection * pConn )

protected

Definition at line 747 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
     // search & remove
     if (pConnList == pConn)
         pConnList = pConn->pNext;
     else
     {
         C4Network2IOConnection *pAct;
         for (pAct = pConnList; pAct; pAct = pAct->pNext)
             if (pAct->pNext == pConn)
                 break;
         if (pAct)
             pAct->pNext = pConn->pNext;
         else
             return;
     }
     // remove reference
     pConn->pNext = nullptr; pConn->DelRef();
 }

References ConnListCSec, C4Network2IOConnection::DelRef(), pConnList, and C4Network2IOConnection::pNext.

Referenced by CheckTimeout(), Clear(), ConnectWithSocket(), and HandlePacket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendConnPackets()

void C4Network2IO::SendConnPackets ( )

protected

Definition at line 1254 of file C4Network2IO.cpp.

 {
     CStdLock ConnListLock(&ConnListCSec);
  
     // exlusive conn?
     if (fExclusiveConn)
         // find a live connection
         for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
             if (pConn->isAccepted() || (!pConn->isClosed() && pConn->isConnSent()))
                 // do not sent additional conn packets - no other connection should succeed
                 return;
  
     // sent pending welcome packet(s)
     for (C4Network2IOConnection *pConn = pConnList; pConn; pConn = pConn->pNext)
         if (pConn->isOpen() && !pConn->isConnSent())
         {
             // make packet
             CStdLock LCCoreLock(&LCCoreCSec);
             C4NetIOPacket Pkt = MkC4NetIOPacket(PID_Conn, C4PacketConn(LCCore, pConn->getID(), pConn->getPassword()));
             LCCoreLock.Clear();
             // send
             if (!pConn->Send(Pkt))
                 pConn->Close();
             else
             {
                 // set flag
                 pConn->SetConnSent();
                 // only one conn packet at a time
                 if (fExclusiveConn)
                     return;
             }
         }
  
 }

References CStdLock::Clear(), ConnListCSec, fExclusiveConn, C4ClientCore::getID(), LCCore, LCCoreCSec, MkC4NetIOPacket(), pConnList, PID_Conn, and C4Network2IOConnection::pNext.

Referenced by OnConn(), OnDisconn(), and SetExclusiveConnMode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendMsgToClient()

bool C4Network2IO::SendMsgToClient	(	C4NetIOPacket &	rPkt,
		int	iClient
	)

Definition at line 412 of file C4Network2IO.cpp.

 {
     // find msg connection
     C4Network2IOConnection *pConn = GetMsgConnection(iClient);
     if (!pConn) return false;
     // send
     bool fSuccess = pConn->Send(rPkt);
     pConn->DelRef();
     return fSuccess;
 }

References C4Network2IOConnection::DelRef(), GetMsgConnection(), and C4Network2IOConnection::Send().

Here is the call graph for this function:

◆ SendPuncherPacket()

void C4Network2IO::SendPuncherPacket	(	const C4NetpuncherPacket &	p,
		C4NetIO::HostAddress::AddressFamily	family
	)

Definition at line 481 of file C4Network2IO.cpp.

 {
     if (!pNetIO_UDP) return;
     if (family == C4NetIO::HostAddress::IPv4 && !PuncherAddrIPv4.IsNull())
         pNetIO_UDP->Send(p.PackTo(PuncherAddrIPv4));
     else if (family == C4NetIO::HostAddress::IPv6 && !PuncherAddrIPv6.IsNull())
         pNetIO_UDP->Send(p.PackTo(PuncherAddrIPv6));
 }

References C4NetIO::HostAddress::IPv4, C4NetIO::HostAddress::IPv6, C4NetIO::EndpointAddress::IsNull(), C4NetpuncherPacket::PackTo(), pNetIO_UDP, PuncherAddrIPv4, PuncherAddrIPv6, and C4NetIO::Send().

Referenced by C4Network2::OnPuncherConnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetAcceptMode()

void C4Network2IO::SetAcceptMode ( bool fAcceptAll )

Definition at line 271 of file C4Network2IO.cpp.

 {
     fAllowConnect = fnAllowConnect;
     // Allow connect? Allow discovery of this host
     if (fAllowConnect)
     {
         if (pNetIODiscover)
         {
             pNetIODiscover->SetDiscoverable(true);
             pNetIODiscover->Announce();
         }
     }
 }

References C4Network2IODiscover::Announce(), fAllowConnect, pNetIODiscover, and C4Network2IODiscover::SetDiscoverable().

Referenced by C4Network2::InitHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetExclusiveConnMode()

void C4Network2IO::SetExclusiveConnMode ( bool fExclusiveConn )

Definition at line 285 of file C4Network2IO.cpp.

 {
     if (fExclusiveConn == fnExclusiveConn)
         return;
     // Set flag
     fExclusiveConn = fnExclusiveConn;
     // Allowed? Send all pending welcome packets
     if (!fExclusiveConn)
         SendConnPackets();
 }

References fExclusiveConn, and SendConnPackets().

Here is the call graph for this function:

◆ SetLocalCCore()

void C4Network2IO::SetLocalCCore ( const C4ClientCore & CCore )

Definition at line 213 of file C4Network2IO.cpp.

 {
     CStdLock LCCoreLock(&LCCoreCSec);
     LCCore = nCCore;
 }

References LCCore, and LCCoreCSec.

Referenced by C4Network2::HandleJoinData(), and C4Network2::InitNetIO().

Here is the caller graph for this function:

◆ SetReference()

void C4Network2IO::SetReference ( class C4Network2Reference * pReference )

Definition at line 798 of file C4Network2IO.cpp.

 {
     if (pRefServer)
         pRefServer->SetReference(pReference);
     else
         delete pReference;
 }

References pRefServer, and C4Network2RefServer::SetReference().

Referenced by C4Network2::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TimerInterval()

virtual uint32_t StdSchedulerProc::TimerInterval ( )

inlinevirtualinherited

Reimplemented in CStdTimerProc.

Definition at line 84 of file StdScheduler.h.

84 { return 0; }

Member Data Documentation

◆ AutoAcceptCSec

CStdCSec C4Network2IO::AutoAcceptCSec

protected

Definition at line 87 of file C4Network2IO.h.

Referenced by AddAutoAccept(), ClearAutoAccept(), doAutoAccept(), and RemoveAutoAccept().

◆ BroadcastCSec

CStdCSec C4Network2IO::BroadcastCSec

protected

Definition at line 72 of file C4Network2IO.h.

Referenced by BeginBroadcast(), and EndBroadcast().

◆ ConnListCSec

CStdCSec C4Network2IO::ConnListCSec

protected

Definition at line 72 of file C4Network2IO.h.

Referenced by AddConnection(), BeginBroadcast(), Broadcast(), BroadcastMsg(), CheckTimeout(), Clear(), GenerateStatistics(), GetConnection(), GetConnectionByConnAddr(), GetConnectionByID(), getConnectionCount(), GetDataConnection(), GetMsgConnection(), HandleFwdReq(), RemoveConnection(), and SendConnPackets().

◆ fAllowConnect

bool C4Network2IO::fAllowConnect {false}

protected

Definition at line 78 of file C4Network2IO.h.

Referenced by Clear(), OnConn(), and SetAcceptMode().

◆ fExclusiveConn

bool C4Network2IO::fExclusiveConn {false}

protected

Definition at line 90 of file C4Network2IO.h.

Referenced by Clear(), SendConnPackets(), and SetExclusiveConnMode().

◆ iNextConnID

uint32_t C4Network2IO::iNextConnID {0}

protected

Definition at line 75 of file C4Network2IO.h.

Referenced by Clear(), ConnectWithSocket(), and OnConn().

◆ iTCPBCRate

int C4Network2IO::iTCPBCRate {0}

protected

Definition at line 98 of file C4Network2IO.h.

Referenced by GenerateStatistics(), getProtBCRate(), and Init().

◆ iTCPIRate

int C4Network2IO::iTCPIRate {0}

protected

Definition at line 98 of file C4Network2IO.h.

Referenced by GenerateStatistics(), getProtIRate(), and Init().

◆ iTCPORate

int C4Network2IO::iTCPORate {0}

protected

Definition at line 98 of file C4Network2IO.h.

Referenced by GenerateStatistics(), getProtORate(), and Init().

◆ iUDPBCRate

int C4Network2IO::iUDPBCRate {0}

protected

Definition at line 99 of file C4Network2IO.h.

Referenced by GenerateStatistics(), getProtBCRate(), and Init().

◆ iUDPIRate

int C4Network2IO::iUDPIRate {0}

protected

Definition at line 99 of file C4Network2IO.h.

Referenced by GenerateStatistics(), getProtIRate(), and Init().

◆ iUDPORate

int C4Network2IO::iUDPORate {0}

protected

Definition at line 99 of file C4Network2IO.h.

Referenced by GenerateStatistics(), getProtORate(), and Init().

◆ LCCore

C4ClientCore C4Network2IO::LCCore

protected

Definition at line 67 of file C4Network2IO.h.

Referenced by HandleFwdReq(), HandlePacket(), SendConnPackets(), and SetLocalCCore().

◆ LCCoreCSec

CStdCSec C4Network2IO::LCCoreCSec

protected

Definition at line 68 of file C4Network2IO.h.

Referenced by SendConnPackets(), and SetLocalCCore().

◆ nullptr

struct C4Network2IO::AutoAccept C4Network2IO::nullptr

protected

◆ pConnList

C4Network2IOConnection* C4Network2IO::pConnList {nullptr}

protected

Definition at line 71 of file C4Network2IO.h.

Referenced by AddConnection(), BeginBroadcast(), Broadcast(), BroadcastMsg(), CheckTimeout(), Clear(), doAutoAccept(), GenerateStatistics(), GetConnection(), GetConnectionByConnAddr(), GetConnectionByID(), getConnectionCount(), GetDataConnection(), GetMsgConnection(), HandleFwdReq(), Ping(), RemoveConnection(), and SendConnPackets().

◆ pNetIO_TCP

C4NetIO* C4Network2IO::pNetIO_TCP {nullptr}

protected

Definition at line 55 of file C4Network2IO.h.

Referenced by Clear(), DataIO(), GenerateStatistics(), getNetIO(), getNetIOName(), getNetIOProt(), hasTCP(), Init(), and MsgIO().

◆ pNetIO_UDP

C4NetIO * C4Network2IO::pNetIO_UDP {nullptr}

protected

Definition at line 55 of file C4Network2IO.h.

Referenced by Clear(), DataIO(), GenerateStatistics(), getNetIO(), getNetIOName(), getNetIOProt(), HandlePuncherPacket(), hasUDP(), Init(), InitPuncher(), MsgIO(), OnConn(), OnDisconn(), OnPacket(), Punch(), and SendPuncherPacket().

◆ pNetIODiscover

class C4Network2IODiscover* C4Network2IO::pNetIODiscover {nullptr}

protected

Definition at line 58 of file C4Network2IO.h.

Referenced by Clear(), Init(), and SetAcceptMode().

◆ pRefServer

class C4Network2RefServer* C4Network2IO::pRefServer {nullptr}

protected

Definition at line 61 of file C4Network2IO.h.

Referenced by Clear(), Init(), IsReferenceNeeded(), and SetReference().

◆ PuncherAddrIPv4

C4NetIO::addr_t C4Network2IO::PuncherAddrIPv4

protected

Definition at line 102 of file C4Network2IO.h.

Referenced by InitPuncher(), IsPuncherAddr(), OnDisconn(), and SendPuncherPacket().

◆ PuncherAddrIPv6

C4NetIO::addr_t C4Network2IO::PuncherAddrIPv6

protected

Definition at line 102 of file C4Network2IO.h.

Referenced by InitPuncher(), IsPuncherAddr(), OnDisconn(), and SendPuncherPacket().

◆ tLastExecute

C4TimeMilliseconds C4Network2IO::tLastExecute

protected

Definition at line 93 of file C4Network2IO.h.

Referenced by Execute(), GetNextTick(), and Init().

◆ tLastPing

C4TimeMilliseconds C4Network2IO::tLastPing

protected

Definition at line 94 of file C4Network2IO.h.

Referenced by Execute(), and Init().

◆ tLastStatistic

C4TimeMilliseconds C4Network2IO::tLastStatistic

protected

Definition at line 97 of file C4Network2IO.h.

Referenced by Execute(), and Init().

◆ UPnPMgr

class C4Network2UPnP* C4Network2IO::UPnPMgr {nullptr}

protected

Definition at line 64 of file C4Network2IO.h.

Referenced by Clear(), and Init().

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Class Documentation

◆ C4Network2IO::AutoAccept

◆ C4Network2IO::NetEvPacketData

Constructor & Destructor Documentation

◆ C4Network2IO()

◆ ~C4Network2IO()

Member Function Documentation

◆ AddAutoAccept()

◆ AddConnection()

◆ BeginBroadcast()

◆ Broadcast()

◆ BroadcastMsg()

◆ CallHandlers()

◆ Changed()

◆ CheckTimeout()

◆ Clear()

◆ ClearAutoAccept()

◆ Connect()

◆ ConnectWithSocket()

◆ DataIO()

◆ doAutoAccept()

◆ EndBroadcast()

◆ Execute()

◆ ExecuteUntil()

◆ GenerateStatistics()

◆ GetConnection()

◆ GetConnectionByConnAddr()

◆ GetConnectionByID()

◆ getConnectionCount()

◆ GetDataConnection()

◆ GetFDs()

◆ GetMsgConnection()

◆ getNetIO()

◆ getNetIOName()

◆ getNetIOProt()

◆ GetNextTick()

◆ getProtBCRate()

◆ getProtIRate()

◆ getProtORate()

◆ HandleFwdReq()

◆ HandlePacket() [1/2]

◆ HandlePacket() [2/2]

◆ HandlePuncherPacket()

◆ hasTCP()

◆ hasUDP()

◆ Init()

◆ InitPuncher()

◆ IsLowPriority()

◆ IsNotify()

◆ IsPuncherAddr()

◆ IsReferenceNeeded()

◆ IsSignaled()

◆ MsgIO()

◆ OnConn()

◆ OnDisconn()

◆ OnError()

◆ OnPacket() [1/2]

◆ OnPacket() [2/2]

◆ OnThreadEvent()

◆ Ping()

◆ Punch()

◆ RemoveAutoAccept()

◆ RemoveConnection()

◆ SendConnPackets()

◆ SendMsgToClient()

◆ SendPuncherPacket()

◆ SetAcceptMode()

◆ SetExclusiveConnMode()

◆ SetLocalCCore()

◆ SetReference()

◆ TimerInterval()

Member Data Documentation

◆ AutoAcceptCSec

◆ BroadcastCSec

◆ ConnListCSec