C4NetIOUDP::Peer Class Reference

#include <C4NetIO.h>

Collaboration diagram for C4NetIOUDP::Peer:

Public Member Functions
	Peer (const C4NetIO::addr_t &naddr, C4NetIOUDP *pnParent)
	~Peer ()
const C4NetIO::addr_t &	GetAddr () const
const C4NetIO::addr_t &	GetAltAddr () const
bool	Connect (bool fFailCallback)
bool	Send (const C4NetIOPacket &rPacket)
bool	Check (bool fForceCheck=true)
void	OnRecv (const C4NetIOPacket &Packet)
void	Close (const char *szReason)
bool	Open () const
bool	Closed () const
bool	MultiCast () const
unsigned int	GetMCAckPacketCounter () const
C4TimeMilliseconds	GetTimeout ()
void	CheckTimeout ()
bool	doBroadcast () const
void	SetBroadcast (bool fSet)
void	SetAltAddr (const C4NetIO::addr_t &naddr2)
int	GetIRate () const
int	GetORate () const
int	GetLoss () const
void	ClearStatistics ()

Public Attributes
Peer *	Next

Protected Types
enum	ConnStatus { CS_None , CS_Conn , CS_Works , CS_Closed }

Protected Member Functions
bool	DoConn (bool fMC)
bool	DoCheck (int iAskCnt=0, int iMCAskCnt=0, unsigned int *pAskList=nullptr)
bool	SendDirect (const Packet &rPacket, unsigned int iNr=~0)
bool	SendDirect (C4NetIOPacket &&rPacket)
void	OnConn ()
void	OnClose (const char *szReason)
void	CheckCompleteIPackets ()
void	SetTimeout (int iLength=iStdTimeout, int iRetryCnt=0)
void	OnTimeout ()

Protected Attributes
C4NetIOUDP *const	pParent
C4NetIO::addr_t	addr
C4NetIO::addr_t	addr2
addr_t	PeerAddr
enum C4NetIOUDP::Peer::ConnStatus	eStatus
bool	fMultiCast
bool	fDoBroadcast
bool	fConnFailCallback
PacketList	OPackets
PacketList	IPackets
PacketList	IMCPackets
unsigned int	iOPacketCounter
unsigned int	iIPacketCounter
unsigned int	iRIPacketCounter
unsigned int	iIMCPacketCounter
unsigned int	iRIMCPacketCounter
unsigned int	iMCAckPacketCounter
CStdCSec	OutCSec
C4TimeMilliseconds	tNextReCheck
unsigned int	iLastPacketAsked
unsigned int	iLastMCPacketAsked
C4TimeMilliseconds	tTimeout
unsigned int	iRetries
int	iIRate
int	iORate
int	iLoss
CStdCSec	StatCSec

Static Protected Attributes
static const unsigned int	iConnectRetries = 5
static const unsigned int	iReCheckInterval = 1000

Detailed Description

Definition at line 736 of file C4NetIO.h.

Member Enumeration Documentation

ConnStatus

enum C4NetIOUDP::Peer::ConnStatus

protected

Enumerator
CS_None
CS_Conn
CS_Works
CS_Closed

Definition at line 760 of file C4NetIO.h.

        {
            CS_None, CS_Conn, CS_Works, CS_Closed
        }

Constructor & Destructor Documentation

Peer()

C4NetIOUDP::Peer::Peer	(	const C4NetIO::addr_t &	naddr,
		C4NetIOUDP *	pnParent
	)

Definition at line 3161 of file C4NetIO.cpp.

        : pParent(pnParent), addr(naddr),
        eStatus(CS_None),
        fMultiCast(false), fDoBroadcast(false),
        OPackets(iMaxOPacketBacklog),
        iOPacketCounter(0),
        iIPacketCounter(0), iRIPacketCounter(0),
        iIMCPacketCounter(0), iRIMCPacketCounter(0),
        iMCAckPacketCounter(0),
        tNextReCheck(C4TimeMilliseconds::NegativeInfinity),
        iIRate(0), iORate(0), iLoss(0)
{
}

~Peer()

C4NetIOUDP::Peer::~Peer

(

)

Definition at line 3175 of file C4NetIO.cpp.

{
    // send close-packet
    Close("deleted");
}

References C4NetIOUDP::Close().

Here is the call graph for this function:

Member Function Documentation

Check()

bool C4NetIOUDP::Peer::Check

(

bool

fForceCheck = true

)

Definition at line 3210 of file C4NetIO.cpp.

{
    // only on working connections
    if (eStatus != CS_Works) return true;
    // prevent re-check (check floods)
    // instead, ask for other packets that are missing until recheck is allowed
    bool fNoReCheck = tNextReCheck > C4TimeMilliseconds::Now();
    if (!fNoReCheck) iLastPacketAsked = iLastMCPacketAsked = 0;
    unsigned int iStartAt = fNoReCheck ? std::max(iLastPacketAsked + 1, iIPacketCounter) : iIPacketCounter;
    unsigned int iStartAtMC = fNoReCheck ? std::max(iLastMCPacketAsked + 1, iIMCPacketCounter) : iIMCPacketCounter;
    // check if we have something to ask for
    const unsigned int iMaxAskCnt = 10;
    unsigned int i, iAskList[iMaxAskCnt], iAskCnt = 0, iMCAskCnt = 0;
    for (i = iStartAt; i < iRIPacketCounter; i++)
        if (!IPackets.FragmentPresent(i))
            if (iAskCnt < iMaxAskCnt)
                iLastPacketAsked = iAskList[iAskCnt++] = i;
    for (i = iStartAtMC; i < iRIMCPacketCounter; i++)
        if (!IMCPackets.FragmentPresent(i))
            if (iAskCnt + iMCAskCnt < iMaxAskCnt)
                iLastMCPacketAsked = iAskList[iAskCnt + iMCAskCnt++] = i;
    int iEAskCnt = iAskCnt + iMCAskCnt;
    // no re-check limit? set it
    if (!fNoReCheck)
    {
        if (iEAskCnt)
            tNextReCheck = C4TimeMilliseconds::Now() + iReCheckInterval;
        else
            tNextReCheck = C4TimeMilliseconds::NegativeInfinity;
    }
    // something to ask for? (or check forced?)
    if (iEAskCnt || fForceCheck)
        return DoCheck(iAskCnt, iMCAskCnt, iAskList);
    return true;
}

References C4NetIOUDP::DoCheck(), C4TimeMilliseconds::NegativeInfinity, and C4TimeMilliseconds::Now().

Here is the call graph for this function:

CheckCompleteIPackets()

void C4NetIOUDP::Peer::CheckCompleteIPackets ( )

protected

Definition at line 3581 of file C4NetIO.cpp.

{
    // only status CS_Works
    if (eStatus != CS_Works) return;
    // (If the status is CS_Conn, we'll have to wait until the connection in the
    //  opposite direction is etablished. There is no problem in checking for
    //  complete packets here, but the one using the interface may get very confused
    //  if he gets a callback for a connection that hasn't been announced to him
    //  yet)
 
    // check for complete incoming packets
    Packet *pPkt;
    while ((pPkt = IPackets.GetFirstPacketComplete()))
    {
        // missing packet?
        if (pPkt->GetNr() != iIPacketCounter) break;
        // do callback
        if (pParent->pCB)
            pParent->pCB->OnPacket(pPkt->GetData(), pParent);
        // advance packet counter
        iIPacketCounter = pPkt->GetNr() + pPkt->FragmentCnt();
        // remove packet from queue
        int iNr = pPkt->GetNr();
        IPackets.DeletePacket(pPkt);
        assert(!IPackets.GetPacketFrgm(iNr)); (void)iNr;
    }
    while ((pPkt = IMCPackets.GetFirstPacketComplete()))
    {
        // missing packet?
        if (pPkt->GetNr() != iIMCPacketCounter) break;
        // do callback
        if (pParent->pCB)
            pParent->pCB->OnPacket(pPkt->GetData(), pParent);
        // advance packet counter
        iIMCPacketCounter = pPkt->GetNr() + pPkt->FragmentCnt();
        // remove packet from queue
        int iNr = pPkt->GetNr();
        IMCPackets.DeletePacket(pPkt);
        assert(!IMCPackets.GetPacketFrgm(iNr)); (void)iNr;
    }
}

References C4NetIOUDP::Packet::FragmentCnt(), C4NetIOUDP::Packet::GetData(), and C4NetIOUDP::Packet::GetNr().

Here is the call graph for this function:

CheckTimeout()

void C4NetIOUDP::Peer::CheckTimeout

(

)

Definition at line 3473 of file C4NetIO.cpp.

{
    // check
    if (C4TimeMilliseconds::Now() > tTimeout)
        OnTimeout();
}

References C4TimeMilliseconds::Now().

Here is the call graph for this function:

ClearStatistics()

void C4NetIOUDP::Peer::ClearStatistics

(

)

Definition at line 3480 of file C4NetIO.cpp.

{
    CStdLock StatLock(&StatCSec);
    iIRate = iORate = 0;
    iLoss = 0;
}

References C4NetIOUDP::StatCSec.

Close()

void C4NetIOUDP::Peer::Close

(

const char *

szReason

)

Definition at line 3458 of file C4NetIO.cpp.

{
    // already closed?
    if (eStatus == CS_Closed)
        return;
    // send close-packet
    ClosePacket Pkt;
    Pkt.StatusByte = IPID_Close;
    Pkt.Nr = 0;
    Pkt.Addr = addr;
    SendDirect(C4NetIOPacket(&Pkt, sizeof(Pkt), false, addr));
    // callback
    OnClose(szReason);
}

References C4NetIOUDP::ClosePacket::Addr, CS_Closed, C4NetIOUDP::IPID_Close, C4NetIOUDP::PacketHdr::Nr, C4NetIOUDP::SendDirect(), and C4NetIOUDP::PacketHdr::StatusByte.

Referenced by C4NetIOUDP::Close(), and C4NetIOUDP::ConnectPeer().

Here is the call graph for this function:

Here is the caller graph for this function:

Closed()

bool C4NetIOUDP::Peer::Closed ( ) const

inline

Definition at line 819 of file C4NetIO.h.

{ return eStatus == CS_Closed; }

References CS_Closed, and eStatus.

Referenced by C4NetIOUDP::OnShareFree().

Here is the caller graph for this function:

Connect()

bool C4NetIOUDP::Peer::Connect

(

bool

fFailCallback

)

Definition at line 3181 of file C4NetIO.cpp.

{
    // initiate connection (DoConn will set status CS_Conn)
    fMultiCast = false; fConnFailCallback = fFailCallback;
    return DoConn(false);
}

References C4NetIOUDP::fMultiCast.

Referenced by C4NetIOUDP::ConnectPeer().

Here is the caller graph for this function:

doBroadcast()

bool C4NetIOUDP::Peer::doBroadcast ( ) const

inline

Definition at line 831 of file C4NetIO.h.

{ return fDoBroadcast; }

References fDoBroadcast.

Referenced by C4NetIOUDP::Broadcast().

Here is the caller graph for this function:

DoCheck()

bool C4NetIOUDP::Peer::DoCheck ( int  iAskCnt = 0, int  iMCAskCnt = 0, unsigned int *  pAskList = nullptr  )

protected

Definition at line 3506 of file C4NetIO.cpp.

{
    // security
    if (!pAskList) iAskCnt = iMCAskCnt = 0;
    // statistics
    { CStdLock StatLock(&StatCSec); iLoss += iAskCnt + iMCAskCnt; }
    // alloc data
    int iAskListSize = (iAskCnt + iMCAskCnt) * sizeof(*pAskList);
    StdBuf Packet; Packet.New(sizeof(CheckPacketHdr) + iAskListSize);
    CheckPacketHdr *pChkPkt = getMBufPtr<CheckPacketHdr>(Packet);
    // set up header
    pChkPkt->StatusByte = IPID_Check; // (note: always du here, see C4NetIOUDP::DoCheck)
    pChkPkt->Nr = iOPacketCounter;
    pChkPkt->AckNr = iIPacketCounter;
    pChkPkt->MCAckNr = iIMCPacketCounter;
    // copy ask list
    pChkPkt->AskCount = iAskCnt;
    pChkPkt->MCAskCount = iMCAskCnt;
    if (pAskList)
        Packet.Write(pAskList, iAskListSize, sizeof(CheckPacketHdr));
    // send packet
    return SendDirect(C4NetIOPacket(Packet, addr));
}

References C4NetIOUDP::CheckPacketHdr::AckNr, C4NetIOUDP::CheckPacketHdr::AskCount, C4NetIOUDP::iOPacketCounter, C4NetIOUDP::IPID_Check, C4NetIOUDP::CheckPacketHdr::MCAckNr, C4NetIOUDP::CheckPacketHdr::MCAskCount, C4NetIOUDP::PacketHdr::Nr, C4NetIOUDP::Packet, C4NetIOUDP::SendDirect(), C4NetIOUDP::StatCSec, and C4NetIOUDP::PacketHdr::StatusByte.

Here is the call graph for this function:

DoConn()

bool C4NetIOUDP::Peer::DoConn ( bool  fMC )

protected

Definition at line 3487 of file C4NetIO.cpp.

{
    // set status
    eStatus = CS_Conn;
    // set timeout
    SetTimeout(iStdTimeout, iConnectRetries);
    // send packet (include current outgoing packet counter and mc addr)
    ConnPacket Pkt;
    Pkt.StatusByte = uint8_t(IPID_Conn) | (fMC ?  0x80 : 0x00);
    Pkt.ProtocolVer = pParent->iVersion;
    Pkt.Nr = fMC ? pParent->iOPacketCounter : iOPacketCounter;
    Pkt.Addr = addr;
    if (pParent->fMultiCast)
        Pkt.MCAddr = pParent->C4NetIOSimpleUDP::getMCAddr();
    else
        Pkt.MCAddr = C4NetIO::addr_t();
    return SendDirect(C4NetIOPacket(&Pkt, sizeof(Pkt), false, addr));
}

References C4NetIOUDP::ConnPacket::Addr, C4NetIOUDP::iOPacketCounter, C4NetIOUDP::IPID_Conn, C4NetIOUDP::iStdTimeout, C4NetIOUDP::ConnPacket::MCAddr, C4NetIOUDP::PacketHdr::Nr, C4NetIOUDP::ConnPacket::ProtocolVer, C4NetIOUDP::SendDirect(), and C4NetIOUDP::PacketHdr::StatusByte.

Here is the call graph for this function:

GetAddr()

const C4NetIO::addr_t& C4NetIOUDP::Peer::GetAddr ( ) const

inline

Definition at line 800 of file C4NetIO.h.

{ return addr; }

References addr.

GetAltAddr()

const C4NetIO::addr_t& C4NetIOUDP::Peer::GetAltAddr ( ) const

inline

Definition at line 801 of file C4NetIO.h.

{ return addr2; }

References addr2.

GetIRate()

int C4NetIOUDP::Peer::GetIRate ( ) const

inline

Definition at line 839 of file C4NetIO.h.

{ return iIRate; }

References iIRate.

Referenced by C4NetIOUDP::GetConnStatistic().

Here is the caller graph for this function:

GetLoss()

int C4NetIOUDP::Peer::GetLoss ( ) const

inline

Definition at line 841 of file C4NetIO.h.

{ return iLoss; }

References iLoss.

GetMCAckPacketCounter()

unsigned int C4NetIOUDP::Peer::GetMCAckPacketCounter ( ) const

inline

Definition at line 824 of file C4NetIO.h.

{ return iMCAckPacketCounter; }

References iMCAckPacketCounter.

Referenced by C4NetIOUDP::ClearMCPackets().

Here is the caller graph for this function:

GetORate()

int C4NetIOUDP::Peer::GetORate ( ) const

inline

Definition at line 840 of file C4NetIO.h.

{ return iORate; }

References iORate.

Referenced by C4NetIOUDP::GetConnStatistic().

Here is the caller graph for this function:

GetTimeout()

C4TimeMilliseconds C4NetIOUDP::Peer::GetTimeout ( )

inline

Definition at line 827 of file C4NetIO.h.

{ return tTimeout; }

References tTimeout.

MultiCast()

bool C4NetIOUDP::Peer::MultiCast ( ) const

inline

Definition at line 821 of file C4NetIO.h.

{ return fMultiCast; }

References fMultiCast.

Referenced by C4NetIOUDP::Broadcast(), and C4NetIOUDP::DoCheck().

Here is the caller graph for this function:

OnClose()

void C4NetIOUDP::Peer::OnClose ( const char *  szReason )

protected

Definition at line 3570 of file C4NetIO.cpp.

{
    // do callback
    C4NetIO::CBClass *pCB = pParent->pCB;
    if (eStatus == CS_Works || (eStatus == CS_Conn && fConnFailCallback))
        if (pCB)
            pCB->OnDisconn(addr, pParent, szReason);
    // set status (this will schedule this peer for deletion)
    eStatus = CS_Closed;
}

References CS_Closed, and C4NetIO::CBClass::OnDisconn().

Here is the call graph for this function:

OnConn()

void C4NetIOUDP::Peer::OnConn ( )

protected

Definition at line 3553 of file C4NetIO.cpp.

{
    // reset timeout
    SetTimeout(TO_INF);
    // set status
    eStatus = CS_Works;
    // do callback
    C4NetIO::CBClass *pCB = pParent->pCB;
    if (pCB && !pCB->OnConn(addr, addr, &PeerAddr, pParent))
    {
        Close("closed");
        return;
    }
    // do packet callback (in case the peer sent data while the connection was in progress)
    CheckCompleteIPackets();
}

References C4NetIOUDP::Close(), C4NetIO::CBClass::OnConn(), and C4NetIO::TO_INF.

Here is the call graph for this function:

OnRecv()

void C4NetIOUDP::Peer::OnRecv

(

const C4NetIOPacket &

Packet

)

Definition at line 3246 of file C4NetIO.cpp.

{
    // statistics
    { CStdLock StatLock(&StatCSec); iIRate += rPacket.getSize() + iUDPHeaderSize; }
    // get packet header
    if (rPacket.getSize()  < sizeof(PacketHdr)) return;
    const PacketHdr *pHdr = getBufPtr<PacketHdr>(rPacket);
    bool fBroadcasted = !!(pHdr->StatusByte & 0x80);
    // save packet nr
    (fBroadcasted ? iRIMCPacketCounter : iRIPacketCounter) = std::max<unsigned int>((fBroadcasted ? iRIMCPacketCounter : iRIPacketCounter), pHdr->Nr);
#ifdef C4NETIOUDP_OPT_RECV_CHECK_IMMEDIATE
    // do check
    if (eStatus == CS_Works)
        Check(false);
#endif
    // what type of packet is it?
    switch (pHdr->StatusByte & 0x7f)
    {
 
    case IPID_Conn:
    {
        // check size
        if (rPacket.getSize() != sizeof(ConnPacket)) break;
        const ConnPacket *pPkt = getBufPtr<ConnPacket>(rPacket);
        // right version?
        if (pPkt->ProtocolVer != pParent->iVersion) break;
        if (!fBroadcasted)
        {
            // Second connection attempt using different address?
            if (!PeerAddr.IsNull() && PeerAddr != pPkt->Addr)
            {
                // Notify peer that he has two addresses to reach this connection.
                AddAddrPacket Pkt;
                Pkt.StatusByte = IPID_AddAddr;
                Pkt.Nr = iOPacketCounter;
                Pkt.Addr = PeerAddr;
                Pkt.NewAddr = pPkt->Addr;
                SendDirect(C4NetIOPacket(&Pkt, sizeof(Pkt), false, addr));
                // But do nothing else - don't interfere with this connection
                break;
            }
            // reinit?
            else if (eStatus == CS_Works && iIPacketCounter != pPkt->Nr)
            {
                // close (callback!) ...
                OnClose("reconnect"); eStatus = CS_Closed;
                // ... and reconnect
                Connect(false);
            }
            // save back the address the peer is using
            PeerAddr = pPkt->Addr;
        }
        // set packet counter
        if (fBroadcasted)
            iRIMCPacketCounter = iIMCPacketCounter = pPkt->Nr;
        else
            iRIPacketCounter = iIPacketCounter = pPkt->Nr;
        // clear incoming packets
        IPackets.Clear();
        IMCPackets.Clear();
        
        tNextReCheck = C4TimeMilliseconds::NegativeInfinity;
 
        iLastPacketAsked = iLastMCPacketAsked = 0;
        // Activate Multicast?
        if (!pParent->fMultiCast)
        {
            addr_t MCAddr = pPkt->MCAddr;
            if (!MCAddr.IsNull())
            {
                // Init Broadcast (with delayed loopback test)
                pParent->fDelayedLoopbackTest = true;
                if (!pParent->InitBroadcast(&MCAddr))
                    pParent->fDelayedLoopbackTest = false;
            }
        }
        // build ConnOk Packet
        ConnOKPacket nPack;
        bool fullyConnected = false;
 
        nPack.StatusByte = IPID_ConnOK; // (always du, no mc experiments here)
        nPack.Nr = fBroadcasted ? pParent->iOPacketCounter : iOPacketCounter;
        nPack.Addr = addr;
        if (fBroadcasted)
            nPack.MCMode = ConnOKPacket::MCM_MCOK; // multicast send ok
        else if (pParent->fMultiCast && addr.GetPort() == pParent->iPort)
            nPack.MCMode = ConnOKPacket::MCM_MC; // du ok, try multicast next
        else
        {
            nPack.MCMode = ConnOKPacket::MCM_NoMC; // du ok
            // no multicast => we're fully connected now
            fullyConnected = true;
        }
        // send it
        SendDirect(C4NetIOPacket(&nPack, sizeof(nPack), false, addr));
        // Clients will try sending data from OnConn, so send ConnOK before that.
        if (fullyConnected) OnConn();
    }
    break;
 
    case IPID_ConnOK:
    {
        if (eStatus != CS_Conn) break;
        // check size
        if (rPacket.getSize() != sizeof(ConnOKPacket)) break;
        const ConnOKPacket *pPkt = getBufPtr<ConnOKPacket>(rPacket);
        // save port
        PeerAddr = pPkt->Addr;
        // Needs another Conn/ConnOK-sequence?
        switch (pPkt->MCMode)
        {
        case ConnOKPacket::MCM_MC:
            // multicast has to be active
            if (pParent->fMultiCast)
            {
                // already trying to connect via multicast?
                if (fMultiCast) break;
                // Send another Conn packet back (this time broadcasted to check if multicast works)
                fMultiCast = true; DoConn(true);
                break;
            }
            // fallthru
        case ConnOKPacket::MCM_NoMC:
            // Connection is established (no multicast support)
            fMultiCast = false; OnConn();
            break;
        case ConnOKPacket::MCM_MCOK:
            // Connection is established (multicast support)
            fMultiCast = true; OnConn();
            break;
        }
    }
    break;
 
    case IPID_Data:
    {
        // get the packet header
        if (rPacket.getSize() < sizeof(DataPacketHdr)) return;
        const DataPacketHdr *pHdr = getBufPtr<DataPacketHdr>(rPacket);
        // already complet?
        if (pHdr->Nr < (fBroadcasted ? iIMCPacketCounter : iIPacketCounter)) break;
        // find or create packet
        bool fAddPacket = false;
        PacketList *pPacketList = fBroadcasted ? &IMCPackets : &IPackets;
        Packet *pPkt = pPacketList->GetPacket(pHdr->FNr);
        if (!pPkt) { pPkt = new Packet(); fAddPacket = true; }
        // add the fragment
        if (pPkt->AddFragment(rPacket, addr))
        {
            // add the packet to list
            if (fAddPacket) if (!pPacketList->AddPacket(pPkt)) { delete pPkt; break; }
            // check for complete packets
            CheckCompleteIPackets();
        }
        else
            // delete the packet
            if (fAddPacket) delete pPkt;
    }
    break;
 
    case IPID_Check:
    {
        // get the packet header
        if (rPacket.getSize() < sizeof(CheckPacketHdr)) break;
        const CheckPacketHdr *pPkt = getBufPtr<CheckPacketHdr>(rPacket);
        // check packet size
        if (rPacket.getSize() < sizeof(CheckPacketHdr) + (pPkt->AskCount + pPkt->MCAskCount) * sizeof(int)) break;
        // clear all acknowledged packets
        CStdLock OutLock(&OutCSec);
        OPackets.ClearPackets(pPkt->AckNr);
        if (pPkt->MCAckNr > iMCAckPacketCounter)
        {
            iMCAckPacketCounter = pPkt->MCAckNr;
            pParent->ClearMCPackets();
        }
        OutLock.Clear();
        // read ask list
        const int *pAskList = getBufPtr<int>(rPacket, sizeof(CheckPacketHdr));
        // send the packets he asks for
        unsigned int i;
        for (i = 0; i < pPkt->AskCount + pPkt->MCAskCount; i++)
        {
            // packet available?
            bool fMCPacket = i >= pPkt->AskCount;
            CStdLock OutLock(fMCPacket ? &pParent->OutCSec : &OutCSec);
            Packet *pPkt2Send = (fMCPacket ? pParent->OPackets : OPackets).GetPacketFrgm(pAskList[i]);
            if (!pPkt2Send) { Close("starvation"); break; }
            // send the fragment
            if (fMCPacket)
                pParent->BroadcastDirect(*pPkt2Send, pAskList[i]);
            else
                SendDirect(*pPkt2Send, pAskList[i]);
        }
    }
    break;
 
    case IPID_Close:
    {
        // check packet size
        if (rPacket.getSize() < sizeof(ClosePacket)) break;
        const ClosePacket *pPkt = getBufPtr<ClosePacket>(rPacket);
        // ignore if it's for another address
        if (!PeerAddr.IsNull() && PeerAddr != pPkt->Addr)
            break;
        // close
        OnClose("connection closed by peer");
    }
    break;
 
    }
}

References C4NetIOUDP::CheckPacketHdr::AckNr, C4NetIOUDP::Packet::AddFragment(), C4NetIOUDP::PacketList::AddPacket(), C4NetIOUDP::ConnPacket::Addr, C4NetIOUDP::ConnOKPacket::Addr, C4NetIOUDP::AddAddrPacket::Addr, C4NetIOUDP::ClosePacket::Addr, C4NetIOUDP::CheckPacketHdr::AskCount, CStdLock::Clear(), C4NetIOUDP::PacketList::ClearPackets(), C4NetIOUDP::Close(), C4NetIOUDP::Connect(), CS_Closed, C4NetIOUDP::fMultiCast, C4NetIOUDP::DataPacketHdr::FNr, C4NetIOUDP::PacketList::GetPacket(), StdBuf::getSize(), C4NetIOUDP::iOPacketCounter, C4NetIOUDP::IPID_AddAddr, C4NetIOUDP::IPID_Check, C4NetIOUDP::IPID_Close, C4NetIOUDP::IPID_Conn, C4NetIOUDP::IPID_ConnOK, C4NetIOUDP::IPID_Data, C4NetIO::EndpointAddress::IsNull(), C4NetIOUDP::iUDPHeaderSize, C4NetIOUDP::CheckPacketHdr::MCAckNr, C4NetIOUDP::ConnPacket::MCAddr, C4NetIOUDP::CheckPacketHdr::MCAskCount, C4NetIOUDP::ConnOKPacket::MCM_MC, C4NetIOUDP::ConnOKPacket::MCM_MCOK, C4NetIOUDP::ConnOKPacket::MCM_NoMC, C4NetIOUDP::ConnOKPacket::MCMode, C4TimeMilliseconds::NegativeInfinity, C4NetIOUDP::AddAddrPacket::NewAddr, C4NetIOUDP::PacketHdr::Nr, C4NetIOUDP::OPackets, C4NetIOUDP::OutCSec, C4NetIOUDP::Packet, C4NetIOUDP::ConnPacket::ProtocolVer, C4NetIOUDP::SendDirect(), C4NetIOUDP::StatCSec, and C4NetIOUDP::PacketHdr::StatusByte.

Here is the call graph for this function:

OnTimeout()

void C4NetIOUDP::Peer::OnTimeout ( )

protected

Definition at line 3636 of file C4NetIO.cpp.

{
    // what state?
    if (eStatus == CS_Conn)
    {
        // retries left?
        if (iRetries)
        {
            int iRetryCnt = iRetries - 1;
            // call DoConn (will set timeout)
            DoConn(fMultiCast);
            // set retry count
            iRetries = iRetryCnt;
            return;
        }
        // connection timeout: close
        Close("connection timeout");
    }
    // reset timeout
    SetTimeout(TO_INF);
}

References C4NetIOUDP::Close(), C4NetIOUDP::fMultiCast, and C4NetIO::TO_INF.

Here is the call graph for this function:

Open()

bool C4NetIOUDP::Peer::Open ( ) const

inline

Definition at line 817 of file C4NetIO.h.

{ return eStatus == CS_Works; }

References CS_Works, and eStatus.

Referenced by C4NetIOUDP::Broadcast(), C4NetIOUDP::DoCheck(), and C4NetIOUDP::GetConnStatistic().

Here is the caller graph for this function:

Send()

bool C4NetIOUDP::Peer::Send

(

const C4NetIOPacket &

rPacket

)

Definition at line 3188 of file C4NetIO.cpp.

{
    CStdLock OutLock(&OutCSec);
    // encapsulate packet
    Packet *pnPacket = new Packet(rPacket.Duplicate(), iOPacketCounter);
    iOPacketCounter += pnPacket->FragmentCnt();
    pnPacket->GetData().SetAddr(addr);
    // add it to outgoing packet stack
    if (!OPackets.AddPacket(pnPacket))
        return false;
    // This should be ensured by calling function anyway.
    // It is not secure to send packets before the connection
    // is etablished completly.
    if (eStatus != CS_Works) return true;
    // send it
    if (!SendDirect(*pnPacket)) {
        Close("failed to send packet");
        return false;
    }
    return true;
}

References C4NetIOUDP::PacketList::AddPacket(), C4NetIOUDP::Close(), C4NetIOPacket::Duplicate(), C4NetIOUDP::Packet::FragmentCnt(), C4NetIOUDP::Packet::GetData(), C4NetIOUDP::iOPacketCounter, C4NetIOUDP::OPackets, C4NetIOUDP::OutCSec, C4NetIOUDP::Packet, C4NetIOUDP::SendDirect(), and C4NetIOPacket::SetAddr().

Referenced by C4NetIOUDP::Broadcast(), and C4NetIOUDP::Send().

Here is the call graph for this function:

Here is the caller graph for this function:

SendDirect() [1/2]

bool C4NetIOUDP::Peer::SendDirect ( C4NetIOPacket &&  rPacket )

protected

Definition at line 3542 of file C4NetIO.cpp.

{
    // insert correct addr
    C4NetIO::addr_t v6Addr(addr.AsIPv6());
    if (!(rPacket.getStatus() & 0x80)) rPacket.SetAddr(v6Addr);
    // count outgoing
    { CStdLock StatLock(&StatCSec); iORate += rPacket.getSize() + iUDPHeaderSize; }
    // forward call
    return pParent->SendDirect(std::move(rPacket));
}

References C4NetIOUDP::iUDPHeaderSize, and C4NetIOUDP::StatCSec.

SendDirect() [2/2]

bool C4NetIOUDP::Peer::SendDirect ( const Packet &  rPacket, unsigned int  iNr = ~0  )

protected

Definition at line 3530 of file C4NetIO.cpp.

{
    // send one fragment only?
    if (iNr + 1)
        return SendDirect(rPacket.GetFragment(iNr - rPacket.GetNr()));
    // otherwise: send all fragments
    bool fSuccess = true;
    for (unsigned int i = 0; i < rPacket.FragmentCnt(); i++)
        fSuccess &= SendDirect(rPacket.GetFragment(i));
    return fSuccess;
}

References C4NetIOUDP::Packet::FragmentCnt(), C4NetIOUDP::Packet::GetFragment(), C4NetIOUDP::Packet::GetNr(), and C4NetIOUDP::SendDirect().

Here is the call graph for this function:

SetAltAddr()

void C4NetIOUDP::Peer::SetAltAddr ( const C4NetIO::addr_t &  naddr2 )

inline

Definition at line 836 of file C4NetIO.h.

{ addr2 = naddr2; }

References addr2.

SetBroadcast()

void C4NetIOUDP::Peer::SetBroadcast ( bool  fSet )

inline

Definition at line 833 of file C4NetIO.h.

{ fDoBroadcast = fSet; }

References fDoBroadcast.

Referenced by C4NetIOUDP::SetBroadcast().

Here is the caller graph for this function:

SetTimeout()

void C4NetIOUDP::Peer::SetTimeout ( int  iLength = iStdTimeout, int  iRetryCnt = 0  )

protected

Definition at line 3623 of file C4NetIO.cpp.

{
    if (iLength != TO_INF)
    {
        tTimeout = C4TimeMilliseconds::Now() + iLength;
    }
    else
    {
        tTimeout = C4TimeMilliseconds::PositiveInfinity;
    }
    iRetries = iRetryCnt;
}

References C4TimeMilliseconds::Now(), C4TimeMilliseconds::PositiveInfinity, and C4NetIO::TO_INF.

Here is the call graph for this function:

Member Data Documentation

addr

C4NetIO::addr_t C4NetIOUDP::Peer::addr

protected

Definition at line 754 of file C4NetIO.h.

Referenced by GetAddr().

addr2

C4NetIO::addr_t C4NetIOUDP::Peer::addr2

protected

Definition at line 756 of file C4NetIO.h.

Referenced by GetAltAddr(), and SetAltAddr().

eStatus

enum C4NetIOUDP::Peer::ConnStatus C4NetIOUDP::Peer::eStatus

protected

Referenced by Closed(), and Open().

fConnFailCallback

bool C4NetIOUDP::Peer::fConnFailCallback

protected

Definition at line 770 of file C4NetIO.h.

fDoBroadcast

bool C4NetIOUDP::Peer::fDoBroadcast

protected

Definition at line 768 of file C4NetIO.h.

Referenced by doBroadcast(), and SetBroadcast().

fMultiCast

bool C4NetIOUDP::Peer::fMultiCast

protected

Definition at line 766 of file C4NetIO.h.

Referenced by MultiCast().

iConnectRetries

const unsigned int C4NetIOUDP::Peer::iConnectRetries = 5

staticprotected

Definition at line 747 of file C4NetIO.h.

iIMCPacketCounter

unsigned int C4NetIOUDP::Peer::iIMCPacketCounter

protected

Definition at line 779 of file C4NetIO.h.

iIPacketCounter

unsigned int C4NetIOUDP::Peer::iIPacketCounter

protected

Definition at line 778 of file C4NetIO.h.

iIRate

int C4NetIOUDP::Peer::iIRate

protected

Definition at line 795 of file C4NetIO.h.

Referenced by GetIRate().

iLastMCPacketAsked

unsigned int C4NetIOUDP::Peer::iLastMCPacketAsked

protected

Definition at line 788 of file C4NetIO.h.

iLastPacketAsked

unsigned int C4NetIOUDP::Peer::iLastPacketAsked

protected

Definition at line 788 of file C4NetIO.h.

iLoss

int C4NetIOUDP::Peer::iLoss

protected

Definition at line 795 of file C4NetIO.h.

Referenced by GetLoss().

iMCAckPacketCounter

unsigned int C4NetIOUDP::Peer::iMCAckPacketCounter

protected

Definition at line 781 of file C4NetIO.h.

Referenced by GetMCAckPacketCounter().

IMCPackets

PacketList C4NetIOUDP::Peer::IMCPackets

protected

Definition at line 774 of file C4NetIO.h.

iOPacketCounter

unsigned int C4NetIOUDP::Peer::iOPacketCounter

protected

Definition at line 777 of file C4NetIO.h.

iORate

int C4NetIOUDP::Peer::iORate

protected

Definition at line 795 of file C4NetIO.h.

Referenced by GetORate().

IPackets

PacketList C4NetIOUDP::Peer::IPackets

protected

Definition at line 774 of file C4NetIO.h.

iReCheckInterval

const unsigned int C4NetIOUDP::Peer::iReCheckInterval = 1000

staticprotected

Definition at line 748 of file C4NetIO.h.

iRetries

unsigned int C4NetIOUDP::Peer::iRetries

protected

Definition at line 792 of file C4NetIO.h.

iRIMCPacketCounter

unsigned int C4NetIOUDP::Peer::iRIMCPacketCounter

protected

Definition at line 779 of file C4NetIO.h.

iRIPacketCounter

unsigned int C4NetIOUDP::Peer::iRIPacketCounter

protected

Definition at line 778 of file C4NetIO.h.

Next

Peer* C4NetIOUDP::Peer::Next

Definition at line 867 of file C4NetIO.h.

Referenced by C4NetIOUDP::AddPeer(), C4NetIOUDP::Broadcast(), C4NetIOUDP::ClearMCPackets(), C4NetIOUDP::ClearStatistic(), C4NetIOUDP::Close(), C4NetIOUDP::DoCheck(), C4NetIOUDP::Execute(), C4NetIOUDP::GetNextTick(), C4NetIOUDP::GetPeer(), and C4NetIOUDP::OnShareFree().

OPackets

PacketList C4NetIOUDP::Peer::OPackets

protected

Definition at line 773 of file C4NetIO.h.

OutCSec

CStdCSec C4NetIOUDP::Peer::OutCSec

protected

Definition at line 784 of file C4NetIO.h.

PeerAddr

addr_t C4NetIOUDP::Peer::PeerAddr

protected

Definition at line 758 of file C4NetIO.h.

pParent

C4NetIOUDP* const C4NetIOUDP::Peer::pParent

protected

Definition at line 751 of file C4NetIO.h.

StatCSec

CStdCSec C4NetIOUDP::Peer::StatCSec

protected

Definition at line 796 of file C4NetIO.h.

tNextReCheck

C4TimeMilliseconds C4NetIOUDP::Peer::tNextReCheck

protected

Definition at line 787 of file C4NetIO.h.

tTimeout

C4TimeMilliseconds C4NetIOUDP::Peer::tTimeout

protected

Definition at line 791 of file C4NetIO.h.

Referenced by GetTimeout().

---

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

• C4NetIO.h
• C4NetIO.cpp