From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02307.html | 4227 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 4227 insertions(+) create mode 100644 docs/doxygen/nel/a02307.html (limited to 'docs/doxygen/nel/a02307.html') diff --git a/docs/doxygen/nel/a02307.html b/docs/doxygen/nel/a02307.html new file mode 100644 index 00000000..818dda63 --- /dev/null +++ b/docs/doxygen/nel/a02307.html @@ -0,0 +1,4227 @@ + + +NeL: NLNET::CCallbackServer class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLNET::CCallbackServer Class Reference

#include <callback_server.h> +

+

Inheritance diagram for NLNET::CCallbackServer: +

+ +NLNET::CCallbackNetBase +NLNET::CBufServer +NLNET::CBufNetBase + +

Detailed Description

+Server class for layer 3
Author:
Vianney Lecroart

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 44 of file callback_server.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types

enum  TEventType { User = 'U', +Connection = 'C', +Disconnection = 'D' + }
 Type of incoming events (max 256). More...

enum  TRecordingState { Off, +Record, +Replay + }
enum  TThreadStategy { SpreadSockets, +FillThreads + }

Public Member Functions

void addCallbackArray (const TCallbackItem *callbackarray, NLMISC::CStringIdArray::TStringId arraysize)
void authorizeOnly (const char *callbackName, TSockId hostid=InvalidSockId)
uint64 bytesReceived () const
 Returns the number of bytes popped by receive() since the beginning.

uint64 bytesSent () const
 Returns the number of bytes pushed by send() since the beginning.

 CCallbackServer (TRecordingState rec=Off, const std::string &recfilename="", bool recordall=true)
 Constructor.

bool connected () const
 Returns true if the connection is still connected. on server, we always "connected".

void disconnect (TSockId hostid, bool quick=false)
void disconnect (TSockId hostid)
void displayAllMyAssociations ()
void displayReceiveQueueStat (NLMISC::CLog *log=NLMISC::InfoLog)
void displaySendQueueStat (NLMISC::CLog *log=NLMISC::InfoLog, TSockId destid=InvalidSockId)
void displayThreadStat (NLMISC::CLog *log=NLMISC::InfoLog)
bool flush (TSockId destid)
 Force to send all data pending in the send queue.

uint64 getBytesReceived ()
uint64 getBytesSent ()
uint64 getReceiveQueueSize ()
uint32 getSendQueueSize (TSockId destid)
uint64 getSendQueueSize ()
NLMISC::CStringIdArray & getSIDA ()
 Use this function to get the String ID Array needed when you want to create a message.

virtual TSockId getSockId (TSockId hostid=InvalidSockId)
 Returns the sockid (cf. CCallbackClient).

const CInetAddress & hostAddress (TSockId hostid)
 Returns the address of the specified host.

void ignoreAllUnknownId (bool b)
void init (uint16 port)
 Listens on the specified port.

bool isAServer () const
 Returns true if this is a CCallbackServer.

const CInetAddress & listenAddress () const
 Returns the internet address of the listening socket.

uint32 maxExpectedBlockSize () const
 Returns the max size of the received messages (default: 2^31-1).

uint32 maxSentBlockSize () const
 Returns the max size of the sent messages (default: 2^31-1).

uint32 nbConnections () const
 Returns the number of connections (at the last update()).

uint64 newBytesReceived ()
 Returns the number of bytes popped by receive() since the previous call to this method.

uint64 newBytesSent ()
 Returns the number of bytes pushed by send() since the previous call to this method.

void receive (NLMISC::CMemStream &buffer, TSockId *hostid)
void send (const CMessage &buffer, TSockId hostid, bool log=true)
 Sends a message to the specified host.

void setConnectionCallback (TNetCallback cb, void *arg)
 Sets callback for incoming connections (or NULL to disable callback).

void setDefaultCallback (TMsgCallback defaultCallback)
 Sets default callback for unknown message types.

void setDisconnectionCallback (TNetCallback cb, void *arg)
 Sets callback for disconnections (or NULL to disable callback).

void setMaxExpectedBlockSize (sint32 limit)
void setMaxSentBlockSize (sint32 limit)
void setOtherSideAssociations (const char **associationarray, NLMISC::CStringIdArray::TStringId arraysize)
void setSizeFlushTrigger (TSockId destid, sint32 size)
void setTimeFlushTrigger (TSockId destid, sint32 ms)
void update ()
 Update the network (call this method evenly).

void update (sint32 timeout=0)
 Updates the network (call this method evenly).


Protected Member Functions

void addNewThread (CThreadPool &threadpool, CServerBufSock *bufsock)
void * argOfConnectionCallback () const
 Returns the argument of the connection callback.

void * argOfDisconnectionCallback () const
 Returns the argument of the disconnection callback.

void baseUpdate (sint32 timeout=0)
 Used by client and server class.

void checkThreadId () const
TNetCallback connectionCallback () const
 Returns the connection callback.

volatile bool dataAvailableFlag () const
 Return _DataAvailable.

TNetCallback disconnectionCallback () const
 Returns the disconnection callback.

void dispatchNewSocket (CServerBufSock *bufsock)
bool noDelay () const
 Returns the TCP_NODELAY flag.

void processOneMessage ()
 Read a message from the network and process it.

void pushBufferToHost (const NLMISC::CMemStream &buffer, TSockId hostid)
 Pushes a buffer to the specified host's send queue and update (unless not connected).

void pushMessageIntoReceiveQueue (const uint8 *buffer, uint32 size)
void pushMessageIntoReceiveQueue (const std::vector< uint8 > &buffer)
 Push message into receive queue (mutexed).

CSynchronizedFIFO & receiveQueue ()
 Access to the receive queue.

CServerReceiveTask * receiveTask (std::vector< NLMISC::IThread * >::iterator ipt)
 Returns the receive task corresponding to a particular thread.

void setDataAvailableFlag (bool da)
 Sets _DataAvailable.


Protected Attributes

uint64 _BytesReceived
uint64 _BytesSent
std::vector< TCallbackItem > _CallbackArray
TMsgCallback _DefaultCallback
bool _FirstUpdate
NLMISC::CStringIdArray _InputSIDA
bool _IsAServer
TNetCallback _NewDisconnectionCallback
 Used by client and server class.

NLMISC::CStringIdArray _OutputSIDA
uint _ThreadId

Private Member Functions

bool dataAvailable ()
void receive (CMessage &buffer, TSockId *hostid)
 On this layer, you can't call directly receive, It s the update() function that receive and call your callaback.

void send (const NLMISC::CMemStream &buffer, TSockId hostid)
 This function is public in the base class and put it private here because user cannot use it in layer 2.

void sendAllMyAssociations (TSockId to)
 Used by client and server class.


Private Attributes

TNetCallback _ConnectionCallback
 Connection callback.

void * _ConnectionCbArg
 Argument of the connection callback.


Friends

void cbsNewConnection (TSockId from, void *data)
class CListenTask
class CServerBufSock
class CServerReceiveTask
class NLNET::CBufSock
+

Member Enumeration Documentation

+

+ + + + +
+ + +
enum NLNET::CBufNetBase::TEventType [inherited] +
+
+ + + + + +
+   + + +

+Type of incoming events (max 256). +

+

Enumeration values:
+ + + + +
User  +
Connection  +
Disconnection  +
+
+ +

+Definition at line 79 of file buf_net_base.h. +

+

00079 { User = 'U', Connection = 'C', Disconnection = 'D' };
+
+

+ + + + +
+ + +
enum NLNET::CCallbackNetBase::TRecordingState [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + +
Off  +
Record  +
Replay  +
+
+ +

+Definition at line 163 of file callback_net_base.h. +

+

00163 { Off, Record, Replay };
+
+

+ + + + +
+ + +
enum NLNET::CBufServer::TThreadStategy [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + +
SpreadSockets  +
FillThreads  +
+
+ +

+Definition at line 160 of file buf_server.h. +

+

00160 { SpreadSockets, FillThreads };
+
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLNET::CCallbackServer::CCallbackServer ( TRecordingState  rec = Off,
const std::string &  recfilename = "",
bool  recordall = true
) 
+
+ + + + + +
+   + + +

+Constructor. +

+ +

+Definition at line 70 of file callback_server.cpp. +

+References NLNET::cbsNewConnection(), DEFAULT_MAX_SOCKETS_PER_THREADS, DEFAULT_MAX_THREADS, DEFAULT_STRATEGY, and nlassertex. +

+

00070                                                                                                  :
+00071         CCallbackNetBase( rec, recfilename, recordall ),
+00072         CBufServer( DEFAULT_STRATEGY, DEFAULT_MAX_THREADS, DEFAULT_MAX_SOCKETS_PER_THREADS, true, rec==Replay ),
+00073         _ConnectionCallback(NULL),
+00074         _ConnectionCbArg(NULL)
+00075 {
+00076 #ifndef USE_MESSAGE_RECORDER
+00077         nlassertex( rec==Off, ("LNETL3S: The message recorder is disabled at compilation time ; switch the recording state Off") );
+00078 #endif
+00079         
+00080         CBufServer::setDisconnectionCallback (_NewDisconnectionCallback, this);
+00081         CBufServer::setConnectionCallback (cbsNewConnection, this);
+00082 
+00083         _IsAServer = true;
+00084         _DefaultCallback = NULL;
+00085 }
+
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackNetBase::addCallbackArray ( const TCallbackItem *  callbackarray,
NLMISC::CStringIdArray::TStringId  arraysize
)  [inherited]
+
+ + + + + +
+   + + +

+Appends callback array with the specified array. You can add callback only *after* adding the server or the client.

Parameters:
+ + +
arraysize is the number of callback items.
+
+ +

+Definition at line 184 of file callback_net_base.cpp. +

+References NLNET::CCallbackNetBase::_CallbackArray, NLNET::CCallbackNetBase::_OutputSIDA, NLMISC::CStringIdArray::addString(), NLNET::TCallbackItem::Callback, NLNET::CCallbackNetBase::checkThreadId(), nlassert, NLMISC::CStringIdArray::resize(), sint, NLMISC::CStringIdArray::size(), NLMISC::CStringIdArray::TStringId, and uint. +

+Referenced by NLNET::CCallbackClient::CCallbackClient(), NLNET::CCallbackNetBase::CCallbackNetBase(), NLNET::CPacsClient::connect(), NLNET::CNamingClient::connect(), NLNET::CLoginClient::connectToShard(), NLNET::CUnifiedNetwork::init(), NLNET::CLoginServer::init(), and NLNET::_CUniTime::installServer(). +

+

00185 {
+00186         checkThreadId ();
+00187 
+00188         // be sure that the 2 array have the same size
+00189         nlassert (_CallbackArray.size () == (uint)_OutputSIDA.size ());
+00190 
+00191         if (arraysize == 1 && callbackarray[0].Callback == NULL && string("") == callbackarray[0].Key)
+00192         {
+00193                 // it's an empty array, ignore it
+00194                 return;
+00195         }
+00196 
+00197         // resize the array
+00198         sint oldsize = _CallbackArray.size();
+00199 
+00200         _CallbackArray.resize (oldsize + arraysize);
+00201         _OutputSIDA.resize (oldsize + arraysize);
+00202 
+00203 //TOO MUCH MESSAGE      nldebug ("L3NB_CB: Adding %d callback to the array", arraysize);
+00204 
+00205         for (sint i = 0; i < arraysize; i++)
+00206         {
+00207                 CStringIdArray::TStringId ni = oldsize + i;
+00208 //TOO MUCH MESSAGE              nldebug ("L3NB_CB: Adding callback to message '%s', id '%d'", callbackarray[i].Key, ni);
+00209                 // copy callback value
+00210                 
+00211                 _CallbackArray[ni] = callbackarray[i];
+00212                 // add the string to the string id array
+00213                 _OutputSIDA.addString (callbackarray[i].Key, ni);
+00214 
+00215         }
+00216 //      nldebug ("LNETL3NB_CB: Added %d callback Now, there're %d callback associated with message type", arraysize, _CallbackArray.size ());
+00217 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CBufServer::addNewThread ( CThreadPool &  threadpool,
CServerBufSock *  bufsock
)  [protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 958 of file buf_server.cpp. +

+References NLNET::CServerReceiveTask::addNewSocket(), NLNET::CBufServer::CServerReceiveTask, NLNET::CThreadPool, nlassert, nldebug, nlnettrace, and NLNET::CServerBufSock::setOwnerTask(). +

+Referenced by NLNET::CBufServer::dispatchNewSocket(). +

+

00959 {
+00960         nlnettrace( "CBufServer::addNewThread" );
+00961         nlassert( bufsock != NULL );
+00962 
+00963         // Create new task and dispatch the socket to it
+00964         CServerReceiveTask *task = new CServerReceiveTask( this );
+00965         bufsock->setOwnerTask( task );
+00966         task->addNewSocket( bufsock );
+00967 
+00968         // Add a new thread to the pool, with this task
+00969         IThread *thr = IThread::create( task );
+00970         {
+00971                 threadpool.push_back( thr );
+00972                 thr->start();
+00973                 nldebug( "LNETL1: Added a new thread; pool size is %d", threadpool.size() );
+00974                 nldebug( "LNETL1: New socket dispatched to thread %d", threadpool.size()-1 );
+00975         }
+00976 }
+
+

+ + + + +
+ + + + + + + + + +
void* NLNET::CBufServer::argOfConnectionCallback (   )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Returns the argument of the connection callback. +

+ +

+Definition at line 314 of file buf_server.h. +

+References NLNET::CBufServer::_ConnectionCbArg. +

+Referenced by NLNET::CBufServer::dataAvailable(). +

+

00314 { return _ConnectionCbArg; }
+
+

+ + + + +
+ + + + + + + + + +
void* NLNET::CBufNetBase::argOfDisconnectionCallback (   )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Returns the argument of the disconnection callback. +

+ +

+Definition at line 160 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_DisconnectionCbArg. +

+Referenced by NLNET::CBufServer::dataAvailable(), and NLNET::CBufClient::dataAvailable(). +

+

00160 { return _DisconnectionCbArg; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackNetBase::authorizeOnly ( const char *  callbackName,
TSockId  hostid = InvalidSockId
)  [inherited]
+
+ + + + + +
+   + + +

+Sets the callback that you want the other side calls. If it didn't call this callback, it will be disconnected If cb is NULL, we authorize *all* callback. On a client, the hostid must be InvalidSockId (or ommited). On a server, you must provide a hostid. +

+Definition at line 471 of file callback_net_base.cpp. +

+References NLNET::CBufSock::asString(), NLNET::CBufSock::AuthorizedCallback, NLNET::CCallbackNetBase::checkThreadId(), NLNET::CCallbackNetBase::getSockId(), nlassert, nldebug, and NLNET::TSockId. +

+Referenced by NLNET::cbShardValidation(), and NLNET::ClientConnection(). +

+

00472 {
+00473         checkThreadId ();
+00474 
+00475         nldebug ("LNETL3NB: authorizeOnly (%s, %s)", callbackName, hostid->asString().c_str());
+00476 
+00477         hostid = getSockId (hostid);
+00478         
+00479         nlassert (hostid != InvalidSockId);
+00480 
+00481         hostid->AuthorizedCallback = (callbackName == NULL)?"":callbackName;
+00482 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackNetBase::baseUpdate ( sint32  timeout = 0  )  [protected, inherited]
+
+ + + + + +
+   + + +

+Used by client and server class. +

+ +

+Definition at line 328 of file callback_net_base.cpp. +

+References NLNET::CCallbackNetBase::_FirstUpdate, NLNET::CCallbackNetBase::_InputSIDA, NLNET::CCallbackNetBase::_LastMovedStringArray, NLNET::CCallbackNetBase::_LastUpdateTime, NLNET::CCallbackNetBase::checkThreadId(), NLNET::CCallbackNetBase::dataAvailable(), NLMISC::CStringIdArray::getAskedStringArray(), NLMISC::CStringIdArray::getNeedToAskedStringArray(), H_AUTO, NLMISC::CStringIdArray::moveNeedToAskToAskedStringArray(), nlassert, nldebug, NLMISC::nlSleep(), NLNET::CCallbackNetBase::processOneMessage(), NLNET::CCallbackNetBase::send(), NLMISC::CMemStream::serial(), sint32, size, NLMISC::CStringIdArray::TStringId, and NLMISC::TTime. +

+Referenced by update(), and NLNET::CCallbackClient::update(). +

+

00329 {
+00330         H_AUTO(L3UpdateCallbackNetBase);
+00331 
+00332         checkThreadId ();
+00333 
+00334         // slow down the layer H_AUTO (CCallbackNetBase_baseUpdate);
+00335 
+00336         nlassert( timeout >= -1 );
+00337         TTime t0 = CTime::getLocalTime();
+00338 
+00339         //
+00340         // The first time, we init time counters
+00341         //
+00342         if (_FirstUpdate)
+00343         {
+00344 //              nldebug("LNETL3NB: First update()");
+00345                 _FirstUpdate = false;
+00346                 _LastUpdateTime = t0;
+00347                 _LastMovedStringArray = t0;
+00348         }
+00349 
+00350         //
+00351         // Every 1 seconds if we have new unknown association, we ask them to the other side
+00352         //
+00353         if (t0 - _LastUpdateTime >  1000)
+00354         {
+00355 //              nldebug("LNETL3NB: baseUpdate()");
+00356                 _LastUpdateTime = t0;
+00357 
+00358                 const set<string> &sa = _InputSIDA.getNeedToAskedStringArray ();
+00359                 if (!sa.empty ())
+00360                 {
+00361                         CMessage msgout (_InputSIDA, "AA");
+00362                         //nlassert (sa.size () < 65536); // no size limit anymore
+00363                         CStringIdArray::TStringId size = sa.size ();
+00364                         nldebug ("LNETL3NB_ASSOC: I need %d string association, ask them to the other side", size);
+00365                         msgout.serial (size);
+00366                         for (set<string>::iterator it = sa.begin(); it != sa.end(); it++)
+00367                         {
+00368                                 nldebug ("LNETL3NB_ASSOC:  what is the id of '%s'?", (*it).c_str ());
+00369                                 string str(*it);
+00370                                 msgout.serial (str);
+00371                         }
+00372                         // send the message to the other side
+00373                         send (msgout, 0);
+00374                         _InputSIDA.moveNeedToAskToAskedStringArray();
+00375                         _LastMovedStringArray = t0;
+00376                 }
+00377         }
+00378 
+00379         //
+00380         // Every 60 seconds if we have not answered association, we ask again to get them!
+00381         //
+00382         if (!_InputSIDA.getAskedStringArray().empty() && t0 - _LastMovedStringArray > 60000)
+00383         {
+00384                 // we didn't have an answer for the association, resend them
+00385                 const set<string> sa = _InputSIDA.getAskedStringArray ();
+00386                 CMessage msgout (_InputSIDA, "AA");
+00387                 //nlassert (sa.size () < 65536); // no size limit anymore
+00388                 CStringIdArray::TStringId size = sa.size ();
+00389                 nldebug ("LNETL3NB_ASSOC: client didn't answer my asked association, retry! I need %d string association, ask them to the other side", size);
+00390                 msgout.serial (size);
+00391                 for (set<string>::iterator it = sa.begin(); it != sa.end(); it++)
+00392                 {
+00393                         nldebug ("LNETL3NB_ASSOC:  what is the id of '%s'?", (*it).c_str ());
+00394                         string str(*it);
+00395                         msgout.serial (str);
+00396                 }
+00397                 // sends the message to the other side
+00398                 send (msgout, 0);
+00399                 _LastMovedStringArray = t0;
+00400         }
+00401 
+00402         /*
+00403          * timeout -1    =>  read one message in the queue or nothing if no message in queue
+00404          * timeout 0     =>  read all messages in the queue
+00405          * timeout other =>  read all messages in the queue until timeout expired (at least all one time)
+00406          */
+00407 
+00408         bool exit = false;
+00409 
+00410         while (!exit)
+00411         {
+00412                 // process all messages in the queue
+00413                 while (dataAvailable ())
+00414                 {
+00415                         processOneMessage ();
+00416                         if (timeout == -1)
+00417                         {
+00418                                 exit = true;
+00419                                 break;
+00420                         }
+00421                 }
+00422 
+00423                 // need to exit?
+00424                 if (timeout == 0 || (sint32)(CTime::getLocalTime() - t0) > timeout)
+00425                 {
+00426                         exit = true;
+00427                 }
+00428                 else
+00429                 {
+00430                         // enable multithreading on windows :-/
+00431                         // slow down the layer H_AUTO (CCallbackNetBase_baseUpdate_nlSleep);
+00432                         nlSleep (10);
+00433                 }
+00434         }
+00435 
+00436 #ifdef USE_MESSAGE_RECORDER
+00437         _MR_UpdateCounter++;
+00438 #endif
+00439 
+00440 }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CBufServer::bytesReceived (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Returns the number of bytes popped by receive() since the beginning. +

+ +

+Definition at line 255 of file buf_server.h. +

+References NLNET::CBufServer::_BytesPoppedIn, and uint64. +

+Referenced by NLNET::CBufServer::newBytesReceived(). +

+

00255 { return _BytesPoppedIn; }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CBufServer::bytesSent (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Returns the number of bytes pushed by send() since the beginning. +

+ +

+Definition at line 261 of file buf_server.h. +

+References NLNET::CBufServer::_BytesPushedOut, and uint64. +

+Referenced by NLNET::CBufServer::newBytesSent(). +

+

00261 { return _BytesPushedOut; }
+
+

+ + + + +
+ + + + + + + + + +
void NLNET::CCallbackNetBase::checkThreadId (   )  const [protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 533 of file callback_net_base.cpp. +

+Referenced by NLNET::CCallbackNetBase::addCallbackArray(), NLNET::CCallbackNetBase::authorizeOnly(), NLNET::CCallbackNetBase::baseUpdate(), NLNET::CCallbackClient::connect(), connected(), NLNET::CCallbackClient::connected(), dataAvailable(), NLNET::CCallbackClient::dataAvailable(), disconnect(), NLNET::CCallbackClient::disconnect(), NLNET::CCallbackNetBase::displayAllMyAssociations(), flush(), NLNET::CCallbackClient::flush(), getSockId(), NLNET::CCallbackClient::getSockId(), hostAddress(), NLNET::CCallbackNetBase::isAServer(), NLNET::CCallbackNetBase::processOneMessage(), receive(), NLNET::CCallbackClient::receive(), send(), NLNET::CCallbackClient::send(), sendAllMyAssociations(), setConnectionCallback(), setDisconnectionCallback(), NLNET::CCallbackNetBase::setDisconnectionCallback(), NLNET::CCallbackClient::setDisconnectionCallback(), NLNET::CCallbackNetBase::setOtherSideAssociations(), update(), and NLNET::CCallbackClient::update(). +

+

00534 {
+00535 /*      some people use this class in different thread but with a mutex to be sure to have
+00536         no concurent access
+00537         if (getThreadId () != _ThreadId)
+00538         {
+00539                 nlerror ("You try to access to the same CCallbackClient or CCallbackServer with 2 differents thread (%d and %d)", _ThreadId, getThreadId());
+00540         }
+00541 */
+00542 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLNET::CCallbackServer::connected (   )  const [inline, virtual]
+
+ + + + + +
+   + + +

+Returns true if the connection is still connected. on server, we always "connected". +

+ +

+Reimplemented from NLNET::CCallbackNetBase. +

+Definition at line 67 of file callback_server.h. +

+References NLNET::CCallbackNetBase::checkThreadId(). +

+

00067 { checkThreadId (); return true; } 
+
+

+ + + + +
+ + + + + + + + + +
TNetCallback NLNET::CBufServer::connectionCallback (   )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Returns the connection callback. +

+ +

+Definition at line 311 of file buf_server.h. +

+References NLNET::CBufServer::_ConnectionCallback, and NLNET::TNetCallback. +

+Referenced by NLNET::CBufServer::dataAvailable(). +

+

00311 { return _ConnectionCallback; }
+
+

+ + + + +
+ + + + + + + + + +
bool NLNET::CCallbackServer::dataAvailable (   )  [private]
+
+ + + + + +
+   + + +

+Checks if there is some data to receive. Returns false if the receive queue is empty. This is where the connection/disconnection callbacks can be called. +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 283 of file callback_server.cpp. +

+References NLNET::CCallbackNetBase::checkThreadId(). +

+

00284 {
+00285         checkThreadId ();
+00286 
+00287 #ifdef USE_MESSAGE_RECORDER
+00288         if ( _MR_RecordingState != Replay )
+00289         {
+00290 #endif
+00291 
+00292                 // Real dataAvailable()
+00293                 return CBufServer::dataAvailable (); 
+00294 
+00295 #ifdef USE_MESSAGE_RECORDER
+00296         }
+00297         else
+00298         {
+00299                 // Simulated dataAvailable()
+00300                 return CCallbackNetBase::replayDataAvailable();
+00301         }
+00302 #endif
+00303 }
+
+

+ + + + +
+ + + + + + + + + +
volatile bool NLNET::CBufNetBase::dataAvailableFlag (   )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Return _DataAvailable. +

+ +

+Definition at line 206 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_DataAvailable. +

+Referenced by NLNET::CBufServer::dataAvailable(), and NLNET::CBufClient::dataAvailable(). +

+

00206 { return _DataAvailable; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CBufServer::disconnect ( TSockId  hostid,
bool  quick = false
)  [inherited]
+
+ + + + + +
+   + + +

+Disconnect a connection Set hostid to InvalidSockId to disconnect all connections. If hostid is not InvalidSockId and the socket is not connected, the method does nothing. If quick is true, any pending data will not be sent before disconnecting. +

+Definition at line 251 of file buf_server.cpp. +

+References NLNET::CServerReceiveTask::_Connections, NLNET::CBufServer::_ThreadPool, NLNET::CSock::connected(), NLNET::CTcpSock::disconnect(), NLNET::CBufSock::flush(), nlnettrace, NLNET::CBufServer::receiveTask(), NLNET::CBufSock::Sock, and NLNET::TSockId. +

+

00252 {
+00253         nlnettrace( "CBufServer::disconnect" );
+00254         if ( hostid != InvalidSockId )
+00255         {
+00256                 // Disconnect only if physically connected
+00257                 if ( hostid->Sock->connected() )
+00258                 {
+00259                         if ( ! quick )
+00260                         {
+00261                                 hostid->flush();
+00262                         }
+00263                         hostid->Sock->disconnect(); // the connection will be removed by the next call of update()
+00264                 }
+00265         }
+00266         else
+00267         {
+00268                 // Disconnect all
+00269                 CThreadPool::iterator ipt;
+00270                 {
+00271                         CSynchronized<CThreadPool>::CAccessor poolsync( &_ThreadPool );
+00272                         for ( ipt=poolsync.value().begin(); ipt!=poolsync.value().end(); ++ipt )
+00273                         {
+00274                                 CServerReceiveTask *task = receiveTask(ipt);
+00275                                 CConnections::iterator ipb;
+00276                                 {
+00277                                         CSynchronized<CConnections>::CAccessor connectionssync( &task->_Connections );
+00278                                         for ( ipb=connectionssync.value().begin(); ipb!=connectionssync.value().end(); ++ipb )
+00279                                         {
+00280                                                 if ( (*ipb)->Sock->connected() )
+00281                                                 {
+00282                                                         if ( ! quick )
+00283                                                         {
+00284                                                                 (*ipb)->flush();
+00285                                                         }
+00286                                                         (*ipb)->Sock->disconnect();
+00287                                                 }
+00288                                         }
+00289                                 }
+00290                         }
+00291                 }
+00292         }
+00293 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackServer::disconnect ( TSockId  hostid  )  [virtual]
+
+ + + + + +
+   + + +

+Disconnect a connection Set hostid to InvalidSockId to disconnect all connections. If hostid is not InvalidSockId and the socket is not connected, the method does nothing. Before disconnecting, any pending data is actually sent. +

+Reimplemented from NLNET::CCallbackNetBase. +

+Definition at line 246 of file callback_server.cpp. +

+References NLNET::CCallbackNetBase::checkThreadId(), and NLNET::TSockId. +

+Referenced by NLNET::cbWSDisconnectClient(), and NLNET::CUnifiedNetwork::release(). +

+

00247 {
+00248         checkThreadId ();
+00249 
+00250 #ifdef USE_MESSAGE_RECORDER
+00251         if ( _MR_RecordingState != Replay )
+00252         {
+00253 #endif
+00254                 // Disconnect
+00255                 CBufServer::disconnect( hostid );
+00256 
+00257 #ifdef USE_MESSAGE_RECORDER
+00258         }
+00259         // else, no need to manually replay the disconnection, such as in CCallbackClient,
+00260         // it will be replayed during the next update()
+00261 #endif
+00262 }
+
+

+ + + + +
+ + + + + + + + + +
TNetCallback NLNET::CBufNetBase::disconnectionCallback (   )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Returns the disconnection callback. +

+ +

+Definition at line 157 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_DisconnectionCallback, and NLNET::TNetCallback. +

+Referenced by NLNET::CBufServer::dataAvailable(), and NLNET::CBufClient::dataAvailable(). +

+

00157 { return _DisconnectionCallback; }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CBufServer::dispatchNewSocket ( CServerBufSock *  bufsock  )  [protected, inherited]
+
+ + + + + +
+   + + +

+Binds a new socket and send buffer to an existing or a new thread (that starts) Note: this method is called in the listening thread. +

+Definition at line 866 of file buf_server.cpp. +

+References NLNET::CBufServer::_MaxSocketsPerThread, NLNET::CBufServer::_MaxThreads, NLNET::CBufServer::_ThreadPool, NLNET::CBufServer::_ThreadStrategy, NLNET::CServerReceiveTask::addNewSocket(), NLNET::CBufServer::addNewThread(), min, nldebug, nlnettrace, nlwarning, NLNET::CServerReceiveTask::numberOfConnections(), NLNET::CBufServer::receiveTask(), NLNET::CServerBufSock::setOwnerTask(), NLNET::CBufServer::SpreadSockets, and uint. +

+Referenced by NLNET::CListenTask::run(). +

+

00867 {
+00868         nlnettrace( "CBufServer::dispatchNewSocket" );
+00869 
+00870         CSynchronized<CThreadPool>::CAccessor poolsync( &_ThreadPool );
+00871         if ( _ThreadStrategy == SpreadSockets ) 
+00872         {
+00873                 // Find the thread with the smallest number of connections and check if all
+00874                 // threads do not have the same number of connections
+00875                 uint min = 0xFFFFFFFF;
+00876                 uint max = 0;
+00877                 CThreadPool::iterator ipt, iptmin, iptmax;
+00878                 for ( iptmin=iptmax=ipt=poolsync.value().begin(); ipt!=poolsync.value().end(); ++ipt )
+00879                 {
+00880                         uint noc = receiveTask(ipt)->numberOfConnections();
+00881                         if ( noc < min )
+00882                         {
+00883                                 min = noc;
+00884                                 iptmin = ipt;
+00885                         }
+00886                         if ( noc > max )
+00887                         {
+00888                                 max = noc;
+00889                                 iptmax = ipt;
+00890                         }
+00891                 }
+00892 
+00893                 // Check if we make the pool of threads grow (if we have not found vacant room
+00894                 // and if it is allowed to)
+00895                 if ( (poolsync.value().empty()) ||
+00896                          ((min == max) && (poolsync.value().size() < _MaxThreads)) )
+00897                 {
+00898                         addNewThread( poolsync.value(), bufsock );
+00899                 }
+00900                 else
+00901                 {
+00902                         // Dispatch socket to an existing thread of the pool
+00903                         CServerReceiveTask *task = receiveTask(iptmin);
+00904                         bufsock->setOwnerTask( task );
+00905                         task->addNewSocket( bufsock );
+00906 #ifdef NL_OS_UNIX
+00907                         task->wakeUp();
+00908 #endif                  
+00909                         
+00910                         if ( min >= (uint)_MaxSocketsPerThread )
+00911                         {
+00912                                 nlwarning( "LNETL1: Exceeding the maximum number of sockets per thread" );
+00913                         }
+00914                         nldebug( "LNETL1: New socket dispatched to thread %d", iptmin-poolsync.value().begin() );
+00915                 }
+00916 
+00917         }
+00918         else // _ThreadStrategy == FillThreads
+00919         {
+00920                 CThreadPool::iterator ipt;
+00921                 for ( ipt=poolsync.value().begin(); ipt!=poolsync.value().end(); ++ipt )
+00922                 {
+00923                         uint noc = receiveTask(ipt)->numberOfConnections();
+00924                         if ( noc < _MaxSocketsPerThread )
+00925                         {
+00926                                 break;
+00927                         }
+00928                 }
+00929 
+00930                 // Check if we have to make the thread pool grow (if we have not found vacant room)
+00931                 if ( ipt == poolsync.value().end() )
+00932                 {
+00933                         if ( poolsync.value().size() == _MaxThreads )
+00934                         {
+00935                                 nlwarning( "LNETL1: Exceeding the maximum number of threads" );
+00936                         }
+00937                         addNewThread( poolsync.value(), bufsock );
+00938                 }
+00939                 else
+00940                 {
+00941                         // Dispatch socket to an existing thread of the pool
+00942                         CServerReceiveTask *task = receiveTask(ipt);
+00943                         bufsock->setOwnerTask( task );
+00944                         task->addNewSocket( bufsock );
+00945 #ifdef NL_OS_UNIX
+00946                         task->wakeUp();
+00947 #endif                  
+00948                         nldebug( "LNETL1: New socket dispatched to thread %d", ipt-poolsync.value().begin() );
+00949                 }
+00950         }
+00951 }
+
+

+ + + + +
+ + + + + + + + + +
void NLNET::CCallbackNetBase::displayAllMyAssociations (   )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 464 of file callback_net_base.cpp. +

+References NLNET::CCallbackNetBase::_OutputSIDA, NLNET::CCallbackNetBase::checkThreadId(), and NLMISC::CStringIdArray::display(). +

+Referenced by NLNET::CLoginClient::connectToShard(). +

+

00465 {
+00466         checkThreadId ();
+00467 
+00468         _OutputSIDA.display ();
+00469 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackServer::displayReceiveQueueStat ( NLMISC::CLog *  log = NLMISC::InfoLog  )  [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NLNET::CCallbackNetBase. +

+Definition at line 85 of file callback_server.h. +

+

00085 { CBufServer::displayReceiveQueueStat(log); }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackServer::displaySendQueueStat ( NLMISC::CLog *  log = NLMISC::InfoLog,
TSockId  destid = InvalidSockId
)  [inline]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 86 of file callback_server.h. +

+References NLNET::TSockId. +

+

00086 { CBufServer::displaySendQueueStat(log, destid); }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackServer::displayThreadStat ( NLMISC::CLog *  log = NLMISC::InfoLog  )  [inline]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 88 of file callback_server.h. +

+

00088 { CBufServer::displayThreadStat(log); }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLNET::CCallbackServer::flush ( TSockId  destid  )  [inline]
+
+ + + + + +
+   + + +

+Force to send all data pending in the send queue. +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 55 of file callback_server.h. +

+References NLNET::CCallbackNetBase::checkThreadId(), nlassert, and NLNET::TSockId. +

+

00055 { checkThreadId (); nlassert( destid != InvalidSockId ); return CBufServer::flush(destid); }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CCallbackNetBase::getBytesReceived (   )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 88 of file callback_net_base.h. +

+References NLNET::CCallbackNetBase::_BytesReceived, and uint64. +

+Referenced by NLNET::CUnifiedNetwork::getBytesReceived(). +

+

00088 { return _BytesReceived; }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CCallbackNetBase::getBytesSent (   )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 87 of file callback_net_base.h. +

+References NLNET::CCallbackNetBase::_BytesSent, and uint64. +

+Referenced by NLNET::CUnifiedNetwork::getBytesSent(). +

+

00087 { return _BytesSent; }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CCallbackServer::getReceiveQueueSize (   )  [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NLNET::CCallbackNetBase. +

+Definition at line 82 of file callback_server.h. +

+References uint64. +

+Referenced by NLNET::CUnifiedNetwork::getReceiveQueueSize(). +

+

00082 { return CBufServer::getReceiveQueueSize(); }
+
+

+ + + + +
+ + + + + + + + + + +
uint32 NLNET::CBufServer::getSendQueueSize ( TSockId  destid  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 660 of file buf_server.cpp. +

+References NLNET::CServerReceiveTask::_Connections, NLNET::CBufServer::_ThreadPool, NLNET::CBufServer::receiveTask(), NLNET::CBufSock::SendFifo, NLMISC::CBufFIFO::size(), NLNET::TSockId, and uint32. +

+

00661 {
+00662         if ( destid != InvalidSockId )
+00663         {
+00664                 return destid->SendFifo.size();
+00665         }
+00666         else
+00667         {
+00668                 // add all client buffers
+00669 
+00670                 uint32 total = 0;
+00671 
+00672                 // For each thread
+00673                 CThreadPool::iterator ipt;
+00674                 {
+00675                         CSynchronized<CThreadPool>::CAccessor poolsync( &_ThreadPool );
+00676                         for ( ipt=poolsync.value().begin(); ipt!=poolsync.value().end(); ++ipt )
+00677                         {
+00678                                 // For each thread of the pool
+00679                                 CServerReceiveTask *task = receiveTask(ipt);
+00680                                 CConnections::iterator ipb;
+00681                                 {
+00682                                         CSynchronized<CConnections>::CAccessor connectionssync( &task->_Connections );
+00683                                         for ( ipb=connectionssync.value().begin(); ipb!=connectionssync.value().end(); ++ipb )
+00684                                         {
+00685                                                 // For each socket of the thread, update sending
+00686                                                 total = (*ipb)->SendFifo.size ();
+00687                                         }
+00688                                 }
+00689                         }
+00690                 }
+00691                 return total;
+00692         }
+00693 }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CCallbackServer::getSendQueueSize (   )  [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NLNET::CCallbackNetBase. +

+Definition at line 83 of file callback_server.h. +

+References uint64. +

+Referenced by NLNET::CUnifiedNetwork::getSendQueueSize(). +

+

00083 { return CBufServer::getSendQueueSize(0); }
+
+

+ + + + +
+ + + + + + + + + +
NLMISC::CStringIdArray& NLNET::CCallbackNetBase::getSIDA (   )  [inline, inherited]
+
+ + + + + +
+   + + +

+Use this function to get the String ID Array needed when you want to create a message. +

+ +

+Definition at line 129 of file callback_net_base.h. +

+References NLNET::CCallbackNetBase::_InputSIDA. +

+Referenced by NLNET::cbcMessageRecvAllAssociations(), NLNET::cbnbMessageAskAssociations(), NLNET::cbnbMessageRecvAssociations(), NLNET::cbServerAskUniversalTime(), NLNET::cbShardValidation(), NLNET::CLoginClient::connectToShard(), NLNET::CNetDisplayer::doDisplay(), NLNET::CNamingClient::queryServicePort(), NLNET::CNamingClient::registerService(), NLNET::CNamingClient::registerServiceWithSId(), NLNET::CNamingClient::resendRegisteration(), sendAllMyAssociations(), NLNET::CCallbackNetBase::setOtherSideAssociations(), and NLNET::CNamingClient::unregisterService(). +

+

00129 { return _InputSIDA; }
+
+

+ + + + +
+ + + + + + + + + + +
TSockId NLNET::CCallbackServer::getSockId ( TSockId  hostid = InvalidSockId  )  [virtual]
+
+ + + + + +
+   + + +

+Returns the sockid (cf. CCallbackClient). +

+ +

+Implements NLNET::CCallbackNetBase. +

+Definition at line 268 of file callback_server.cpp. +

+References NLNET::CCallbackNetBase::checkThreadId(), nlassert, and NLNET::TSockId. +

+

00269 {
+00270         nlassert (hostid != InvalidSockId);     // invalid hostid
+00271         checkThreadId ();
+00272         nlassert (connected ());
+00273         nlassert (hostid != NULL);
+00274         return hostid;
+00275 }
+
+

+ + + + +
+ + + + + + + + + + +
const CInetAddress& NLNET::CCallbackServer::hostAddress ( TSockId  hostid  )  [inline]
+
+ + + + + +
+   + + +

+Returns the address of the specified host. +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 77 of file callback_server.h. +

+References NLNET::CCallbackNetBase::checkThreadId(), nlassert, and NLNET::TSockId. +

+

00077 { nlassert(hostid!=InvalidSockId); checkThreadId(); return CBufServer::hostAddress (hostid); }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackNetBase::ignoreAllUnknownId ( bool  b  )  [inline, inherited]
+
+ + + + + +
+   + + +

+If you ignore all unknown id, the net will not ask for other side to know new association. It's used in the naming service for example because the naming client will never answer. In this case, it will always send the message with the full string name (slower) +

+Definition at line 157 of file callback_net_base.h. +

+References NLNET::CCallbackNetBase::_InputSIDA, and NLMISC::CStringIdArray::ignoreAllUnknownId(). +

+

00158         {
+00159                 _InputSIDA.ignoreAllUnknownId (b);
+00160         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CBufServer::init ( uint16  port  )  [inherited]
+
+ + + + + +
+   + + +

+Listens on the specified port. +

+ +

+Definition at line 93 of file buf_server.cpp. +

+References NLNET::CBufServer::_ListenTask, NLNET::CBufServer::_ListenThread, NLNET::CBufServer::_ReplayMode, NLNET::CListenTask::init(), NLNET::CBufNetBase::maxExpectedBlockSize(), nldebug, nlnettrace, NLMISC::IThread::start(), and uint16. +

+Referenced by NLNET::CNetManager::addServer(), and NLNET::CUnifiedNetwork::init(). +

+

00094 {
+00095         nlnettrace( "CBufServer::init" );
+00096         if ( ! _ReplayMode )
+00097         {
+00098                 _ListenTask->init( port, maxExpectedBlockSize() );
+00099                 _ListenThread->start();
+00100         }
+00101         else
+00102         {
+00103                 nldebug( "LNETL1: Binding listen socket to any address, port %hu", port );
+00104         }
+00105 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLNET::CCallbackNetBase::isAServer (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Returns true if this is a CCallbackServer. +

+ +

+Definition at line 126 of file callback_net_base.h. +

+References NLNET::CCallbackNetBase::_IsAServer, and NLNET::CCallbackNetBase::checkThreadId(). +

+

00126 { checkThreadId (); return _IsAServer; }
+
+

+ + + + +
+ + + + + + + + + +
const CInetAddress& NLNET::CBufServer::listenAddress (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Returns the internet address of the listening socket. +

+ +

+Definition at line 238 of file buf_server.h. +

+References NLNET::CBufServer::_ListenTask, and NLNET::CListenTask::localAddr(). +

+Referenced by NLNET::CLoginServer::init(), NLNET::NLMISC_DYNVARIABLE(), and NLNET::setListenAddress(). +

+

00238 { return _ListenTask->localAddr(); }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NLNET::CBufNetBase::maxExpectedBlockSize (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Returns the max size of the received messages (default: 2^31-1). +

+ +

+Definition at line 135 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_MaxExpectedBlockSize, and uint32. +

+Referenced by NLNET::CBufClient::connect(), and NLNET::CBufServer::init(). +

+

00136         {
+00137                 return _MaxExpectedBlockSize;
+00138         }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NLNET::CBufNetBase::maxSentBlockSize (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Returns the max size of the sent messages (default: 2^31-1). +

+ +

+Definition at line 141 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_MaxSentBlockSize, and uint32. +

+Referenced by NLNET::CBufServer::send(), and NLNET::CBufClient::send(). +

+

00142         {
+00143                 return _MaxSentBlockSize;
+00144         }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NLNET::CBufServer::nbConnections (   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Returns the number of connections (at the last update()). +

+ +

+Definition at line 267 of file buf_server.h. +

+References NLNET::CBufServer::_NbConnections, and uint32. +

+Referenced by send(). +

+

00267 { return _NbConnections; }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CBufServer::newBytesReceived (   )  [inherited]
+
+ + + + + +
+   + + +

+Returns the number of bytes popped by receive() since the previous call to this method. +

+ +

+Definition at line 749 of file buf_server.cpp. +

+References NLNET::CBufServer::_PrevBytesPoppedIn, NLNET::CBufServer::bytesReceived(), and uint64. +

+

00750 {
+00751         uint64 b = bytesReceived();
+00752         uint64 nbrecvd = b - _PrevBytesPoppedIn;
+00753         //nlinfo( "b: %"NL_I64"u   new: %"NL_I64"u", b, nbrecvd );
+00754         _PrevBytesPoppedIn = b;
+00755         return nbrecvd;
+00756 }
+
+

+ + + + +
+ + + + + + + + + +
uint64 NLNET::CBufServer::newBytesSent (   )  [inherited]
+
+ + + + + +
+   + + +

+Returns the number of bytes pushed by send() since the previous call to this method. +

+ +

+Definition at line 761 of file buf_server.cpp. +

+References NLNET::CBufServer::_PrevBytesPushedOut, NLNET::CBufServer::bytesSent(), and uint64. +

+

00762 {
+00763         uint64 b = bytesSent();
+00764         uint64 nbsent = b - _PrevBytesPushedOut;
+00765         //nlinfo( "b: %"NL_I64"u   new: %"NL_I64"u", b, nbsent );
+00766         _PrevBytesPushedOut = b;
+00767         return nbsent;
+00768 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLNET::CBufServer::noDelay (   )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Returns the TCP_NODELAY flag. +

+ +

+Definition at line 276 of file buf_server.h. +

+Referenced by NLNET::CListenTask::run(). +

+

00276 { return _NoDelay; }
+
+

+ + + + +
+ + + + + + + + + +
void NLNET::CCallbackNetBase::processOneMessage (   )  [protected, inherited]
+
+ + + + + +
+   + + +

+Read a message from the network and process it. +

+ +

+Definition at line 223 of file callback_net_base.cpp. +

+References NLNET::CCallbackNetBase::_BytesReceived, NLNET::CCallbackNetBase::_CallbackArray, NLNET::CCallbackNetBase::_DefaultCallback, NLNET::CCallbackNetBase::_OutputSIDA, NLNET::CBufSock::asString(), NLNET::CBufSock::AuthorizedCallback, NLNET::CCallbackNetBase::checkThreadId(), NLNET::CCallbackNetBase::disconnect(), NLNET::CMessage::getId(), NLNET::CMessage::getName(), NLNET::CCallbackNetBase::getSockId(), NLNET::CMessage::length(), nldebug, nlwarning, NLNET::CCallbackNetBase::receive(), sint16, NLNET::TMsgCallback, NLNET::CMessage::toString(), NLNET::TSockId, NLMISC::CStringIdArray::TStringId, and NLNET::CMessage::TypeHasAnId. +

+Referenced by NLNET::CCallbackNetBase::baseUpdate(). +

+

00224 {
+00225         checkThreadId ();
+00226 
+00227         // slow down the layer H_AUTO (CCallbackNetBase_processOneMessage);
+00228 
+00229         CMessage msgin (_OutputSIDA, "", true);
+00230         TSockId tsid;
+00231         receive (msgin, &tsid);
+00232 
+00233         _BytesReceived += msgin.length ();
+00234         
+00235         // now, we have to call the good callback
+00236         NLMISC::CStringIdArray::TStringId pos = -1;
+00237         if (msgin.TypeHasAnId)
+00238         {
+00239                 pos = msgin.getId ();
+00240         }
+00241         else
+00242         {
+00243                 std::string name = msgin.getName ();
+00244                 sint16 i;
+00245                 for (i = 0; i < (sint16) _CallbackArray.size (); i++)
+00246                 {
+00247                         if (name == _CallbackArray[i].Key)
+00248                         {
+00249                                 pos = i;
+00250                                 break;
+00251                         }
+00252                 }
+00253         }
+00254 
+00255         TMsgCallback    cb = NULL;
+00256         if (pos < 0 || pos >= (sint16) _CallbackArray.size ())
+00257         {
+00258                 if (_DefaultCallback == NULL)
+00259                 {
+00260                         nlwarning ("LNETL3NB_CB: Callback %s not found in _CallbackArray", msgin.toString().c_str());
+00261                 }
+00262                 else
+00263                 {
+00264                         cb = _DefaultCallback;
+00265                 }
+00266         }
+00267         else
+00268         {
+00269                 cb = _CallbackArray[pos].Callback;
+00270         }
+00271 
+00272         TSockId realid = getSockId (tsid);
+00273 
+00274         if (!realid->AuthorizedCallback.empty() && msgin.getName() != realid->AuthorizedCallback)
+00275         {
+00276                 nlwarning ("LNETL3NB_CB: %s try to call the callback %s but only %s is authorized. Disconnect him!", tsid->asString().c_str(), msgin.toString().c_str(), tsid->AuthorizedCallback.c_str());
+00277                 disconnect (tsid);
+00278         }
+00279         else if (cb == NULL)
+00280         {
+00281                 nlwarning ("LNETL3NB_CB: Callback %s is NULL, can't call it", msgin.toString().c_str());
+00282         }
+00283         else
+00284         {
+00285                 nldebug ("LNETL3NB_CB: Calling callback (%s)%s", msgin.getName().c_str(), (cb==_DefaultCallback)?" DEFAULT_CB":"");
+00286                 cb(msgin, realid, *this);
+00287         }
+00288         
+00289 /*
+00290         if (pos < 0 || pos >= (sint16) _CallbackArray.size ())
+00291         {
+00292                 if (_DefaultCallback == NULL)
+00293                         nlwarning ("LNETL3NB_CB: Callback %s not found in _CallbackArray", msgin.toString().c_str());
+00294                 else
+00295                 {
+00296                         // ...
+00297                 }
+00298         }
+00299         else
+00300         {
+00301                 TSockId realid = getSockId (tsid);
+00302 
+00303                 if (!realid->AuthorizedCallback.empty() && msgin.getName() != realid->AuthorizedCallback)
+00304                 {
+00305                         nlwarning ("LNETL3NB_CB: %s try to call the callback %s but only %s is authorized. Disconnect him!", tsid->asString().c_str(), msgin.toString().c_str(), tsid->AuthorizedCallback.c_str());
+00306                         disconnect (tsid);
+00307                 }
+00308                 else if (_CallbackArray[pos].Callback == NULL)
+00309                 {
+00310                         nlwarning ("LNETL3NB_CB: Callback %s is NULL, can't call it", msgin.toString().c_str());
+00311                 }
+00312                 else
+00313                 {
+00314                         nldebug ("LNETL3NB_CB: Calling callback (%s)", _CallbackArray[pos].Key);
+00315                         _CallbackArray[pos].Callback (msgin, realid, *this);
+00316                 }
+00317         }
+00318 */
+00319 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CBufServer::pushBufferToHost ( const NLMISC::CMemStream &  buffer,
TSockId  hostid
)  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Pushes a buffer to the specified host's send queue and update (unless not connected). +

+ +

+Definition at line 298 of file buf_server.h. +

+References NLNET::CBufServer::_BytesPushedOut, buffer, nlassert, NLNET::CBufSock::pushBuffer(), NLNET::TBlockSize, and NLNET::TSockId. +

+Referenced by NLNET::CBufServer::send(). +

+

00299         {
+00300                 nlassert( hostid != InvalidSockId );
+00301                 if ( hostid->pushBuffer( buffer ) )
+00302                 {
+00303                         _BytesPushedOut += buffer.length() + sizeof(TBlockSize); // statistics
+00304                 }
+00305         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CBufNetBase::pushMessageIntoReceiveQueue ( const uint8 *  buffer,
uint32  size
)  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 183 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_RecvFifo, buffer, NLNET::CFifoAccessor, NLNET::CBufNetBase::setDataAvailableFlag(), size, uint32, and uint8. +

+

00184         {
+00185                 //sint32 mbsize;
+00186                 {
+00187                         //nldebug( "BNB: Acquiring the receive queue... ");
+00188                         CFifoAccessor recvfifo( &_RecvFifo );
+00189                         //nldebug( "BNB: Acquired, pushing the received buffer... ");
+00190                         recvfifo.value().push( buffer, size );
+00191                         //nldebug( "BNB: Pushed, releasing the receive queue..." );
+00192                         //mbsize = recvfifo.value().size() / 1048576;
+00193                         setDataAvailableFlag( true );
+00194                 }
+00195                 //nldebug( "BNB: Released." );
+00196                 /*if ( mbsize > 1 )
+00197                 {
+00198                         nlwarning( "The receive queue size exceeds %d MB", mbsize );
+00199                 }*/
+00200         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CBufNetBase::pushMessageIntoReceiveQueue ( const std::vector< uint8 > &  buffer  )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Push message into receive queue (mutexed). +

+ +

+Definition at line 164 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_RecvFifo, buffer, NLNET::CFifoAccessor, and NLNET::CBufNetBase::setDataAvailableFlag(). +

+Referenced by NLNET::CBufSock::advertiseSystemEvent(), and NLNET::CClientReceiveTask::run(). +

+

00165         {
+00166                 //sint32 mbsize;
+00167                 {
+00168                         //nldebug( "BNB: Acquiring the receive queue... ");
+00169                         CFifoAccessor recvfifo( &_RecvFifo );
+00170                         //nldebug( "BNB: Acquired, pushing the received buffer... ");
+00171                         recvfifo.value().push( buffer );
+00172                         //nldebug( "BNB: Pushed, releasing the receive queue..." );
+00173                         //mbsize = recvfifo.value().size() / 1048576;
+00174                         setDataAvailableFlag( true );
+00175                 }
+00176                 //nldebug( "BNB: Released." );
+00177                 //if ( mbsize > 1 )
+00178                 //{
+00179                 //      nlwarning( "The receive queue size exceeds %d MB", mbsize );
+00180                 //}
+00181         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CBufServer::receive ( NLMISC::CMemStream &  buffer,
TSockId *  hostid
)  [inherited]
+
+ + + + + +
+   + + +

+Receives next block of data in the specified (resizes the vector) You must call dataAvailable() before every call to receive() +

+Definition at line 565 of file buf_server.cpp. +

+References NLNET::CBufServer::_BytesPoppedIn, buffer, NLNET::CFifoAccessor, nlassert, NLMISC_BSWAP32, nlnettrace, nlwarning, NLNET::CBufNetBase::receiveQueue(), NLNET::CBufNetBase::setDataAvailableFlag(), NLNET::TBlockSize, NLNET::TSockId, and uint32. +

+

00566 {
+00567         nlnettrace( "CBufServer::receive" );
+00568         //nlassert( dataAvailable() );
+00569         nlassert( phostid != NULL );
+00570         {
+00571                 CFifoAccessor recvfifo( &receiveQueue() );
+00572                 nlassert( ! recvfifo.value().empty() );
+00573                 recvfifo.value().front( buffer );
+00574                 recvfifo.value().pop();
+00575                 setDataAvailableFlag( ! recvfifo.value().empty() );
+00576         }
+00577 
+00578         // Extract hostid (and event type)
+00579         *phostid = *((TSockId*)&(buffer.buffer()[buffer.size()-sizeof(TSockId)-1]));
+00580         nlassert( buffer.buffer()[buffer.size()-1] == CBufNetBase::User );
+00581 
+00582         // debug features, we number all packet to be sure that they are all sent and received
+00583         // \todo remove this debug feature when ok
+00584 #ifdef NL_BIG_ENDIAN
+00585         uint32 val = NLMISC_BSWAP32(*(uint32*)buffer.buffer());
+00586 #else
+00587         uint32 val = *(uint32*)buffer.buffer();
+00588 #endif
+00589 
+00590         //      nldebug ("receive message number %u", val);
+00591         if ((*phostid)->ReceiveNextValue != val)
+00592         {
+00593                 nlwarning ("LNETL1: !!!LOST A MESSAGE!!! I received the message number %u but I'm waiting the message number %u (cnx %s), warn lecroart@nevrax.com with the log now please", val, (*phostid)->ReceiveNextValue, (*phostid)->asString().c_str());
+00594                 // resync the message number
+00595                 (*phostid)->ReceiveNextValue = val;
+00596         }
+00597 
+00598         (*phostid)->ReceiveNextValue++;
+00599 
+00600         buffer.resize( buffer.size()-sizeof(TSockId)-1 );
+00601 
+00602         // TODO OPTIM remove the nldebug for speed
+00603         //commented for optimisation nldebug( "LNETL1: Read buffer (%d+%d B) from %s", buffer.size(), sizeof(TSockId)+1, /*stringFromVector(buffer).c_str(), */(*phostid)->asString().c_str() );
+00604 
+00605         // Statistics
+00606         _BytesPoppedIn += buffer.size() + sizeof(TBlockSize);
+00607 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackServer::receive ( CMessage &  buffer,
TSockId *  hostid
)  [private, virtual]
+
+ + + + + +
+   + + +

+On this layer, you can't call directly receive, It s the update() function that receive and call your callaback. +

+ +

+Implements NLNET::CCallbackNetBase. +

+Definition at line 205 of file callback_server.cpp. +

+References buffer, NLNET::CCallbackNetBase::checkThreadId(), nlassert, NLNET::Receiving, and NLNET::TSockId. +

+

00206 {
+00207         checkThreadId ();
+00208         nlassert (connected ());
+00209 
+00210 #ifdef USE_MESSAGE_RECORDER
+00211         if ( _MR_RecordingState != Replay )
+00212         {
+00213 #endif
+00214 
+00215                 // Receive
+00216                 CBufServer::receive (buffer, hostid);
+00217 
+00218 #ifdef USE_MESSAGE_RECORDER
+00219                 if ( _MR_RecordingState == Record )
+00220                 {
+00221                         // Record received message
+00222                         _MR_Recorder.recordNext( _MR_UpdateCounter, Receiving, *hostid, const_cast<CMessage&>(buffer) );
+00223                 }
+00224         }
+00225         else
+00226         {
+00227                 // Retrieve received message loaded by dataAvailable()
+00228                 buffer = _MR_Recorder.ReceivedMessages.front().Message;
+00229                 *hostid = _MR_Recorder.ReceivedMessages.front().SockId;
+00230                 _MR_Recorder.ReceivedMessages.pop();
+00231         }
+00232 #endif
+00233         
+00234         buffer.readType ();
+00235 }
+
+

+ + + + +
+ + + + + + + + + +
CSynchronizedFIFO& NLNET::CBufNetBase::receiveQueue (   )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Access to the receive queue. +

+ +

+Definition at line 154 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_RecvFifo, and NLNET::CSynchronizedFIFO. +

+Referenced by NLNET::CBufServer::dataAvailable(), NLNET::CBufClient::dataAvailable(), NLNET::CBufClient::disconnect(), NLNET::CBufServer::receive(), NLNET::CBufClient::receive(), and NLNET::CServerReceiveTask::run(). +

+

00154 { return _RecvFifo; }
+
+

+ + + + +
+ + + + + + + + + + +
CServerReceiveTask* NLNET::CBufServer::receiveTask ( std::vector< NLMISC::IThread * >::iterator  ipt  )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Returns the receive task corresponding to a particular thread. +

+ +

+Definition at line 284 of file buf_server.h. +

+Referenced by NLNET::CBufServer::disconnect(), NLNET::CBufServer::dispatchNewSocket(), NLNET::CBufServer::displaySendQueueStat(), NLNET::CBufServer::displayThreadStat(), NLNET::CBufServer::getSendQueueSize(), NLNET::CBufServer::send(), NLNET::CBufServer::update(), and NLNET::CBufServer::~CBufServer(). +

+

00285         {
+00286                 return ((CServerReceiveTask*)((*ipt)->getRunnable()));
+00287         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackServer::send ( const NLMISC::CMemStream &  buffer,
TSockId  hostid
)  [inline, private]
+
+ + + + + +
+   + + +

+This function is public in the base class and put it private here because user cannot use it in layer 2. +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 93 of file callback_server.h. +

+References nlstop, and NLNET::TSockId. +

+

00093 { nlstop; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackServer::send ( const CMessage &  buffer,
TSockId  hostid,
bool  log = true
)  [virtual]
+
+ + + + + +
+   + + +

+Sends a message to the specified host. +

+ +

+Implements NLNET::CCallbackNetBase. +

+Definition at line 124 of file callback_server.cpp. +

+References buffer, NLNET::CCallbackNetBase::checkThreadId(), NLNET::CBufServer::nbConnections(), nlassert, NLNET::Sending, sint, and NLNET::TSockId. +

+Referenced by sendAllMyAssociations(). +

+

00125 {
+00126         checkThreadId ();
+00127         nlassert (connected ());
+00128         nlassert (buffer.length() != 0);
+00129         nlassert (buffer.typeIsSet());
+00130 
+00131         if (hostid == InvalidSockId)
+00132         {
+00133                 // broadcast
+00134                 sint nb = nbConnections ();
+00135                 _BytesSent += buffer.length () * nb;
+00136         }
+00137         else
+00138         {
+00139                 _BytesSent += buffer.length ();
+00140         }
+00141 
+00142 //      if (log)
+00143         {
+00144 //              nldebug ("LNETL3S: Server: send(%s, %s)", buffer.toString().c_str(), hostid->asString().c_str());
+00145         }
+00146 
+00147 #ifdef USE_MESSAGE_RECORDER
+00148         if ( _MR_RecordingState != Replay )
+00149         {
+00150 #endif
+00151 
+00152                 // Send
+00153                 CBufServer::send (buffer, hostid);
+00154 
+00155 #ifdef USE_MESSAGE_RECORDER
+00156                 if ( _MR_RecordingState == Record )
+00157                 {
+00158                         // Record sent message
+00159                         _MR_Recorder.recordNext( _MR_UpdateCounter, Sending, hostid, const_cast<CMessage&>(buffer) );
+00160                 }
+00161         }
+00162         else
+00163         {       
+00165         }
+00166 #endif
+00167 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackServer::sendAllMyAssociations ( TSockId  to  )  [private]
+
+ + + + + +
+   + + +

+Used by client and server class. +

+ +

+Reimplemented from NLNET::CCallbackNetBase. +

+Definition at line 91 of file callback_server.cpp. +

+References NLNET::CBufSock::asString(), NLNET::CCallbackNetBase::checkThreadId(), NLNET::CCallbackNetBase::getSIDA(), NLMISC::CStringIdArray::getString(), nlassert, nldebug, send(), NLMISC::CMemStream::serial(), NLMISC::CStringIdArray::size(), size, NLNET::TSockId, and NLMISC::CStringIdArray::TStringId. +

+

00092 {
+00093         nlassert (to != InvalidSockId); // invalid hostid
+00094         checkThreadId ();
+00095         nlassert (connected ());
+00096 
+00097         // he wants all associations
+00098         CMessage msgout (getSIDA(), "RAA");
+00099 
+00100         CStringIdArray::TStringId size;
+00101         size = _OutputSIDA.size ();
+00102 
+00103         nldebug ("LNETL3S: Send all (%d) my string association to %s", size, to->asString().c_str());
+00104         
+00105         msgout.serial (size);
+00106 
+00107         for (CStringIdArray::TStringId i = 0; i < size; i++)
+00108         {
+00109 //              nldebug ("LNETL3S:  sending association '%s' -> %d", _OutputSIDA.getString(i).c_str (), i);
+00110                 string str(_OutputSIDA.getString(i));
+00111                 msgout.serial (str);
+00112                 msgout.serial (i);
+00113         }
+00114 
+00115         send (msgout, to);
+00116 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackServer::setConnectionCallback ( TNetCallback  cb,
void *  arg
)  [inline]
+
+ + + + + +
+   + + +

+Sets callback for incoming connections (or NULL to disable callback). +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 61 of file callback_server.h. +

+References NLNET::CCallbackNetBase::checkThreadId(), and NLNET::TNetCallback. +

+Referenced by NLNET::CNetManager::addServer(), NLNET::CUnifiedNetwork::init(), and NLNET::CLoginServer::init(). +

+

00061 { checkThreadId (); _ConnectionCallback = cb; _ConnectionCbArg = arg; }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CBufNetBase::setDataAvailableFlag ( bool  da  )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Sets _DataAvailable. +

+ +

+Definition at line 203 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_DataAvailable. +

+Referenced by NLNET::CBufServer::dataAvailable(), NLNET::CBufClient::dataAvailable(), NLNET::CBufClient::disconnect(), NLNET::CBufNetBase::pushMessageIntoReceiveQueue(), NLNET::CBufServer::receive(), NLNET::CBufClient::receive(), and NLNET::CServerReceiveTask::run(). +

+

00203 { _DataAvailable = da; }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackNetBase::setDefaultCallback ( TMsgCallback  defaultCallback  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Sets default callback for unknown message types. +

+ +

+Definition at line 110 of file callback_net_base.h. +

+References NLNET::CCallbackNetBase::_DefaultCallback, and NLNET::TMsgCallback. +

+Referenced by NLNET::CUnifiedNetwork::addService(), and NLNET::CUnifiedNetwork::init(). +

+

00110 { _DefaultCallback = defaultCallback; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackServer::setDisconnectionCallback ( TNetCallback  cb,
void *  arg
)  [inline]
+
+ + + + + +
+   + + +

+Sets callback for disconnections (or NULL to disable callback). +

+ +

+Reimplemented from NLNET::CCallbackNetBase. +

+Definition at line 64 of file callback_server.h. +

+References NLNET::CCallbackNetBase::checkThreadId(), and NLNET::TNetCallback. +

+Referenced by NLNET::CUnifiedNetwork::init(). +

+

00064 { checkThreadId (); CCallbackNetBase::setDisconnectionCallback (cb, arg); }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CBufNetBase::setMaxExpectedBlockSize ( sint32  limit  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Sets the max size of the received messages. If receiving a message bigger than the limit, the connection will be dropped.

+Default value: 1 MegaByte If you put a negative number as limit, the max size is reset to the default value. Warning: you can call this method only at initialization time, before connecting (for a client) or calling init() (for a server) ! +

+Definition at line 109 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_MaxExpectedBlockSize, sint32, and uint32. +

+

00110         {
+00111                 if ( limit < 0 )
+00112                         _MaxExpectedBlockSize = 1048576;
+00113                 else
+00114                         _MaxExpectedBlockSize = (uint32)limit;
+00115         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CBufNetBase::setMaxSentBlockSize ( sint32  limit  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Sets the max size of the sent messages. Note: Limiting of sending not implemented, currently

+Default value: 1 MegaByte If you put a negative number as limit, the max size is reset to the default value. Warning: you can call this method only at initialization time, before connecting (for a client) or calling init() (for a server) ! +

+Definition at line 126 of file buf_net_base.h. +

+References NLNET::CBufNetBase::_MaxSentBlockSize, sint32, and uint32. +

+

00127         {
+00128                 if ( limit < 0 )
+00129                         _MaxSentBlockSize = 1048576;
+00130                 else
+00131                         _MaxSentBlockSize = (uint32)limit;
+00132         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CCallbackNetBase::setOtherSideAssociations ( const char **  associationarray,
NLMISC::CStringIdArray::TStringId  arraysize
)  [inherited]
+
+ + + + + +
+   + + +

+Gives some association of the other side. The goal is, in specific case, we don't want to ask associations to the other side (client is not secure for example). In this case, we can set other side associations by hand using this functions. +

+Definition at line 451 of file callback_net_base.cpp. +

+References NLMISC::CStringIdArray::addString(), NLNET::CCallbackNetBase::checkThreadId(), NLNET::CCallbackNetBase::getSIDA(), nldebug, sint, and NLMISC::CStringIdArray::TStringId. +

+

00452 {
+00453         checkThreadId ();
+00454 
+00455         nldebug ("LNETL3NB_ASSOC: setOtherSideAssociations() sets %d association strings", arraysize);
+00456 
+00457         for (sint i = 0; i < arraysize; i++)
+00458         {
+00459                 nldebug ("LNETL3NB_ASSOC:  association '%s' -> %d", associationarray[i], i);
+00460                 getSIDA().addString (associationarray[i], i);
+00461         }
+00462 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CBufServer::setSizeFlushTrigger ( TSockId  destid,
sint32  size
)  [inline, inherited]
+
+ + + + + +
+   + + +

+Sets the size flush trigger. When the size of the send queue reaches or exceeds this value, all data in the send queue is automatically sent (-1 to disable this trigger ) +

+Definition at line 226 of file buf_server.h. +

+References nlassert, NLNET::CBufSock::setSizeFlushTrigger(), sint32, size, and NLNET::TSockId. +

+

00226 { nlassert( destid != InvalidSockId ); destid->setSizeFlushTrigger( size ); }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLNET::CBufServer::setTimeFlushTrigger ( TSockId  destid,
sint32  ms
)  [inline, inherited]
+
+ + + + + +
+   + + +

+Sets the time flush trigger (in millisecond). When this time is elapsed, all data in the send queue is automatically sent (-1 to disable this trigger) +

+Definition at line 221 of file buf_server.h. +

+References nlassert, NLNET::CBufSock::setTimeFlushTrigger(), sint32, and NLNET::TSockId. +

+

00221 { nlassert( destid != InvalidSockId ); destid->setTimeFlushTrigger( ms ); }
+
+

+ + + + +
+ + + + + + + + + +
void NLNET::CBufServer::update (   )  [inherited]
+
+ + + + + +
+   + + +

+Update the network (call this method evenly). +

+ +

+Definition at line 613 of file buf_server.cpp. +

+References NLNET::CServerReceiveTask::_Connections, NLNET::CBufServer::_NbConnections, NLNET::CBufServer::_ThreadPool, nldebug, and NLNET::CBufServer::receiveTask(). +

+

00614 {
+00615         //nlnettrace( "CBufServer::update-BEGIN" );
+00616 
+00617         _NbConnections = 0;
+00618 
+00619         // For each thread
+00620         CThreadPool::iterator ipt;
+00621         {
+00622           //nldebug( "UPD: Acquiring the Thread Pool" );
+00623                 CSynchronized<CThreadPool>::CAccessor poolsync( &_ThreadPool );
+00624                 //nldebug( "UPD: Acquired." );
+00625                 for ( ipt=poolsync.value().begin(); ipt!=poolsync.value().end(); ++ipt )
+00626                 {
+00627                         // For each thread of the pool
+00628                         CServerReceiveTask *task = receiveTask(ipt);
+00629                         CConnections::iterator ipb;
+00630                         {
+00631                                 CSynchronized<CConnections>::CAccessor connectionssync( &task->_Connections );
+00632                                 for ( ipb=connectionssync.value().begin(); ipb!=connectionssync.value().end(); ++ipb )
+00633                                 {
+00634                                     // For each socket of the thread, update sending
+00635                                     if ( ! ((*ipb)->Sock->connected() && (*ipb)->update()) )
+00636                                     {
+00637                                                 // Update did not work or the socket is not connected anymore
+00638                                         nldebug( "LNETL1: Socket %s is disconnected", (*ipb)->asString().c_str() );
+00639                                                 // Disconnection event if disconnected (known either from flush (in update) or when receiving data)
+00640                                                 (*ipb)->advertiseDisconnection( this, *ipb );
+00641                                         
+00642                                                 /*if ( (*ipb)->advertiseDisconnection( this, *ipb ) )
+00643                                                 {
+00644                                                         // Now the connection removal is in dataAvailable()
+00645                                                         // POLL6
+00646                                                 }*/
+00647                                     }
+00648                                     else
+00649                                     {
+00650                                                 _NbConnections++;
+00651                                     }
+00652                                 }
+00653                         }
+00654                 }
+00655         }
+00656 
+00657         //nlnettrace( "CBufServer::update-END" );
+00658 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLNET::CCallbackServer::update ( sint32  timeout = 0  )  [virtual]
+
+ + + + + +
+   + + +

+Updates the network (call this method evenly). +

+ +

+Reimplemented from NLNET::CCallbackNetBase. +

+Definition at line 175 of file callback_server.cpp. +

+References NLNET::CCallbackNetBase::baseUpdate(), NLNET::CCallbackNetBase::checkThreadId(), H_AUTO, nlassert, and sint32. +

+Referenced by NLNET::CUnifiedNetwork::update(). +

+

00176 {
+00177         H_AUTO(L3UpdateServer);
+00178 
+00179         checkThreadId ();
+00180         nlassert (connected ());
+00181 
+00182         //      nldebug ("LNETL3S: Client: update()");
+00183         baseUpdate ( timeout ); // first receive
+00184 
+00185 #ifdef USE_MESSAGE_RECORDER
+00186         if ( _MR_RecordingState != Replay )
+00187         {
+00188 #endif
+00189 
+00190                 // L1-2 Update (nothing to do in replay mode)
+00191                 CBufServer::update (); // then send
+00192 
+00193 #ifdef USE_MESSAGE_RECORDER
+00194         }
+00195 #endif
+00196 
+00197 }
+
+

Friends And Related Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void cbsNewConnection ( TSockId  from,
void *  data
)  [friend]
+
+ + + + + +
+   + + +

+ +

+Definition at line 45 of file callback_server.cpp. +

+

00046 {
+00047         nlassert (data != NULL);
+00048         CCallbackServer *server = (CCallbackServer *)data;
+00049 
+00050         nldebug("LNETL3S: newConnection()");
+00051 
+00052 #ifdef USE_MESSAGE_RECORDER
+00053         // Record connection
+00054         server->noticeConnection( from );
+00055 #endif
+00056 
+00057         // send all my association to the new client
+00058 // association are disactivated so we don t need to send them
+00059 //      server->sendAllMyAssociations (from);
+00060 
+00061         // call the client callback if necessary
+00062         if (server->_ConnectionCallback != NULL)
+00063                 server->_ConnectionCallback (from, server->_ConnectionCbArg);
+00064 }
+
+

+ + + + +
+ + +
friend class CListenTask [friend, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 272 of file buf_server.h. +

+Referenced by NLNET::CBufServer::CBufServer().

+

+ + + + +
+ + +
friend class CServerBufSock [friend, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 271 of file buf_server.h.

+

+ + + + +
+ + +
friend class CServerReceiveTask [friend, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 273 of file buf_server.h. +

+Referenced by NLNET::CBufServer::addNewThread().

+

+ + + + +
+ + +
friend class NLNET::CBufSock [friend, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 148 of file buf_net_base.h.

+

Field Documentation

+

+ + + + +
+ + +
uint64 NLNET::CCallbackNetBase::_BytesReceived [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 167 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::CCallbackNetBase(), NLNET::CCallbackNetBase::getBytesReceived(), and NLNET::CCallbackNetBase::processOneMessage().

+

+ + + + +
+ + +
uint64 NLNET::CCallbackNetBase::_BytesSent [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 167 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::CCallbackNetBase(), and NLNET::CCallbackNetBase::getBytesSent().

+

+ + + + +
+ + +
std::vector<TCallbackItem> NLNET::CCallbackNetBase::_CallbackArray [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 196 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::addCallbackArray(), and NLNET::CCallbackNetBase::processOneMessage().

+

+ + + + +
+ + +
TNetCallback NLNET::CCallbackServer::_ConnectionCallback [private] +
+
+ + + + + +
+   + + +

+Connection callback. +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 100 of file callback_server.h. +

+Referenced by NLNET::cbsNewConnection().

+

+ + + + +
+ + +
void* NLNET::CCallbackServer::_ConnectionCbArg [private] +
+
+ + + + + +
+   + + +

+Argument of the connection callback. +

+ +

+Reimplemented from NLNET::CBufServer. +

+Definition at line 101 of file callback_server.h. +

+Referenced by NLNET::cbsNewConnection().

+

+ + + + +
+ + +
TMsgCallback NLNET::CCallbackNetBase::_DefaultCallback [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 199 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::processOneMessage(), and NLNET::CCallbackNetBase::setDefaultCallback().

+

+ + + + +
+ + +
bool NLNET::CCallbackNetBase::_FirstUpdate [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 202 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::baseUpdate().

+

+ + + + +
+ + +
NLMISC::CStringIdArray NLNET::CCallbackNetBase::_InputSIDA [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 188 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::baseUpdate(), NLNET::CCallbackNetBase::getSIDA(), and NLNET::CCallbackNetBase::ignoreAllUnknownId().

+

+ + + + +
+ + +
bool NLNET::CCallbackNetBase::_IsAServer [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 201 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::isAServer().

+

+ + + + +
+ + +
TNetCallback NLNET::CCallbackNetBase::_NewDisconnectionCallback [protected, inherited] +
+
+ + + + + +
+   + + +

+Used by client and server class. +

+ +

+Definition at line 170 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::CCallbackNetBase().

+

+ + + + +
+ + +
NLMISC::CStringIdArray NLNET::CCallbackNetBase::_OutputSIDA [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 193 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::addCallbackArray(), NLNET::cbnbMessageAskAssociations(), NLNET::CCallbackNetBase::displayAllMyAssociations(), and NLNET::CCallbackNetBase::processOneMessage().

+

+ + + + +
+ + +
uint NLNET::CCallbackNetBase::_ThreadId [protected, inherited] +
+
+ + + + + +
+   + + +

+

Todo:
ace: debug feature that we should remove one day nefore releasing the game
+ +

+Definition at line 232 of file callback_net_base.h. +

+Referenced by NLNET::CCallbackNetBase::CCallbackNetBase().

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 13:56:32 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1