nel/src/net/message_recorder.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2016  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdnet.h"
  21
  22 #include "nel/net/message_recorder.h"
  23 #include "nel/net/inet_address.h"
  24
  25 using namespace NLMISC;
  26 using namespace std;
  27
  28
  29 namespace NLNET {
  30
  31
  32 /// TNetworkEvent -> string
  33 string EventToString( TNetworkEvent e )
  34 {
  35         switch ( e )
  36         {
  37         case Sending: return "SEND";
  38         case Receiving: return "RECV";
  39         case Connecting: return "CONN";
  40         case ConnFailing: return "CNFL";
  41         case Accepting: return "ACCP";
  42         case Disconnecting: return "DISC";
  43         default: nlstop; return "-ERR-";
  44         }
  45 }
  46
  47 /// string -> TNetworkEvent
  48 TNetworkEvent StringToEvent( string& s )
  49 {
  50         if ( s == "RECV" )
  51                 return Receiving;
  52         else if ( s == "SEND" )
  53                 return Sending;
  54         else if ( s == "DISC" )
  55                 return Disconnecting;
  56         else if ( s == "ACCP" )
  57                 return Accepting;
  58         else if ( s == "CONN" )
  59                 return Connecting;
  60         else if ( s == "CNFL" )
  61                 return ConnFailing;
  62         else
  63         {
  64                 nlstop;
  65                 return Error;
  66         }
  67 }
  68
  69
  70 /*
  71  * Constructor
  72  */
  73 CMessageRecorder::CMessageRecorder() : _RecordAll(true)
  74 {
  75 #ifndef MESSAGES_PLAIN_TEXT
  76         nlerror( "The message recorder works only with plain text messages. Please #define MESSAGES_PLAIN_TEXT" );
  77 #endif
  78 }
  79
  80
  81 /*
  82  * Destructor
  83  */
  84 CMessageRecorder::~CMessageRecorder()
  85 {
  86         if ( !_Filename.empty() )
  87         {
  88                 nldebug( "MR:%s: End of recording", _Filename.c_str() );
  89         }
  90         stopRecord();
  91         stopReplay();
  92 }
  93
  94
  95 /*
  96  * Start recording
  97  */
  98 bool CMessageRecorder::startRecord( const std::string& filename, bool recordall )
  99 {
 100         _Filename = filename;
 101         _File.open( _Filename.c_str(), ios_base::out );
 102         _File << endl;
 103         _RecordAll = recordall;
 104         if ( _File.fail() )
 105         {
 106                 nlwarning( "MR: Record: Cannot open file %s", _Filename.c_str() );
 107                 return false;
 108         }
 109         else
 110         {
 111                 nldebug( "MR: Start recording into %s", _Filename.c_str() );
 112                 return true;
 113         }
 114 }
 115
 116
 117 /*
 118  * Same as stringFromVector() but assumes the vector contains only printable characters
 119  */
 120 /*string stringFromTextVector( const vector<uint8>& v )
 121 {
 122         string s;
 123
 124         // Copy contents
 125         s.resize( v.size() );
 126         memcpy( &*s.begin(), &*v.begin(), v.size() );
 127
 128         return s;
 129 }*/
 130
 131
 132 /*
 133  * Add a record
 134  */
 135 void CMessageRecorder::recordNext( sint64 updatecounter, TNetworkEvent event, TSockId sockid, CMessage& message )
 136 {
 137         nlassert( _File.is_open() );
 138
 139         if ( (_RecordAll) || (event != Sending) )
 140         {
 141                 // Serial to stream
 142                 TMessageRecord rec ( event, sockid, message, updatecounter /*CTime::getLocalTime()*/ );
 143                 CMemStream stream ( false, true );
 144                 rec.serial( stream );
 145                 char c = '\0';      // end of cstring
 146                 stream.serial( c ); // added to the stream for _File << (char*)stream.buffer()
 147
 148                 // Dump to file
 149                 nldebug( "MR:%s: Recording [%s]", _Filename.c_str(), stream.buffer() );
 150                 int len = (int)(stream.length()-2); // not the null character (and its separator) at the end of the buffer
 151                 _File << "* ";
 152                 _File <<  len; // if we put the expression directly, it makes an access violation ! Weird.
 153                 _File << " ";
 154                 _File << (char*)stream.buffer() << endl;
 155         }
 156 }
 157
 158
 159 /*
 160  * Stop recording
 161  */
 162 void CMessageRecorder::stopRecord()
 163 {
 164         _File.close();
 165         _Filename.clear();
 166 }
 167
 168
 169 /*
 170  * Start playback
 171  */
 172 bool CMessageRecorder::startReplay( const std::string& filename )
 173 {
 174         _Filename = filename;
 175         _File.open( _Filename.c_str(), ios_base::in );
 176         if ( _File.fail() )
 177         {
 178                 nlerror( "MR: Replay: Cannot open file %s", _Filename.c_str() );
 179                 return false;
 180         }
 181         else
 182         {
 183                 nldebug( "MR: Start replaying from %s", _Filename.c_str() );
 184                 return true;
 185         }
 186 }
 187
 188
 189 /*
 190  * Get next record (throw EStreamOverflow)
 191  */
 192 bool CMessageRecorder::loadNext( TMessageRecord& record )
 193 {
 194         // WARNING!!! This features doesn't work anymore becaues bufferAsVector() is not available with new CMemStream
 195         nlstop;
 196         return false;
 197
 198         nlassert( _File.is_open() );
 199
 200         // Dump from file
 201         CMemStream stream ( true, true );
 202         uint32 len;
 203         char c;
 204         _File >> c; // skip "* ";
 205         _File >> (int&)len;
 206         _File.ignore(); // skip delimiter
 207         if ( ! _File.fail() )
 208         {
 209                 _File.get( (char*)stream.bufferToFill( len+1 ), len+1, '\0' );
 210                 //stream.bufferAsVector().resize( len ); // cut end of cstring
 211                 nldebug( "MR:%s: Reading [%s]", _Filename.c_str(), stream.buffer() );
 212
 213                 // Serial from stream
 214                 record.serial( stream ); // may throw EStreamOverflow if _File.fail()
 215         }
 216
 217         return ! _File.fail(); // retest
 218 }
 219
 220
 221 /*
 222  * Get the next record (from the preloaded records, or from the file)
 223  */
 224 bool CMessageRecorder::getNext( TMessageRecord& record, sint64 updatecounter )
 225 {
 226         if ( ! _PreloadedRecords.empty() )
 227         {
 228                 if ( _PreloadedRecords.front().UpdateCounter == updatecounter )
 229                 {
 230                         // The requested record is in the preload
 231                         record = _PreloadedRecords.front();
 232                         _PreloadedRecords.pop_front();
 233                         return true;
 234                 }
 235                 else
 236                 {
 237                         // The requested record is not in the file
 238                         nlassert( updatecounter < _PreloadedRecords.front().UpdateCounter ); // not >
 239                         return false;
 240                 }
 241         }
 242         else
 243         {
 244                 if ( loadNext( record ) )
 245                 {
 246                         if ( record.UpdateCounter == updatecounter )
 247                         {
 248                                 // The requested record has been loaded
 249                                 return true;
 250                         }
 251                         else
 252                         {
 253                                 // The next loaded record is a new one
 254                                 nlassert( updatecounter < record.UpdateCounter ); // not >
 255                                 _PreloadedRecords.push_back( record ); // when we read one too far
 256                                 return false;
 257                         }
 258                 }
 259                 else
 260                 {
 261                         return false;
 262                 }
 263         }
 264 }
 265
 266
 267 /*
 268  * Push the received blocks for this counter into the receive queue
 269  */
 270 void CMessageRecorder::replayNextDataAvailable( sint64 updatecounter )
 271 {
 272         TMessageRecord rec( true ); // input message
 273
 274         while ( getNext( rec, updatecounter ) )
 275         {
 276                 switch ( rec.Event )
 277                 {
 278                 case Receiving :
 279                 case Accepting :
 280                 case Disconnecting :
 281                         ReceivedMessages.push( rec );
 282                         break;
 283
 284                 case Sending :
 285                         break;
 286
 287                 case Connecting :
 288                 case ConnFailing :
 289                         _ConnectionAttempts.push_back( rec );
 290                         break;
 291
 292                 default :
 293                         nlstop;
 294                 }
 295         }
 296 }
 297
 298
 299 /*
 300  * Returns true and the event type if the counter of the next data is updatecounter
 301  */
 302 TNetworkEvent CMessageRecorder::checkNextOne( sint64 updatecounter )
 303 {
 304         TMessageRecord record;
 305         if ( getNext( record, updatecounter ) )
 306         {
 307                 nldebug( "MR: Check next one: %s at update %" NL_I64 "u", EventToString(record.Event).c_str(), updatecounter );
 308                 return record.Event;
 309         }
 310         else
 311         {
 312                 return Error;
 313         }
 314 }
 315
 316
 317 /*
 318  * Get the first stored connection attempt corresponding to addr
 319  */
 320 TNetworkEvent CMessageRecorder::replayConnectionAttempt( const CInetAddress& addr )
 321 {
 322         TNetworkEvent event;
 323         deque<TMessageRecord>::iterator ipr;
 324
 325         if ( ! _ConnectionAttempts.empty() )
 326         {
 327                 // Search in the already processed connection attempts
 328                 for ( ipr=_ConnectionAttempts.begin(); ipr!=_ConnectionAttempts.end(); ++ipr )
 329                 {
 330                         CInetAddress stored_addr;
 331                         (*ipr).Message.serial( stored_addr );
 332                         if ( stored_addr == addr )
 333                         {
 334                                 // Found
 335                                 event = (*ipr).Event;
 336                                 nldebug( "MR: Connection attempt found at update %" NL_I64 "u", (*ipr).UpdateCounter );
 337                                 _ConnectionAttempts.erase( ipr );
 338                                 return event;
 339                         }
 340                 }
 341         }
 342
 343         // Seek in the preloaded records
 344         for ( ipr=_PreloadedRecords.begin(); ipr!=_PreloadedRecords.end(); ++ipr )
 345         {
 346                 event = (*ipr).Event;
 347                 if ( (event == Connecting) || (event == ConnFailing) )
 348                 {
 349                         CInetAddress stored_addr;
 350                         (*ipr).Message.serial( stored_addr );
 351                         if ( stored_addr == addr )
 352                         {
 353                                 // Found
 354                                 nldebug( "MR: Connection attempt found at update %" NL_I64 "u", (*ipr).UpdateCounter );
 355                                 _PreloadedRecords.erase( ipr );
 356                                 return event;
 357                         }
 358                 }
 359         }
 360         if ( ipr==_PreloadedRecords.end() )
 361         {
 362                 // If not found, load next records until found !
 363                 TMessageRecord rec( true );
 364                 while ( loadNext( rec ) )
 365                 {
 366                         if ( ( rec.Event == Connecting ) || ( rec.Event == ConnFailing ) )
 367                         {
 368                                 CInetAddress stored_addr;
 369                                 rec.Message.serial( stored_addr );
 370                                 if ( stored_addr == addr )
 371                                 {
 372                                         // Found
 373                                         nldebug( "MR: Connection attempt found at update %" NL_I64 "u", rec.UpdateCounter );
 374                                         return rec.Event;
 375                                 }
 376                                 else
 377                                 {
 378                                         _PreloadedRecords.push_back( rec );
 379                                 }
 380                         }
 381                         else
 382                         {
 383                                 _PreloadedRecords.push_back( rec );
 384                         }
 385                 }
 386                 // Not found
 387                 nldebug( "MR: Connection attempt not found" );
 388                 return Error;
 389         }
 390         nlstop;
 391         return Error;
 392 }
 393
 394
 395 /*
 396  * Stop playback
 397  */
 398 void CMessageRecorder::stopReplay()
 399 {
 400         _File.close();
 401         _Filename.clear();
 402 }
 403
 404
 405 } // NLNET