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/misc/string_id_array.h"
+00029 #include "nel/misc/hierarchical_timer.h"
+00030 
+00031 #include "nel/net/buf_sock.h"
+00032 #include "nel/net/callback_net_base.h"
+00033 
+00034 #ifdef USE_MESSAGE_RECORDER
+00035 #ifdef NL_OS_WINDOWS
+00036 #pragma message ( "NeL Net layer 3: message recorder enabled" )
+00037 #endif // NL_OS_WINDOWS
+00038 #include "nel/net/message_recorder.h"
+00039 #else
+00040 #ifdef NL_OS_WINDOWS
+00041 #pragma message ( "NeL Net layer 3: message recorder disabled" )
+00042 #endif // NL_OS_WINDOWS
+00043 #endif
+00044 
+00045 
+00046 using namespace std;
+00047 using namespace NLMISC;
+00048 
+00049 namespace NLNET {
+00050 
+00051 
+00052 /*
+00053  *
+00054  */
+00055 void cbnbMessageRecvAssociations (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
+00056 {
+00057         // receive a new message association
+00058 
+00059         CStringIdArray::TStringId size;
+00060         msgin.serial (size);
+00061 
+00062         nldebug ("LNETL3NB_ASSOC: The other side gave me %d association strings", size);
+00063 
+00064         for (CStringIdArray::TStringId i = 0; i < size; i++)
+00065         {
+00066                 std::string name;
+00067                 CStringIdArray::TStringId id;
+00068 
+00069                 msgin.serial (name);
+00070                 msgin.serial (id);
+00071 
+00072                 // if id == -1, it means that there are no callback associated to this message
+00073                 // it should not happen, it mean that one side send a message that the other side
+00074                 // can't manage in his callbackarray.
+00075                 // to resolve the problem, add the callback in the callbackarray in the other side
+00076                 // and put NULL if you don't want to manage this message
+00077                 nlassert (id != -1);
+00078 
+00079                 nldebug ("LNETL3NB_ASSOC:  association '%s' -> %d", name.c_str (), id);
+00080                 netbase.getSIDA().addString (name, id);
+00081         }
+00082 }
+00083 
+00084 
+00085 /*
+00086  * the other side want to know some of my association, send them!
+00087  */
+00088 void cbnbMessageAskAssociations (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
+00089 {
+00090         CMessage msgout (netbase.getSIDA(), "RA");
+00091         CStringIdArray::TStringId size;
+00092         msgin.serial (size);
+00093 
+00094         nldebug ("LNETL3NB_ASSOC: The other side want %d string associations", size);
+00095 
+00096         msgout.serial (size);
+00097 
+00098         for (sint i = 0; i < size; i++)
+00099         {
+00100                 string name;
+00101                 msgin.serial (name);
+00102                 nldebug ("LNETL3NB_ASSOC:  sending association '%s' -> %d", name.c_str (), netbase._OutputSIDA.getId(name));
+00103 
+00104                 // if this assert occurs, it means that the other side ask an unknown message
+00105                 // or that there are different types of client (with differents callbackarray) and one of the client doesn't have this callback
+00106                 nlassert(netbase._OutputSIDA.getId(name) != -1);
+00107 
+00108                 msgout.serial (name);
+00109 
+00110                 CStringIdArray::TStringId id = netbase._OutputSIDA.getId (name);
+00111                 msgout.serial (id);
+00112         }
+00113         // send the message to the other side
+00114         netbase.send (msgout, from);
+00115 }
+00116 
+00117 static TCallbackItem cbnbMessageAssociationArray[] =
+00118 {
+00119         { "AA", cbnbMessageAskAssociations },
+00120         { "RA", cbnbMessageRecvAssociations },
+00121 };
+00122 
+00123 
+00124 /*
+00125  * Disconnection callback
+00126  */
+00127 void cbnbNewDisconnection (TSockId from, void *data)
+00128 {
+00129         nlassert (data != NULL);
+00130         CCallbackNetBase *base = (CCallbackNetBase *)data;
+00131 
+00132         nldebug("LNETL3NB: cbnbNewDisconnection()");
+00133 
+00134 #ifdef USE_MESSAGE_RECORDER
+00135         // Record or replay disconnection
+00136         base->noticeDisconnection( from );
+00137 #endif
+00138         
+00139         // Call the client callback if necessary
+00140         if (base->_DisconnectionCallback != NULL)
+00141                 base->_DisconnectionCallback (from, base->_DisconnectionCbArg);
+00142 }
+00143 
+00144 
+00145 /*
+00146  * Constructor
+00147  */
+00148 CCallbackNetBase::CCallbackNetBase(  TRecordingState rec, const string& recfilename, bool recordall ) :
+00149         _FirstUpdate (true), _DisconnectionCallback(NULL), _DisconnectionCbArg(NULL)
+00150 #ifdef USE_MESSAGE_RECORDER
+00151         , _MR_RecordingState(rec), _MR_UpdateCounter(0)
+00152 #endif
+00153 {
+00154         _ThreadId = getThreadId ();
+00155         _NewDisconnectionCallback = cbnbNewDisconnection;
+00156 
+00157         _BytesSent = 0;
+00158         _BytesReceived = 0;
+00159 
+00160         createDebug(); // for addNegativeFilter to work even in release and releasedebug modes
+00161 
+00162         // add the callback needed to associate messages with id
+00163         addCallbackArray (cbnbMessageAssociationArray, sizeof (cbnbMessageAssociationArray) / sizeof (cbnbMessageAssociationArray[0]));
+00164 
+00165 #ifdef USE_MESSAGE_RECORDER
+00166         switch ( _MR_RecordingState )
+00167         {
+00168         case Record :
+00169                 _MR_Recorder.startRecord( recfilename, recordall );
+00170                 break;
+00171         case Replay :
+00172                 _MR_Recorder.startReplay( recfilename );
+00173                 break;
+00174         default:;
+00175                 // No recording
+00176         }
+00177 #endif
+00178 }
+00179 
+00180 
+00181 /*
+00182  *      Append callback array with the specified array
+00183  */
+00184 void CCallbackNetBase::addCallbackArray (const TCallbackItem *callbackarray, CStringIdArray::TStringId arraysize)
+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's %d callback associated with message type", arraysize, _CallbackArray.size ());
+00217 }
+00218 
+00219 
+00220 /*
+00221  * processOneMessage()
+00222  */
+00223 void CCallbackNetBase::processOneMessage ()
+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 }
+00320 
+00321 
+00322 
+00323 /*
+00324  * baseUpdate
+00325  * Recorded : YES
+00326  * Replayed : YES
+00327  */
+00328 void CCallbackNetBase::baseUpdate (sint32 timeout)
+00329 {
+00330         checkThreadId ();
+00331 
+00332         // slow down the layer H_AUTO (CCallbackNetBase_baseUpdate);
+00333 
+00334         nlassert( timeout >= -1 );
+00335         TTime t0 = CTime::getLocalTime();
+00336 
+00337         //
+00338         // The first time, we init time counters
+00339         //
+00340         if (_FirstUpdate)
+00341         {
+00342 //              nldebug("LNETL3NB: First update()");
+00343                 _FirstUpdate = false;
+00344                 _LastUpdateTime = t0;
+00345                 _LastMovedStringArray = t0;
+00346         }
+00347 
+00348         //
+00349         // Every 1 seconds if we have new unknown association, we ask them to the other side
+00350         //
+00351         if (t0 - _LastUpdateTime >  1000)
+00352         {
+00353 //              nldebug("LNETL3NB: baseUpdate()");
+00354                 _LastUpdateTime = t0;
+00355 
+00356                 const set<string> &sa = _InputSIDA.getNeedToAskedStringArray ();
+00357                 if (!sa.empty ())
+00358                 {
+00359                         CMessage msgout (_InputSIDA, "AA");
+00360                         //nlassert (sa.size () < 65536); // no size limit anymore
+00361                         CStringIdArray::TStringId size = sa.size ();
+00362                         nldebug ("LNETL3NB_ASSOC: I need %d string association, ask them to the other side", size);
+00363                         msgout.serial (size);
+00364                         for (set<string>::iterator it = sa.begin(); it != sa.end(); it++)
+00365                         {
+00366                                 nldebug ("LNETL3NB_ASSOC:  what is the id of '%s'?", (*it).c_str ());
+00367                                 string str(*it);
+00368                                 msgout.serial (str);
+00369                         }
+00370                         // send the message to the other side
+00371                         send (msgout, 0);
+00372                         _InputSIDA.moveNeedToAskToAskedStringArray();
+00373                         _LastMovedStringArray = t0;
+00374                 }
+00375         }
+00376 
+00377         //
+00378         // Every 60 seconds if we have not answered association, we ask again to get them!
+00379         //
+00380         if (!_InputSIDA.getAskedStringArray().empty() && t0 - _LastMovedStringArray > 60000)
+00381         {
+00382                 // we didn't have an answer for the association, resend them
+00383                 const set<string> sa = _InputSIDA.getAskedStringArray ();
+00384                 CMessage msgout (_InputSIDA, "AA");
+00385                 //nlassert (sa.size () < 65536); // no size limit anymore
+00386                 CStringIdArray::TStringId size = sa.size ();
+00387                 nldebug ("LNETL3NB_ASSOC: client didn't answer my asked association, retry! I need %d string association, ask them to the other side", size);
+00388                 msgout.serial (size);
+00389                 for (set<string>::iterator it = sa.begin(); it != sa.end(); it++)
+00390                 {
+00391                         nldebug ("LNETL3NB_ASSOC:  what is the id of '%s'?", (*it).c_str ());
+00392                         string str(*it);
+00393                         msgout.serial (str);
+00394                 }
+00395                 // sends the message to the other side
+00396                 send (msgout, 0);
+00397                 _LastMovedStringArray = t0;
+00398         }
+00399 
+00400         /*
+00401          * timeout -1    =>  read one message in the queue or nothing if no message in queue
+00402          * timeout 0     =>  read all messages in the queue
+00403          * timeout other =>  read all messages in the queue until timeout expired (at least all one time)
+00404          */
+00405 
+00406         bool exit = false;
+00407 
+00408         while (!exit)
+00409         {
+00410                 // process all messages in the queue
+00411                 while (dataAvailable ())
+00412                 {
+00413                         processOneMessage ();
+00414                         if (timeout == -1)
+00415                         {
+00416                                 exit = true;
+00417                                 break;
+00418                         }
+00419                 }
+00420 
+00421                 // need to exit?
+00422                 if (timeout == 0 || (sint32)(CTime::getLocalTime() - t0) > timeout)
+00423                 {
+00424                         exit = true;
+00425                 }
+00426                 else
+00427                 {
+00428                         // enable multithreading on windows :-/
+00429                         // slow down the layer H_AUTO (CCallbackNetBase_baseUpdate_nlSleep);
+00430                         nlSleep (10);
+00431                 }
+00432         }
+00433 
+00434 #ifdef USE_MESSAGE_RECORDER
+00435         _MR_UpdateCounter++;
+00436 #endif
+00437 
+00438 }
+00439 
+00440 
+00441 const   CInetAddress& CCallbackNetBase::hostAddress (TSockId hostid)
+00442 {
+00443         // should never be called
+00444         nlstop;
+00445         static CInetAddress tmp;
+00446         return tmp;
+00447 }
+00448 
+00449 void    CCallbackNetBase::setOtherSideAssociations (const char **associationarray, NLMISC::CStringIdArray::TStringId arraysize)
+00450 {
+00451         checkThreadId ();
+00452 
+00453         nldebug ("LNETL3NB_ASSOC: setOtherSideAssociations() sets %d association strings", arraysize);
+00454 
+00455         for (sint i = 0; i < arraysize; i++)
+00456         {
+00457                 nldebug ("LNETL3NB_ASSOC:  association '%s' -> %d", associationarray[i], i);
+00458                 getSIDA().addString (associationarray[i], i);
+00459         }
+00460 }
+00461 
+00462 void    CCallbackNetBase::displayAllMyAssociations ()
+00463 {
+00464         checkThreadId ();
+00465 
+00466         _OutputSIDA.display ();
+00467 }
+00468 
+00469 void    CCallbackNetBase::authorizeOnly (const char *callbackName, TSockId hostid)
+00470 {
+00471         checkThreadId ();
+00472 
+00473         nldebug ("LNETL3NB: authorizeOnly (%s, %s)", callbackName, hostid->asString().c_str());
+00474 
+00475         hostid = getSockId (hostid);
+00476         
+00477         nlassert (hostid != InvalidSockId);
+00478 
+00479         hostid->AuthorizedCallback = (callbackName == NULL)?"":callbackName;
+00480 }
+00481 
+00482 
+00483 #ifdef USE_MESSAGE_RECORDER
+00484 
+00485 /*
+00486  * Replay dataAvailable() in replay mode
+00487  */
+00488 bool CCallbackNetBase::replayDataAvailable()
+00489 {
+00490         nlassert( _MR_RecordingState == Replay );
+00491 
+00492         if ( _MR_Recorder.ReceivedMessages.empty() )
+00493         {
+00494                 // Fill the queue of received messages related to the present update
+00495                 _MR_Recorder.replayNextDataAvailable( _MR_UpdateCounter );
+00496         }
+00497 
+00498         return replaySystemCallbacks();
+00499 }
+00500 
+00501 
+00502 /*
+00503  * Record or replay disconnection
+00504  */
+00505 void CCallbackNetBase::noticeDisconnection( TSockId hostid )
+00506 {
+00507         nlassert (hostid != InvalidSockId);     // invalid hostid
+00508         if ( _MR_RecordingState != Replay )
+00509         {
+00510                 if ( _MR_RecordingState == Record )
+00511                 {
+00512                         // Record disconnection
+00513                         CMessage emptymsg;
+00514                         _MR_Recorder.recordNext( _MR_UpdateCounter, Disconnecting, hostid, emptymsg );
+00515                 }
+00516         }
+00517         else
+00518         {
+00519                 // Replay disconnection
+00520                 hostid->disconnect( false );
+00521         }
+00522 }
+00523 
+00524 #endif // USE_MESSAGE_RECORDER
+00525 
+00526 
+00527 
+00528 /*
+00529  * checkThreadId
+00530  */
+00531 void CCallbackNetBase::checkThreadId () const
+00532 {
+00533 /*      some people use this class in different thread but with a mutex to be sure to have
+00534         no concurent access
+00535         if (getThreadId () != _ThreadId)
+00536         {
+00537                 nlerror ("You try to access to the same CCallbackClient or CCallbackServer with 2 differents thread (%d and %d)", _ThreadId, getThreadId());
+00538         }
+00539 */
+00540 }
+00541 
+00542 
+00543 } // NLNET
+00544 
+
callback_net_base.cpp
