src/network/nNetObject.cpp File Reference

#include "tMemManager.h"
#include "nNetObject.h"
#include "tLocale.h"
#include "nSimulatePing.h"
#include "tSysTime.h"
#include "tToDo.h"
#include "nObserver.h"
#include "nConfig.h"
#include "tRecorder.h"
#include <deque>
#include <set>
#include <map>
#include "nPriorizing.h"

Include dependency graph for nNetObject.cpp:

Go to the source code of this file.

Classes
struct	nDeletedInfo
struct	nDestroyInfo
class	nWaitForAckSync
Defines
#define	ID_PREFETCH   50
Typedefs
typedef std::map< nNetObjectID, nDeletedInfo >	nDeletedInfos
Functions
	tDEFINE_REFOBJ (nNetObject) int sn_pingCharityServer=0
static unsigned short	inc_id ()
static bool	free_server (nNetObjectID id)
static unsigned short	next_free_server_nokill ()
static int	kill_id_hog ()
static void	kill_id_hog_todo ()
static unsigned short	next_free_server (bool kill)
void	req_id_handler (nMessage &m)
void	id_req_handler (nMessage &m)
unsigned short	next_free ()
void	first_fill_ids ()
void	Cheater (int i)
bool	sn_Update (unsigned short &old, unsigned short n)
bool	sn_Update (unsigned long &old, unsigned long n)
bool	sn_WasDeletedLocally (unsigned short id)
static void	net_destroy_handler (nMessage &m)
static void	sn_DoDestroy ()
static void	net_control_handler (nMessage &m)
static void	net_sync_handler (nMessage &m)
static void	ready_handler (nMessage &m)
static void	net_clear_handler (nMessage &m)
void	ClearKnows (int user, bool clear)
static void	login_callback ()
static void	sync_ack_handler (nMessage &m)
static void	sync_msg_handler (nMessage &m)
void	sn_Sync (REAL timeout, bool sync_sn_netObjects, bool otherEnd)
void	clear_owners ()
Variables
static unsigned short	net_current_id = 1
static const unsigned short	net_max_current_id_max = 32000
static const unsigned short	net_max_current_id_min = 16000
static unsigned short	net_max_current_id = net_max_current_id_min
unsigned short	net_reserved_id [ID_PREFETCH]
unsigned short	distribute = 0
unsigned short	request = 0
tArray< unsigned short >	sn_netObjectsOwner
static std::deque< nNetObjectID >	sn_freedIDs
static tArray< bool >	sn_netObjects_AcceptClientSync
tArray< tJUST_CONTROLLED_PTR < nNetObject > >	sn_netObjects (1024)
static const REAL	nDeletedTimeout = 60.0f
static nDeletedInfos	sn_netObjectsDeleted
static bool	sg_todoKillHog = false
nDescriptor	req_id (20, req_id_handler,"req_id")
nDescriptor	id_req (21, id_req_handler,"id_req_handler")
static nNetObjectRegistrar *	sn_Registrar = NULL
static tArray< nDestroyInfo >	sn_Destroyed
static std::set< unsigned short >	sn_LocallyDestroyedIDs
static nCallbackReceivedComplete	sn_ReceivedComplete (sn_DoDestroy)
static nDescriptor	net_destroy (22, net_destroy_handler,"net_destroy")
static tJUST_CONTROLLED_PTR < nMessage >	destroyers [MAXCLIENTS+2]
static REAL	destroyersTime [MAXCLIENTS+2]
static tList< nNetObject >	sn_SyncRequestedObject
bool	deb_net
static nDescriptor	net_control (23, net_control_handler,"net_control")
static nDescriptor	net_sync (24, net_sync_handler,"net_sync")
static bool	is_ready_to_get_objects [MAXCLIENTS+2]
static bool	s_DoPrintDebug = false
static int	sn_syncedUser = -1
static nDescriptor	ready (25, ready_handler,"ready to get objects")
static nDescriptor	net_clear (26, net_clear_handler,"net_clear")
static nCallbackLoginLogout nlc &	login_callback
static bool	sync_ack [MAXCLIENTS+2]
static unsigned short	c_sync = 0
static nDescriptor	sync_ack_nd (27, sync_ack_handler,"sync_ack")
static nDescriptor	sync_nd (28, sync_msg_handler,"sync_msg")

---

Define Documentation

#define ID_PREFETCH   50

Definition at line 105 of file nNetObject.cpp.

Referenced by first_fill_ids(), id_req_handler(), kill_id_hog(), next_free(), and req_id_handler().

---

Typedef Documentation

typedef std::map< nNetObjectID, nDeletedInfo > nDeletedInfos

Definition at line 154 of file nNetObject.cpp.

---

Function Documentation

void Cheater

(

int

i

)

Definition at line 530 of file nNetObject.cpp.

References con, sn_Connections, and sn_DisconnectUser().

Referenced by nAuthentication::HandlePasswordRequest(), nNOInitialisator< T >::Init(), net_control_handler(), net_sync_handler(), new_destination_handler(), nNetObject::Object(), nNetObject::Register(), req_id_handler(), and sn_DoDestroy().

{
    // anything to do at all?
    if (i != 0 && !sn_Connections[i].socket)
    {
        return;
    }

    con << "User " << i << " tried to cheat.\n";
    //  st_Breakpoint();

    if ( i == 0 )
        // terminate connection to server
        throw tGenericException("There was a network error, the connection to the server had to be terminated.", "Network Error");
    else
        sn_DisconnectUser(i, "$network_kill_cheater" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void clear_owners

(

)

Definition at line 2025 of file nNetObject.cpp.

References GrowingArrayBase::Len(), and sn_netObjectsOwner.

                   {
    sn_freedIDs.clear();
    for (int i=sn_netObjectsOwner.Len()-1;i>=0;i--)
        sn_netObjectsOwner(i)=0;
}

Here is the call graph for this function:

void ClearKnows	(	int	user,
		bool	clear
	)

Definition at line 1795 of file nNetObject.cpp.

References nNetObject::ClearKnows(), GrowingArrayBase::Len(), and sn_netObjectsOwner.

                                     {
    nNetObject::ClearKnows(user, clear);

    if (clear)
        for (int i=sn_netObjectsOwner.Len()-1;i>=0;i--){
            if (sn_netObjectsOwner(i)==user)
                sn_netObjectsOwner(i)=0;
        }
}

Here is the call graph for this function:

void first_fill_ids

(

)

Definition at line 518 of file nNetObject.cpp.

References ID_PREFETCH, id_req, nCLIENT, request, sn_GetNetState(), and tERR_ERROR.

Referenced by login_accept_handler(), and net_clear_handler().

                     {
    if (sn_GetNetState()!=nCLIENT)
        tERR_ERROR("first_fill_ids is only for clients!");

    distribute=request=0;

    tJUST_CONTROLLED_PTR< nMessage > m = new nMessage(id_req);
    m->Write(ID_PREFETCH - 10);
    m->Send(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool free_server

(

nNetObjectID

id

)

[static]

Definition at line 157 of file nNetObject.cpp.

References nDeletedInfo::object_, sn_netObjects, nDeletedInfo::time_, tSysTimeFloat(), and nDeletedInfo::UnSet().

Referenced by next_free_server_nokill().

{
    if ( bool(sn_netObjectsOwner[id]) || bool(sn_netObjects[id]) )
    {
        return false;
    }

    nDeletedInfos::iterator found = sn_netObjectsDeleted.find( id );
    if ( found != sn_netObjectsDeleted.end() )
    {
        nDeletedInfo  & deleted = (*found).second;
        if ( deleted.time_ > tSysTimeFloat() - nDeletedTimeout )
        {
            return false;
        }

        if ( deleted.object_ )
        {
#ifdef DEBUG
            sn_BreakOnObjectID( id );
#endif
            // clear the deletion info, but don't reuse the ID just yet
            deleted.UnSet();
            return false;
        }
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void id_req_handler

(

nMessage &

m

)

Definition at line 396 of file nNetObject.cpp.

References nMessage::End(), ID_PREFETCH, MAXCLIENTS, next_free_server(), nSERVER, nMessage::Read(), req_id, nMessage::SenderID(), and sn_GetNetState().

                                {
    // Add security: keep clients from fetching too many ids

    if (sn_GetNetState()==nSERVER && m.SenderID()<=MAXCLIENTS)
    {
        if (m.End())
        { // old style request; send only one ID back.
            tJUST_CONTROLLED_PTR< nMessage > rep=new nMessage(req_id);
            unsigned short id=next_free_server(true);
            sn_netObjectsOwner[id]=m.SenderID();
            //    con << "Assigning ID " << id << "\n";
            rep->Write(id);
            rep->Send(m.SenderID());

#ifdef DEBUG
            //con << "distributed id " << net_current_id-1 << " to user " << m.SenderID() << '\n';
#endif
        }
        else
        {
            // new style request: many IDs
            unsigned short num;
            m.Read(num);

            // but not too many. kick violators.
            if ( num > ID_PREFETCH*4 )
            {
                throw nKillHim();
            }

            tJUST_CONTROLLED_PTR< nMessage > rep=new nMessage(req_id);

            unsigned short begin_block=0;       // begin of the block of currently assigned IDs
            unsigned short block_len=0;         // and it's length

            for (int i = num-1; i>=0; i--)
            {
                nNetObjectID id = next_free_server(true);

                sn_netObjectsOwner[id]=m.SenderID();

                if (begin_block + block_len == id)      // RLE for allocated IDs
                    block_len++;
                else
                {
                    if (block_len > 0)
                    {
                        //                    con << "Assigning block " << begin_block << " - " << begin_block + block_len - 1 << "\n";
                        rep->Write(begin_block);
                        rep->Write(block_len);
                    }
                    begin_block = id;
                    block_len = 1;
                }
            }
            if (block_len > 0)
            {
                //            con << "Assigning block " << begin_block << " - " << begin_block + block_len - 1 << "\n";
                rep->Write(begin_block);
                rep->Write(block_len);
            }

            rep->Send(m.SenderID());
        }
    }
}

Here is the call graph for this function:

static unsigned short inc_id

(

)

[static]

Definition at line 92 of file nNetObject.cpp.

References net_max_current_id.

Referenced by next_free_server_nokill().

                              {
    unsigned short ret=net_current_id++;

    if ( net_current_id > net_max_current_id )
    {
        net_current_id = 1;
    }

    if (net_current_id==0)
        net_current_id++;
    return ret;
}

Here is the caller graph for this function:

static int kill_id_hog

(

)

[static]

Definition at line 239 of file nNetObject.cpp.

References con, ID_PREFETCH, GrowingArrayBase::Len(), MAXCLIENTS, sn_DisconnectUser(), sn_netObjects, sn_netObjectsOwner, and st_Breakpoint().

Referenced by kill_id_hog_todo().

{
    int i;
    int grabbedIDs[MAXCLIENTS+2];
    int usedIDs[MAXCLIENTS+2];

    for ( i = MAXCLIENTS+1; i>=0; --i )
    {
        grabbedIDs[i] = 0;
        usedIDs[i] = 0;
    }

    // find out how many IDs a user has reserved with or without using them
    for ( i = sn_netObjectsOwner.Len()-1; i>=0; --i )
    {
        int owner = sn_netObjectsOwner( i );
        if ( owner >= 0 && owner <= MAXCLIENTS )
        {
            if ( sn_netObjects[i] )
            {
                usedIDs[ owner ] ++;
            }
            else if ( owner > 0 )
            {
                grabbedIDs[ owner ] ++;
            }
        }
    }

    // find the user with most used/grabbed IDs
    int maxGrabbed = 2 * ID_PREFETCH + 1;
    int maxUsed = 0;
    int maxGrabbedUser = -1;
    int maxUsedUser = -1;

    for ( i = MAXCLIENTS+1; i > 0; --i )
    {
        if ( grabbedIDs[i] > maxGrabbed )
        {
            maxGrabbedUser = i;
            maxGrabbed = grabbedIDs[i];
        }

        if ( usedIDs[i] > maxUsed )
        {
            maxUsedUser = i;
            maxUsed = usedIDs[i];
        }
    }

    // kick the top grabber
    if ( maxGrabbedUser > 0 )
    {
        con << "Killing top ID grabber.\n";
        st_Breakpoint();
        sn_DisconnectUser( maxGrabbedUser, "$network_kill_maxidgrabber" );
        return maxGrabbedUser;
    }

    // kick the top user
    else if ( maxUsedUser > 0 )
    {
        con << "Killing top ID user.\n";
        st_Breakpoint();
        sn_DisconnectUser( maxUsedUser, "$network_kill_maxiduser" );
        return maxUsedUser;
    }

    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void kill_id_hog_todo

(

)

[static]

Definition at line 312 of file nNetObject.cpp.

References kill_id_hog().

Referenced by next_free_server().

{
    if ( sg_todoKillHog )
        kill_id_hog();
    sg_todoKillHog=false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void login_callback

(

)

[static]

Definition at line 1857 of file nNetObject.cpp.

References nNetObject::ClearKnows(), nCallbackLoginLogout::Login(), NULL, nNetObject::RelabelOnConnect(), tArray< T, MALLOC >::SetLen(), and nCallbackLoginLogout::User().

                            {
    int user = nCallbackLoginLogout::User();
    ClearKnows( user, !nCallbackLoginLogout::Login() );

    if ( user == 0 )
    {
        if (nCallbackLoginLogout::Login())
            nNetObject::RelabelOnConnect();
        else
        {
            sn_Destroyed.SetLen(0);
            sn_LocallyDestroyedIDs.clear();
        }
    }

    // send and delete the  remaining destroyer message
    if ( destroyers[user] )
    {
        destroyers[user]->Send(user);
        destroyers[user]=NULL;
    }
}

Here is the call graph for this function:

static void net_clear_handler

(

nMessage &

m

)

[static]

Definition at line 1712 of file nNetObject.cpp.

References nNetObject::ClearAll(), first_fill_ids(), nSERVER, and sn_GetNetState().

                                          {
    if (sn_GetNetState()!=nSERVER){
        nNetObject::ClearAll();
        first_fill_ids();
    }
}

Here is the call graph for this function:

static void net_control_handler

(

nMessage &

m

)

[static]

Definition at line 1376 of file nNetObject.cpp.

References Cheater(), nNetObject::id, nSERVER, nNetObject::Owner(), nMessage::Read(), nNetObject::ReceiveControlNet(), nMessage::SenderID(), sn_GetNetState(), and sn_netObjects.

                                            {
    //con << "control\n";
    if (sn_GetNetState()==nSERVER){
        unsigned short id;
        m.Read(id);
        nNetObject *o = sn_netObjects[id];
        if ( o ){
            if (m.SenderID()==o->Owner()) // only the owner is
                // allowed to control the object
                o->ReceiveControlNet(m);
            else
                Cheater(m.SenderID()); // another lame cheater.
        }
    }
}

Here is the call graph for this function:

static void net_destroy_handler

(

nMessage &

m

)

[static]

Definition at line 872 of file nNetObject.cpp.

References nDestroyInfo::actionOnDeleteExecuted, nMessage::End(), nDestroyInfo::id, nNetObject::id, GrowingArrayBase::Len(), nMessage::Read(), nDestroyInfo::sender, nMessage::SenderID(), tArray< T, MALLOC >::SetLen(), sn_netObjects, sn_WasDeletedLocally(), tASSERT, nDestroyInfo::timeout, and tSysTimeFloat().

                                            {
    //con << "destroy begin\n";
    unsigned short id;
    //int count=0;
    while (!m.End()){
        m.Read(id);
#ifdef DEBUG
        sn_BreakOnObjectID( id );
#endif
        // see if there was a local destruction; if yes, ignore.
        if (sn_WasDeletedLocally( id ))
            continue;

        nDestroyInfo& info = sn_Destroyed[ sn_Destroyed.Len() ];
        info.id = id;
        info.sender = m.SenderID();
        info.actionOnDeleteExecuted=false;
        info.timeout=tSysTimeFloat()+nDeletedTimeout;

        // notify object of pending deletion
        if (nNetObject *no=sn_netObjects[id])
        {
            tASSERT( !no->Owned() );

            no->ActionOnDelete();
            info.actionOnDeleteExecuted=true;

            // if the object is now suddenly owned by this machine, there must be a reason.
            // undo the deletion. Whoever did this has now the responsibility for the object.
            if ( no->Owned() )
                sn_Destroyed.SetLen( sn_Destroyed.Len() - 1 );
        }

#ifdef DEBUG
        //count ++;
        //con << count;
        //con << " destroying object " << id << " by remote order.\n";
#endif

    }
    //con << "destroy end.\n";
}

Here is the call graph for this function:

static void net_sync_handler

(

nMessage &

m

)

[static]

Definition at line 1470 of file nNetObject.cpp.

References nNetObject::AcceptClientSync(), Cheater(), nNetObject::id, nCLIENT, nNetObject::ObjectDangerous(), nNetObject::Owner(), nMessage::Read(), nNetObject::ReadAll(), nMessage::Reset(), nMessage::SenderID(), sn_GetNetState(), nNetObject::SyncIsNew(), and tERR_ERROR.

                                         {
    unsigned short id;
    m.Read(id);
#ifdef DEBUG
    // sn_BreakOnObjectID( id );
#endif
    nNetObject * obj = nNetObject::ObjectDangerous(id);
    if (obj){
        if (sn_GetNetState()!=nCLIENT &&
                (!obj->AcceptClientSync()
                 || obj->Owner()!=m.SenderID())
           ){
            Cheater(m.SenderID());
#ifdef DEBUG
            tERR_ERROR("sync should only be called client-side!");
#endif
        }
        else if (obj->SyncIsNew(m)){
            m.Reset();
            m.Read(id);
            obj->ReadAll(m, false);
        }
    }
}

Here is the call graph for this function:

unsigned short next_free

(

)

Definition at line 465 of file nNetObject.cpp.

References con, ID_PREFETCH, id_req, nCLIENT, next_free_server(), request, sn_Connections, sn_GetNetState(), sn_netObjects, sn_Receive(), sn_SendPlanned(), nNetObject::SyncAll(), tAdvanceFrame(), tERR_ERROR_INT, and tSysTimeFloat().

Referenced by nNetObject::GetID(), and nNetObject::RelabelOnConnect().

                          {
    unsigned short ret=0;

    do{
        if (sn_GetNetState()==nCLIENT){
            unsigned short need_soon = request + ID_PREFETCH - distribute;
            if (need_soon > ID_PREFETCH)
                need_soon -= ID_PREFETCH;
            if (need_soon < (ID_PREFETCH >> 1))
            {
                tJUST_CONTROLLED_PTR< nMessage > m = new nMessage(id_req);
                m->Write(ID_PREFETCH >> 2);
                m->Send(0);
            }

            double timeout=tSysTimeFloat()+60;
            while (sn_Connections[0].socket && distribute==request && tSysTimeFloat()<timeout){
                // wait for new ids from the server
#ifdef DEBUG
                // con << distribute << ":" << request << '\n';
#endif
                sn_Receive();
                nNetObject::SyncAll();
                sn_SendPlanned();
                //      st_Breakpoint();
                tAdvanceFrame(1000000);
            }
            if (tSysTimeFloat()>=timeout)
                tERR_ERROR_INT("Not enough nNetObject IDs to distribute. Sorry!\n");

            ret=net_reserved_id[distribute];

            distribute++;
            if (distribute>=ID_PREFETCH)
                distribute=0;
            //      con << "used id " << ret << '\n';
            net_current_id=ret+1;
        }
        else
        {
            ret=next_free_server(false);
        }

        if (sn_netObjects[ret]){
            con << "Warning! Network id assignment error on ID " << ret << " belonging to client " << sn_netObjects[ret]->Owner() << "\n";
            ret=0;
        }

    }while (ret==0 && sn_Connections[0].socket);

    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned short next_free_server

(

bool

kill

)

[static]

Definition at line 319 of file nNetObject.cpp.

References con, increase(), kill_id_hog_todo(), net_max_current_id, next_free_server_nokill(), and st_ToDo().

Referenced by id_req_handler(), and next_free().

                                                   {
    nNetObjectID id = next_free_server_nokill();
    if ( id > 0 )
    {
        return id;
    }
    else
    {
        // plan to kill the worst ID user
        sg_todoKillHog=true;
        st_ToDo( kill_id_hog_todo );

        // increase ID limit
        int increase = 1000;
        if ( net_max_current_id + 2 * increase < net_max_current_id_max )
            net_max_current_id += increase;
        else
            net_max_current_id = net_max_current_id + ( net_max_current_id_max - net_max_current_id );

        id = next_free_server_nokill();
        if ( id > 0 )
        {
            return id;
        }
        else
        {
            // throw an error
            if ( kill )
                throw nKillHim();

            // or just exit silently
            con << "Emergency exit: desperately ran out of IDs.\n";
            exit(-1);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned short next_free_server_nokill

(

)

[static]

Definition at line 187 of file nNetObject.cpp.

References free_server(), inc_id(), net_max_current_id, nSERVER, nSTANDALONE, sn_GetNetState(), and tERR_ERROR.

Referenced by next_free_server().

                                               {
    // slowly decrease max user ID
    if ( net_max_current_id > net_max_current_id_min )
    {
        net_max_current_id--;
        if ( net_current_id > net_max_current_id )
            net_current_id = 1;
    }

    // recycle old used IDs
    while ( sn_freedIDs.size() > 1000 && sn_freedIDs.size() * 20 > net_max_current_id )
    {
        nNetObjectID freedID = sn_freedIDs.front();
        sn_freedIDs.pop_front();
#ifdef DEBUG
        sn_BreakOnObjectID( freedID );
#endif
        sn_netObjectsOwner[freedID] = 0;
    }

    nNetObjectID start_id = net_current_id;
    if (sn_GetNetState()==nSERVER || sn_GetNetState()==nSTANDALONE)
    {
        do
        {
            inc_id();
        }
        while ( !free_server( net_current_id ) && net_current_id != start_id );

        if ( net_current_id != start_id )
        {
            // no problem!
#ifdef DEBUG
            sn_BreakOnObjectID( net_current_id );
#endif
            return net_current_id;
        }
        else
        {
            // we ran out of IDs.
            return 0;
        }
    }

    else
    {
        tERR_ERROR("next_free_server is not available for clients.");
        return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ready_handler

(

nMessage &

m

)

[static]

Definition at line 1701 of file nNetObject.cpp.

References nConnectionInfo::ping, nMessage::SenderID(), sn_Connections, and nPingAverager::Timestep().

{
    is_ready_to_get_objects[m.SenderID()]=true;

    // reset peer's ping, it's probably unreliable
    sn_Connections[m.SenderID()].ping.Timestep(100);
}

Here is the call graph for this function:

void req_id_handler

(

nMessage &

m

)

Definition at line 356 of file nNetObject.cpp.

References Cheater(), con, nMessage::End(), ID_PREFETCH, nMessage::MessageID(), nSERVER, nMessage::Read(), request, nMessage::SenderID(), sn_GetNetState(), and sn_netObjects.

                                {
    unsigned short stop = distribute;
    if (distribute == 0)
        stop = ID_PREFETCH;

    if (sn_GetNetState()==nSERVER)
        Cheater(m.SenderID());
    else{
        while (!m.End())
        {
            unsigned short id, count=1;
            m.Read(id);
            if (!m.End())
                m.Read(count);

            for (unsigned short i=id + count - 1; i>= id && request+1 != stop; i--)
            {
                if (sn_netObjects[i])
                {
                    con << "Warning! Network id receive error on ID " << i << " belonging to client " << sn_netObjects[i]->Owner() << "\n";
                    con << "while recieving ID block " << id << "-" << id+count-1 << " from netmessage " << m.MessageID() << ".\n";

                }
                else
                {
                    net_reserved_id[request] = i;
#ifdef DEBUG
                    // con << "got id " << net_reserved_id[request] << '\n';
#endif
                    request++;
                    if (request>=ID_PREFETCH)
                        request=0;
                }
            }
        }
    }
}

Here is the call graph for this function:

static void sn_DoDestroy

(

)

[static]

Definition at line 915 of file nNetObject.cpp.

References nNetObject::ActionOnDelete(), nDestroyInfo::actionOnDeleteExecuted, Cheater(), nDestroyInfo::id, GrowingArrayBase::Len(), NULL, nNetObject::Owner(), nDestroyInfo::sender, tArray< T, MALLOC >::SetLen(), sn_Destroyed, sn_netObjects, sn_netObjectsOwner, sn_WasDeletedLocally(), tASSERT, nDestroyInfo::timeout, and tSysTimeFloat().

{
#ifdef DEBUG
    static bool recursion = false;
    tASSERT( !recursion );
    recursion = true;
#endif

    for ( int i = sn_Destroyed.Len()-1 ; i>=0; --i )
    {
        nDestroyInfo& info = sn_Destroyed( i );
        unsigned short id = info.id;

        // check if the message timed out
        bool timedOut = ( info.timeout < tSysTimeFloat() );

        // get object
        nNetObject *no=sn_netObjects[id];

        // destroy it!
        if (bool(no) || timedOut){
#ifdef DEBUG
            sn_BreakOnObjectID( id );
#endif
            // see if there was a local destruction; if yes, ignore.
            if (!sn_WasDeletedLocally( id ) && !timedOut )
            {
                if (no->Owner()==info.sender || info.sender==0){
                    sn_netObjectsDeleted [ id ].Set( no );

                    if (!info.actionOnDeleteExecuted)
                        no->ActionOnDelete();

                    sn_netObjects(id)=NULL;
                    sn_netObjectsOwner(id)=0;
                }
                else
                    Cheater(info.sender);
            }

            // delete message by overwriting it with the last message in the array
            int last = sn_Destroyed.Len()-1;
            info = sn_Destroyed( last );
            sn_Destroyed.SetLen( last );
        }
    }
#ifdef DEBUG
    recursion = false;
#endif
}

Here is the call graph for this function:

void sn_Sync	(	REAL	timeout,
		bool	sync_sn_netObjects,
		bool	otherEnd
	)

Definition at line 1901 of file nNetObject.cpp.

References MAXCLIENTS, nCLIENT, nSERVER, nConnectionInfo::PacketLoss(), REAL, sn_Connections, sn_Delay(), sn_GetNetState(), sn_QueueLen(), sn_Receive(), sn_SendPlanned(), nVersionFeature::Supported(), sync_nd, nNetObject::SyncAll(), and tSysTimeFloat().

Referenced by gGame::StateUpdate(), sync_msg_handler(), and gGame::SyncState().

                                                                 {
    nTimeAbsolute endTime=timeout+tSysTimeFloat();

#ifdef DEBUG
    //con << "Start sync...\n";
#endif

    if (sn_GetNetState()==nCLIENT){
        // repeat as often as packet loss suggests: of 100 packets, we want a single lost packet left probability of 1%.
        REAL failureProbability = 1;
        while ( failureProbability > .0001 && timeout > .01 )
        {
            failureProbability *= sn_Connections[0].PacketLoss();
            // con << failureProbability << "\n";

            // server responding to sync request message
            static nVersionFeature sg_ServerSync( 10 );

            // ask server when we're fully synced from his side
            sync_ack[0]=true;
            if ( sg_ServerSync.Supported( 0 ) && otherEnd )
            {
                tJUST_CONTROLLED_PTR< nMessage > m=new nMessage(sync_nd);
                *m << timeout;
                m->Write(sync_sn_netObjects);
                m->Write(c_sync);
                m->Send(0);
                sync_ack[0]=false;
            }
            else
            {
                // repeating the procedure is useless anyway
                failureProbability = 0;
            }

            // wait for all packets to be sent and the sync ack packet to be received
            while ( sn_Connections[0].socket && ( sync_ack[0] == false || sn_Connections[0].ackPending>0 || sn_QueueLen(0)) &&
                    tSysTimeFloat()<endTime){
                sn_Delay();
                sn_Receive();
                if (sync_sn_netObjects)
                    nNetObject::SyncAll();
                sn_SendPlanned();
            }

            // decrease timeout for next try
            timeout *= .5;
            endTime=timeout+tSysTimeFloat();
        }
    }
    else if (sn_GetNetState()==nSERVER){
        for (int user=MAXCLIENTS;user>0;user--){
            sync_ack[user]=false;
            if (sn_Connections[user].socket){
                tJUST_CONTROLLED_PTR< nMessage > m=new nMessage(sync_nd);
                *m << timeout;
                m->Write(sync_sn_netObjects);
                m->Write(c_sync);
                m->Send(user);
            }
        }

        bool goon=true;
        while (goon){
            sn_Delay();
            sn_Receive();
            if (sync_sn_netObjects)
                nNetObject::SyncAll();
            sn_SendPlanned();

            goon=false;
            for (int user=MAXCLIENTS;user>0;user--)
            {
                if (sn_Connections[user].socket &&
                        (!sync_ack[user] || sn_Connections[user].ackPending>0 || sn_QueueLen(user)))
                {
                    goon=true;
                }
            }

            if (tSysTimeFloat()>endTime)
            {
                goon=false;
            }
        }
    }

#ifdef DEBUG
    //con << "Stop sync.\n";
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool sn_Update	(	unsigned long &	old,
		unsigned long	n
	)

Definition at line 674 of file nNetObject.cpp.

                                                  {
    if ( 0 == old )
    {
        old = n;
        return true;
    }

    long diff=old-n;
    if (diff<0){
        old=n;
        return true;
    }
    else
        return false;
}

bool sn_Update	(	unsigned short &	old,
		unsigned short	n
	)

Definition at line 657 of file nNetObject.cpp.

Referenced by gCycle::ReadSync(), nConfItemBase::s_GetConfigMessage(), and nNetObject::SyncIsNew().

                                                    {
    if ( 0 == old )
    {
        old = n;
        return true;
    }

    short diff=old-n;
    if (diff<0){
        old=n;
        return true;
    }
    else
        return false;
}

Here is the caller graph for this function:

bool sn_WasDeletedLocally

(

unsigned short

id

)

Definition at line 845 of file nNetObject.cpp.

Referenced by nNetObject::InitAfterCreation(), net_destroy_handler(), and sn_DoDestroy().

{
    // delete local destruction log, if there was any
    std::set< unsigned short >::iterator found = sn_LocallyDestroyedIDs.find(id);
    if ( found != sn_LocallyDestroyedIDs.end() )
    {
        // yes. Ignore the message and remove the local destroy thing.
        sn_LocallyDestroyedIDs.erase( found );
        return true;
    }

    return false;
}

Here is the caller graph for this function:

static void sync_ack_handler

(

nMessage &

m

)

[static]

Definition at line 1886 of file nNetObject.cpp.

References nNetObject::id, nMessage::Read(), and nMessage::SenderID().

                                         {
    unsigned short id;
    m.Read(id);
    if (id==c_sync)
        sync_ack[m.SenderID()]=true;
}

Here is the call graph for this function:

static void sync_msg_handler

(

nMessage &

m

)

[static]

Definition at line 1993 of file nNetObject.cpp.

References nSERVER, nMessage::Read(), REAL, nMessage::SenderID(), sn_GetNetState(), sn_Sync(), and sync_ack_nd.

                                         {
    static bool recursion=false;
    if (!recursion){
        recursion=true;

        REAL timeout;
        unsigned short sync_sn_netObjects;

        // sync and write sync response
        m >> timeout;
        m.Read(sync_sn_netObjects);
        unsigned short c_sync;
        m.Read(c_sync);

        if (sn_GetNetState()!=nSERVER){
            sn_Sync(timeout+4,sync_sn_netObjects!=0,false);
            tJUST_CONTROLLED_PTR< nMessage > m=new nMessage(sync_ack_nd);
            m->Write(c_sync);
            m->Send(0);
        }
        else
        {
            // no time for syncing! write sync response immediately with low priority so the client
            // gets it as soon as all other things are sent
            tJUST_CONTROLLED_PTR< nMessage > response=new nMessage(sync_ack_nd);
            response->Write(c_sync);
            response->Send(m.SenderID(),10000000);
        }
        recursion=false;
    }
}

Here is the call graph for this function:

tDEFINE_REFOBJ

(

nNetObject

)

[pure virtual]

---

Variable Documentation

unsigned short c_sync = 0 [static]

Definition at line 1884 of file nNetObject.cpp.

bool deb_net

Definition at line 153 of file nNetwork.cpp.

tJUST_CONTROLLED_PTR< nMessage > destroyers[MAXCLIENTS+2] [static]

Definition at line 978 of file nNetObject.cpp.

REAL destroyersTime[MAXCLIENTS+2] [static]

Definition at line 979 of file nNetObject.cpp.

unsigned short distribute = 0

Definition at line 109 of file nNetObject.cpp.

nDescriptor id_req(21, id_req_handler,"id_req_handler")

Referenced by first_fill_ids(), and next_free().

bool is_ready_to_get_objects[MAXCLIENTS+2] [static]

Definition at line 1506 of file nNetObject.cpp.

nCallbackLoginLogout nlc& login_callback [static]

Definition at line 1880 of file nNetObject.cpp.

const REAL nDeletedTimeout = 60.0f [static]

Definition at line 125 of file nNetObject.cpp.

nDescriptor net_clear(26, net_clear_handler,"net_clear") [static]

Referenced by nNetObject::ClearAll().

nDescriptor net_control(23, net_control_handler,"net_control") [static]

Referenced by nNetObject::NewControlMessage().

unsigned short net_current_id = 1 [static]

Definition at line 59 of file nNetObject.cpp.

nDescriptor net_destroy(22, net_destroy_handler,"net_destroy") [static]

Referenced by nNetObject::~nNetObject().

unsigned short net_max_current_id = net_max_current_id_min [static]

Definition at line 72 of file nNetObject.cpp.

Referenced by inc_id(), next_free_server(), and next_free_server_nokill().

const unsigned short net_max_current_id_max = 32000 [static]

Definition at line 63 of file nNetObject.cpp.

const unsigned short net_max_current_id_min = 16000 [static]

Definition at line 68 of file nNetObject.cpp.

unsigned short net_reserved_id[ID_PREFETCH]

Definition at line 108 of file nNetObject.cpp.

nDescriptor net_sync(24, net_sync_handler,"net_sync") [static]

Referenced by nBandwidthTaskSync::DoExecute(), and nNetObject::SyncAll().

nDescriptor ready(25, ready_handler,"ready to get objects") [static]

Referenced by nNetObject::RelabelOnConnect().

nDescriptor req_id(20, req_id_handler,"req_id")

Referenced by id_req_handler().

unsigned short request = 0

Definition at line 109 of file nNetObject.cpp.

Referenced by first_fill_ids(), next_free(), and req_id_handler().

bool s_DoPrintDebug = false [static]

Definition at line 1511 of file nNetObject.cpp.

bool sg_todoKillHog = false [static]

Definition at line 311 of file nNetObject.cpp.

tArray< nDestroyInfo > sn_Destroyed [static]

Definition at line 841 of file nNetObject.cpp.

Referenced by sn_DoDestroy().

std::deque<nNetObjectID> sn_freedIDs [static]

Definition at line 117 of file nNetObject.cpp.

std::set< unsigned short > sn_LocallyDestroyedIDs [static]

Definition at line 842 of file nNetObject.cpp.

tArray<tJUST_CONTROLLED_PTR<nNetObject> > sn_netObjects(1024)

Referenced by nWaitForAckSync::AckExtraAction(), nNetObject::ClearAll(), nNetObject::ClearKnows(), free_server(), nNetObject::GetID(), nNetObject::GetRefcount(), zValidator::isOwner(), zValidator::isTeamOwner(), zShape::joinWithZone(), kill_id_hog(), net_control_handler(), net_destroy_handler(), next_free(), nWaitForAckSync::nWaitForAckSync(), nNetObject::Object(), nNetObject::ObjectDangerous(), zZone::ReadSync(), nNetObject::Register(), nNetObject::RelabelOnConnect(), nNetObject::Release(), req_id_handler(), zSelectorSingleDeadOwner::select(), zSelectorOwnerTeamTeammate::select(), zSelectorOwnerTeam::select(), zSelectorOwner::select(), sn_DoDestroy(), gGame::StateUpdate(), nNetObject::SyncAll(), and nNetObject::~nNetObject().

tArray<bool> sn_netObjects_AcceptClientSync [static]

Definition at line 120 of file nNetObject.cpp.

nDeletedInfos sn_netObjectsDeleted [static]

Definition at line 155 of file nNetObject.cpp.

tArray<unsigned short> sn_netObjectsOwner

Definition at line 113 of file nNetObject.cpp.

Referenced by clear_owners(), nNetObject::ClearAll(), ClearKnows(), nNetObject::ClearKnows(), kill_id_hog(), and sn_DoDestroy().

nCallbackReceivedComplete sn_ReceivedComplete(sn_DoDestroy) [static]

nNetObjectRegistrar* sn_Registrar = NULL [static]

Definition at line 721 of file nNetObject.cpp.

int sn_syncedUser = -1 [static]

Definition at line 1517 of file nNetObject.cpp.

tList< nNetObject > sn_SyncRequestedObject [static]

Definition at line 982 of file nNetObject.cpp.

Referenced by nNetObject::SyncAll().

bool sync_ack[MAXCLIENTS+2] [static]

Definition at line 1883 of file nNetObject.cpp.

nDescriptor sync_ack_nd(27, sync_ack_handler,"sync_ack") [static]

Referenced by sync_msg_handler().

nDescriptor sync_nd(28, sync_msg_handler,"sync_msg") [static]

Referenced by sn_Sync().

---