nevrax.org : docs

00001 
00007 /* Copyright, 2001 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "stdnet.h"
00027 
00028 #include "nel/net/callback_net_base.h"
00029 #include "nel/net/callback_client.h"
00030 
00031 #ifdef USE_MESSAGE_RECORDER
00032 #include "nel/net/message_recorder.h"
00033 #endif
00034 
00035 
00036 namespace NLNET {
00037 
00038 
00039 /*
00040  * Callbacks management
00041  */
00042 
00043 static void cbcMessageRecvAllAssociations (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
00044 {
00045         netbase.getSIDA().ignoreAllUnknownId (false);
00046         cbnbMessageRecvAssociations (msgin, from, netbase);
00047 }
00048 
00049 
00050 static TCallbackItem ClientMessageAssociationArray[] =
00051 {
00052         { "RAA", cbcMessageRecvAllAssociations },
00053 };
00054 
00055 
00056 /*
00057  * Constructor
00058  */
00059 CCallbackClient::CCallbackClient( TRecordingState rec, const std::string& recfilename, bool recordall ) :
00060         CCallbackNetBase( rec, recfilename, recordall ), CBufClient( true, rec==Replay ), SendNextValue(0), ReceiveNextValue(0)
00061 {
00062         CBufClient::setDisconnectionCallback (_NewDisconnectionCallback, this);
00063 
00064         // add the callback needed to associate messages with id
00065         addCallbackArray (ClientMessageAssociationArray, sizeof (ClientMessageAssociationArray) / sizeof (ClientMessageAssociationArray[0]));
00066 
00067         _InputSIDA.ignoreAllUnknownId (true);
00068 
00069         _IsAServer = false;
00070         _DefaultCallback = NULL;
00071 }
00072 
00073 
00074 /*
00075  * Send a message to the remote host (pushing to its send queue)
00076  * Recorded : YES
00077  * Replayed : MAYBE
00078  */
00079 void CCallbackClient::send (const CMessage &buffer, TSockId hostid, bool log)
00080 {
00081         nlassert (hostid == InvalidSockId);     // should always be InvalidSockId on client
00082         checkThreadId ();
00083         nlassert (connected ());
00084         nlassert (buffer.length() != 0);
00085         nlassert (buffer.typeIsSet());
00086 
00087         _BytesSent += buffer.length ();
00088 
00089 //      if (log)
00090         {
00092 //              nldebug ("send message number %u", SendNextValue);
00093         }
00094 
00095         // debug features, we number all packet to be sure that they are all sent and received
00096         // \todo remove this debug feature when ok
00097         // fill the number
00098         uint32 *val = (uint32*)buffer.buffer ();
00099 #ifdef NL_BIG_ENDIAN
00100         *val = NLMISC_BSWAP32(SendNextValue);
00101 #else
00102         *val = SendNextValue;
00103 #endif
00104         SendNextValue++;
00105 
00106 
00107 #ifdef USE_MESSAGE_RECORDER
00108         if ( _MR_RecordingState != Replay )
00109         {
00110 #endif
00111 
00112                 // Send
00113                 CBufClient::send (buffer);
00114 
00115 #ifdef USE_MESSAGE_RECORDER
00116                 if ( _MR_RecordingState == Record )
00117                 {
00118                         // Record sent message
00119                         _MR_Recorder.recordNext( _MR_UpdateCounter, Sending, hostid, const_cast<CMessage&>(buffer) );
00120                 }
00121         }
00122         else
00123         {       
00125         }
00126 #endif
00127 }
00128 
00129 /*
00130  * Force to send all data pending in the send queue.
00131  * Recorded : NO
00132  * Replayed : NO
00133  */
00134 bool CCallbackClient::flush (TSockId hostid) 
00135 {
00136         nlassert (hostid == InvalidSockId);     // should always be InvalidSockId on client
00137         checkThreadId ();
00138 
00139 #ifdef USE_MESSAGE_RECORDER
00140         if ( _MR_RecordingState != Replay )
00141         {
00142 #endif
00143 
00144                 // Flush sending (nothing to do in replay mode)
00145                 return CBufClient::flush();
00146                 
00147 #ifdef USE_MESSAGE_RECORDER
00148         }
00149         else
00150         {
00151                 return true;
00152         }
00153 #endif
00154 }
00155 
00156 
00157 /*
00158  * Updates the network (call this method evenly)
00159  * Recorded : YES (in baseUpdate())
00160  * Replayed : YES (in baseUpdate())
00161  */
00162 void CCallbackClient::update ( sint32 timeout )
00163 {
00164 //      nldebug ("L3: Client: update()");
00165 
00166         checkThreadId ();
00167 
00168         baseUpdate (timeout); // first receive
00169 
00170 #ifdef USE_MESSAGE_RECORDER
00171         if ( _MR_RecordingState != Replay )
00172         {
00173 #endif
00174 
00175                 // L1-2 Update (nothing to do in replay mode)
00176                 CBufClient::update (); // then send
00177 
00178 #ifdef USE_MESSAGE_RECORDER
00179         }
00180 #endif
00181 }
00182 
00183 
00184 /*
00185  * Returns true if there are messages to read
00186  * Recorded : NO
00187  * Replayed : YES
00188  */
00189 bool CCallbackClient::dataAvailable ()
00190 {
00191         checkThreadId ();
00192 
00193 #ifdef USE_MESSAGE_RECORDER
00194         if ( _MR_RecordingState != Replay )
00195         {
00196 #endif
00197 
00198                 // Real dataAvailable()
00199                 return CBufClient::dataAvailable (); 
00200 
00201 #ifdef USE_MESSAGE_RECORDER
00202         }
00203         else
00204         {
00205                 // Simulated dataAvailable()
00206                 return CCallbackNetBase::replayDataAvailable();
00207         }
00208 #endif
00209 }
00210 
00211 
00212 /*
00213  * Read the next message in the receive queue
00214  * Recorded : YES
00215  * Replayed : YES
00216  */
00217 void CCallbackClient::receive (CMessage &buffer, TSockId *hostid)
00218 {
00219         checkThreadId ();
00220         nlassert (connected ());
00221         *hostid = InvalidSockId;
00222 
00223 #ifdef USE_MESSAGE_RECORDER
00224         if ( _MR_RecordingState != Replay )
00225         {
00226 #endif
00227                 
00228                 // Receive
00229                 CBufClient::receive (buffer);
00230 
00231                 // debug features, we number all packet to be sure that they are all sent and received
00232                 // \todo remove this debug feature when ok
00233 #ifdef NL_BIG_ENDIAN
00234                 uint32 val = NLMISC_BSWAP32(*(uint32*)buffer.buffer ());
00235 #else
00236                 uint32 val = *(uint32*)buffer.buffer ();
00237 #endif
00238 
00239 //              nldebug ("receive message number %u", val);
00240                 if (ReceiveNextValue != val)
00241                 {
00242                         nlstopex (("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, ReceiveNextValue, id()->asString().c_str()));
00243                         // resync the message number
00244                         ReceiveNextValue = val;
00245                 }
00246                 ReceiveNextValue++;
00247 
00248 #ifdef USE_MESSAGE_RECORDER
00249                 if ( _MR_RecordingState == Record )
00250                 {
00251                         // Record received message
00252                         _MR_Recorder.recordNext( _MR_UpdateCounter, Receiving, *hostid, const_cast<CMessage&>(buffer) );
00253                 }
00254         }
00255         else
00256         {
00257                 // Retrieve received message loaded by dataAvailable()
00258                 buffer = _MR_Recorder.ReceivedMessages.front().Message;
00259                 _MR_Recorder.ReceivedMessages.pop();
00260         }
00261 #endif
00262 
00263         buffer.readType ();
00264 }
00265 
00266 /*
00267  *
00268  */
00269 TSockId CCallbackClient::getSockId (TSockId hostid)
00270 {
00271         nlassert (hostid == InvalidSockId);
00272         checkThreadId ();
00273 
00274         return id ();
00275 }
00276 
00277 
00278 /*
00279  * Connect to the specified host
00280  * Recorded : YES
00281  * Replayed : YES
00282  */
00283 void CCallbackClient::connect( const CInetAddress& addr )
00284 {
00285         checkThreadId ();
00286 
00287         SendNextValue = ReceiveNextValue = 0;
00288 
00289 #ifdef USE_MESSAGE_RECORDER
00290         if ( _MR_RecordingState != Replay )
00291         {
00292                 try
00293                 {
00294 #endif
00295 
00296                         // Connect
00297                         CBufClient::connect( addr );
00298 
00299 #ifdef USE_MESSAGE_RECORDER
00300                         if ( _MR_RecordingState == Record )
00301                         {
00302                                 // Record connection
00303                                 CMessage addrmsg;
00304                                 addrmsg.serial( const_cast<CInetAddress&>(addr) );
00305                                 _MR_Recorder.recordNext( _MR_UpdateCounter, Connecting, _BufSock, addrmsg );
00306                         }
00307                 }
00308                 catch ( ESocketConnectionFailed& )
00309                 {
00310                         if ( _MR_RecordingState == Record )
00311                         {
00312                                 // Record connection
00313                                 CMessage addrmsg;
00314                                 addrmsg.serial( const_cast<CInetAddress&>(addr) );
00315                                 _MR_Recorder.recordNext( _MR_UpdateCounter, ConnFailing, _BufSock, addrmsg );
00316                         }
00317                         throw;
00318                 }
00319         }
00320         else
00321         {
00322                 // Check the connection : failure or not
00323                 TNetworkEvent event = _MR_Recorder.replayConnectionAttempt( addr );
00324                 switch ( event )
00325                 {
00326                 case Connecting :
00327                         // Set the remote address
00328                         nlassert( ! _BufSock->Sock->connected() );
00329                         _BufSock->connect( addr, _NoDelay, true );
00330                         _PrevBytesDownloaded = 0;
00331                         _PrevBytesUploaded = 0;
00332                         /*_PrevBytesReceived = 0;
00333                         _PrevBytesSent = 0;*/
00334                         break;
00335                 case ConnFailing :
00336                         throw ESocketConnectionFailed( addr );
00337                         //break;
00338                 default :
00339                         nlwarning( "LNETL3C: No connection event in replay data, at update #%"NL_I64"u", _MR_UpdateCounter );
00340                 }
00341         }
00342 #endif
00343 }
00344 
00345 
00346 /*
00347  * Disconnect a connection
00348  * Recorded : YES
00349  * Replayed : YES
00350  */
00351 void CCallbackClient::disconnect( TSockId hostid )
00352 {
00353         nlassert (hostid == InvalidSockId);     // should always be InvalidSockId on client
00354         checkThreadId ();
00355 
00356         SendNextValue = ReceiveNextValue = 0;
00357 
00358         // Disconnect only if connected (same as physically connected for the client)
00359         if ( _BufSock->connectedState() )
00360         {
00361                 
00362 #ifdef USE_MESSAGE_RECORDER
00363                 if ( _MR_RecordingState != Replay )
00364                 {
00365 #endif
00366 
00367                         // Disconnect
00368                         CBufClient::disconnect ();
00369 
00370 #ifdef USE_MESSAGE_RECORDER
00371                 }
00372                 else
00373                 {
00374                         // Read (skip) disconnection in the file
00375                         if ( ! (_MR_Recorder.checkNextOne( _MR_UpdateCounter ) == Disconnecting) )
00376                         {
00377                                 nlwarning( "LNETL3C: No disconnection event in the replay data, at update #%"NL_I64"u", _MR_UpdateCounter );
00378                         }
00379                 }
00380                 // Record or replay disconnection (because disconnect() in the client does not push a disc. event)
00381                 noticeDisconnection( _BufSock );
00382 #endif
00383         }
00384 }
00385 
00386 
00387 #ifdef USE_MESSAGE_RECORDER
00388 
00389 
00390 /*
00391  * replay connection and disconnection callbacks, client version
00392  */
00393 bool CCallbackClient::replaySystemCallbacks()
00394 {
00395         do
00396         {
00397                 if ( _MR_Recorder.ReceivedMessages.empty() )
00398                 {
00399                         return false;
00400                 }
00401                 else
00402                 {
00403                         switch( _MR_Recorder.ReceivedMessages.front().Event )
00404                         {
00405                         case Receiving:
00406                                 return true;
00407 
00408                         case Disconnecting:
00409                                 nldebug( "Disconnection event" );
00410                                 _BufSock->setConnectedState( false );
00411         
00412                                 // Call callback if needed
00413                                 if ( disconnectionCallback() != NULL )
00414                                 {
00415                                         disconnectionCallback()( id(), argOfDisconnectionCallback() );
00416                                 }
00417                                 break;
00418 
00419                         default:
00420                                 nlerror( "LNETL1: Invalid system event type in client receive queue" );
00421                         }
00422                         // Extract system event
00423                         _MR_Recorder.ReceivedMessages.pop();
00424                 }
00425         }
00426         while ( true );
00427 }
00428 
00429 
00430 #endif // USE_MESSAGE_RECORDER
00431 
00432 
00433 } // NLNET
callback_client.cpp
