nel/src/net/callback_server.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdnet.h"
  18
  19 #include "nel/net/callback_server.h"
  20 #include "nel/net/net_log.h"
  21
  22
  23 #ifdef USE_MESSAGE_RECORDER
  24 #include "nel/net/dummy_tcp_sock.h"
  25 #endif
  26
  27 using namespace std;
  28 using namespace NLMISC;
  29
  30 namespace NLNET {
  31
  32
  33 /*
  34  * Connection callback (the disconnection callback is in callback_net_base.cpp
  35  */
  36 void cbsNewConnection (TSockId from, void *data)
  37 {
  38         nlassert (data != NULL);
  39         CCallbackServer *server = (CCallbackServer *)data;
  40
  41         LNETL3_DEBUG("LNETL3S: newConnection()");
  42
  43 #ifdef USE_MESSAGE_RECORDER
  44         // Record connection
  45         server->noticeConnection( from );
  46 #endif
  47
  48         // send all my association to the new client
  49 // association are disactivated so we don t need to send them
  50 //      server->sendAllMyAssociations (from);
  51
  52         // call the client callback if necessary
  53         if (server->_ConnectionCallback != NULL)
  54                 server->_ConnectionCallback (from, server->_ConnectionCbArg);
  55 }
  56
  57
  58 /*
  59  * Constructor
  60  */
  61 CCallbackServer::CCallbackServer( TRecordingState rec, const string& recfilename, bool recordall, bool initPipeForDataAvailable ) :
  62         CCallbackNetBase( rec, recfilename, recordall ),
  63         CBufServer( DEFAULT_STRATEGY, DEFAULT_MAX_THREADS, DEFAULT_MAX_SOCKETS_PER_THREADS, true, rec==Replay, initPipeForDataAvailable ),
  64         _ConnectionCallback(NULL),
  65         _ConnectionCbArg(NULL)
  66 {
  67 #ifndef USE_MESSAGE_RECORDER
  68         nlassertex( rec==Off, ("LNETL3S: The message recorder is disabled at compilation time ; switch the recording state Off") );
  69 #endif
  70
  71         CBufServer::setDisconnectionCallback (_NewDisconnectionCallback, this);
  72         CBufServer::setConnectionCallback (cbsNewConnection, this);
  73
  74         _IsAServer = true;
  75         _DefaultCallback = NULL;
  76 }
  77
  78
  79 /*
  80  * Send a message to the specified host (pushing to its send queue)
  81  * Recorded : YES
  82  * Replayed : MAYBE
  83  */
  84 void CCallbackServer::send (const CMessage &buffer, TSockId hostid, bool /* log */)
  85 {
  86         nlassert (connected ());
  87         nlassert (buffer.length() != 0);
  88         nlassert (buffer.typeIsSet());
  89
  90         if (hostid == InvalidSockId)
  91         {
  92                 // broadcast
  93                 sint nb = nbConnections ();
  94                 _BytesSent += buffer.length () * nb;
  95         }
  96         else
  97         {
  98                 _BytesSent += buffer.length ();
  99         }
 100
 101 //      if (log)
 102         {
 103 //              LNETL3_DEBUG ("LNETL3S: Server: send(%s, %s)", buffer.toString().c_str(), hostid->asString().c_str());
 104         }
 105
 106 #ifdef USE_MESSAGE_RECORDER
 107         if ( _MR_RecordingState != Replay )
 108         {
 109 #endif
 110
 111                 // Send
 112                 CBufServer::send (buffer, hostid);
 113
 114 #ifdef USE_MESSAGE_RECORDER
 115                 if ( _MR_RecordingState == Record )
 116                 {
 117                         // Record sent message
 118                         _MR_Recorder.recordNext( _MR_UpdateCounter, Sending, hostid, const_cast<CMessage&>(buffer) );
 119                 }
 120         }
 121 #endif
 122 }
 123
 124
 125 /*
 126  * Updates the network (call this method evenly)
 127  * Recorded : YES (in baseUpdate())
 128  * Replayed : YES (in baseUpdate())
 129  */
 130 void CCallbackServer::update2 ( sint32 timeout, sint32 mintime )
 131 {
 132         H_AUTO(L3UpdateServer);
 133
 134         nlassert (connected ());
 135
 136 //      LNETL3_DEBUG ("LNETL3S: Client: update()");
 137         baseUpdate2 ( timeout, mintime ); // first receive
 138
 139 #ifdef USE_MESSAGE_RECORDER
 140         if ( _MR_RecordingState != Replay )
 141         {
 142 #endif
 143                 // L1-2 Update (nothing to do in replay mode)
 144                 CBufServer::update (); // then send
 145
 146 #ifdef USE_MESSAGE_RECORDER
 147         }
 148 #endif
 149
 150 }
 151
 152 /*
 153  * Updates the network (call this method evenly) (legacy)
 154  * Recorded : YES (in baseUpdate())
 155  * Replayed : YES (in baseUpdate())
 156  */
 157 void CCallbackServer::update ( sint32 timeout )
 158 {
 159         H_AUTO(L3UpdateServer);
 160
 161         nlassert (connected ());
 162
 163 //      LNETL3_DEBUG ("LNETL3S: Client: update()");
 164         baseUpdate ( timeout ); // first receive
 165
 166 #ifdef USE_MESSAGE_RECORDER
 167         if ( _MR_RecordingState != Replay )
 168         {
 169 #endif
 170                 // L1-2 Update (nothing to do in replay mode)
 171                 CBufServer::update (); // then send
 172
 173 #ifdef USE_MESSAGE_RECORDER
 174         }
 175 #endif
 176 }
 177
 178
 179 /*
 180  * Read the next message in the receive queue
 181  * Recorded : YES
 182  * Replayed : YES
 183  */
 184 void CCallbackServer::receive (CMessage &buffer, TSockId *hostid)
 185 {
 186         nlassert (connected ());
 187
 188 #ifdef USE_MESSAGE_RECORDER
 189         if ( _MR_RecordingState != Replay )
 190         {
 191 #endif
 192
 193                 // Receive
 194                 CBufServer::receive (buffer, hostid);
 195
 196 #ifdef USE_MESSAGE_RECORDER
 197                 if ( _MR_RecordingState == Record )
 198                 {
 199                         // Record received message
 200                         _MR_Recorder.recordNext( _MR_UpdateCounter, Receiving, *hostid, const_cast<CMessage&>(buffer) );
 201                 }
 202         }
 203         else
 204         {
 205                 // Retrieve received message loaded by dataAvailable()
 206                 buffer = _MR_Recorder.ReceivedMessages.front().Message;
 207                 *hostid = _MR_Recorder.ReceivedMessages.front().SockId;
 208                 _MR_Recorder.ReceivedMessages.pop();
 209         }
 210 #endif
 211
 212         buffer.readType ();
 213 }
 214
 215
 216 /*
 217  * Disconnect a connection
 218  * Set hostid to InvalidSockId to disconnect all connections.
 219  * If hostid is not null and the socket is not connected, the method does nothing.
 220  * Before disconnecting, any pending data is actually sent.
 221  * Recorded : YES in noticeDisconnection called in the disconnection callback
 222  * Replayed : YES in noticeDisconnection called in the disconnection callback
 223  */
 224 void CCallbackServer::disconnect( TSockId hostid )
 225 {
 226 #ifdef USE_MESSAGE_RECORDER
 227         if ( _MR_RecordingState != Replay )
 228         {
 229 #endif
 230                 // Disconnect
 231                 CBufServer::disconnect( hostid );
 232
 233 #ifdef USE_MESSAGE_RECORDER
 234         }
 235         // else, no need to manually replay the disconnection, such as in CCallbackClient,
 236         // it will be replayed during the next update()
 237 #endif
 238 }
 239
 240
 241 /*
 242  *
 243  */
 244 TSockId CCallbackServer::getSockId (TSockId hostid)
 245 {
 246         nlassert (hostid != InvalidSockId);     // invalid hostid
 247         nlassert (connected ());
 248         nlassert (hostid != NULL);
 249         return hostid;
 250 }
 251
 252
 253 /*
 254  * Returns true if there are messages to read
 255  * Recorded : NO
 256  * Replayed : YES
 257  */
 258 bool CCallbackServer::dataAvailable ()
 259 {
 260 #ifdef USE_MESSAGE_RECORDER
 261         if ( _MR_RecordingState != Replay )
 262         {
 263 #endif
 264
 265                 // Real dataAvailable()
 266                 return CBufServer::dataAvailable ();
 267
 268 #ifdef USE_MESSAGE_RECORDER
 269         }
 270         else
 271         {
 272                 // Simulated dataAvailable()
 273                 return CCallbackNetBase::replayDataAvailable();
 274         }
 275 #endif
 276 }
 277
 278
 279 //-------------------------
 280 #ifdef USE_MESSAGE_RECORDER
 281
 282
 283 /*
 284  * Replay connection and disconnection callbacks, client version
 285  */
 286 bool CCallbackServer::replaySystemCallbacks()
 287 {
 288         do
 289         {
 290                 if ( _MR_Recorder.ReceivedMessages.empty() )
 291                 {
 292                         return false;
 293                 }
 294                 else
 295                 {
 296                         // Translate the stored sockid to the replayed sockid
 297                         TSockId sockid;
 298                         std::map<TSockId,TSockId>::iterator isi = _MR_SockIds.find( _MR_Recorder.ReceivedMessages.front().SockId );
 299                         if ( isi != _MR_SockIds.end() )
 300                         {
 301                                 // The sockid is found in the map if the connection already exists
 302                                 sockid = (*isi).second;
 303                                 _MR_Recorder.ReceivedMessages.front().SockId = sockid;
 304                         }
 305
 306                         // Test event type
 307                         switch( _MR_Recorder.ReceivedMessages.front().Event )
 308                         {
 309                         case Receiving:
 310                                 return true;
 311
 312                         case Disconnecting:
 313                                 LNETL3_DEBUG( "LNETL3S: Disconnection event for %p", sockid );
 314                                 sockid->Sock->disconnect();
 315                                 sockid->setConnectedState( false );
 316
 317                                 // Call callback if needed
 318                                 if ( disconnectionCallback() != NULL )
 319                                 {
 320                                         disconnectionCallback()( sockid, argOfDisconnectionCallback() );
 321                                 }
 322                                 break;
 323
 324                         case Accepting:
 325                                 {
 326                                 // Replay connection:
 327
 328                                 // Get remote address
 329                                 CInetAddress addr;
 330                                 _MR_Recorder.ReceivedMessages.front().Message.serial( addr );
 331
 332                                 // Create a new connection
 333                                 sockid = new CBufSock( new CDummyTcpSock() );
 334                                 sockid->Sock->connect( addr );
 335                                 _MR_Connections.push_back( sockid );
 336
 337                                 // Bind it to the "old" sockid
 338                                 _MR_SockIds.insert( make_pair( _MR_Recorder.ReceivedMessages.front().SockId, sockid ) );
 339
 340                                 LNETL3_DEBUG( "LNETL3S: Connection event for %p", sockid );
 341                                 sockid->setConnectedState( true );
 342
 343                                 // Call callback if needed
 344                                 if ( connectionCallback() != NULL )
 345                                 {
 346                                         connectionCallback()( sockid, argOfConnectionCallback() );
 347                                 }
 348                                 break;
 349                                 }
 350                         default:
 351                                 nlerror( "LNETL3S: Invalid system event type in client receive queue" );
 352                         }
 353                         // Extract system event
 354                         _MR_Recorder.ReceivedMessages.pop();
 355                 }
 356         }
 357         while ( true );
 358 }
 359
 360
 361 /*
 362  * Record or replay connection
 363  */
 364 void CCallbackServer::noticeConnection( TSockId hostid )
 365 {
 366         nlassert (hostid != InvalidSockId);     // invalid hostid
 367         if ( _MR_RecordingState != Replay )
 368         {
 369                 if ( _MR_RecordingState == Record )
 370                 {
 371                         // Record connection
 372                         CMessage addrmsg;
 373                         addrmsg.serial( const_cast<CInetAddress&>(hostAddress(hostid)) );
 374                         _MR_Recorder.recordNext( _MR_UpdateCounter, Accepting, hostid, addrmsg );
 375                 }
 376         }
 377 }
 378
 379 #endif // USE_MESSAGE_RECORDER
 380
 381
 382 } // NLNET