nel/src/net/message.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/message.h"
  20
  21 /*#ifdef MESSAGES_PLAIN_TEXT
  22 #pragma message( "CMessage: compiling messages as plain text" )
  23 #else
  24 #pragma message( "CMessage: compiling messages as binary" )
  25 #endif*/
  26
  27 namespace NLNET
  28 {
  29
  30 bool CMessage::_DefaultStringMode = false;
  31
  32 const char *LockedSubMessageError = "a sub message is forbidden";
  33
  34 #define FormatLong 1
  35 #define FormatShort 0
  36
  37
  38 /*
  39  * Constructor by name
  40  */
  41 CMessage::CMessage (const std::string &name, bool inputStream, TStreamFormat streamformat, uint32 defaultCapacity) :
  42         NLMISC::CMemStream (inputStream, false, defaultCapacity),
  43         _Type(OneWay), _SubMessagePosR(0), _LengthR(0), _HeaderSize(0xFFFFFFFF), _TypeSet (false)
  44 {
  45         init( name, streamformat );
  46 }
  47
  48
  49 /*
  50  * Utility method
  51  */
  52 void CMessage::init( const std::string &name, TStreamFormat streamformat )
  53 {
  54         if ( streamformat == UseDefault )
  55         {
  56                 setStringMode( _DefaultStringMode );
  57         }
  58         else
  59         {
  60                 setStringMode( streamformat == String );
  61         }
  62
  63         if (!name.empty())
  64                 setType (name);
  65 }
  66
  67
  68 /*
  69  * Constructor with copy from CMemStream
  70  */
  71 CMessage::CMessage (NLMISC::CMemStream &memstr) :
  72         NLMISC::CMemStream( memstr ),
  73         _Type(OneWay), _SubMessagePosR(0), _LengthR(0), _HeaderSize(0xFFFFFFFF), _TypeSet (false)
  74 {
  75         sint32 pos = getPos();
  76         bool reading = isReading();
  77         if ( reading ) // force input mode to read the type
  78                 readType(); // sets _TypeSet, _HeaderSize and _LengthR
  79         else
  80                 invert(); // calls readType()
  81         if ( ! reading )
  82                 invert(); // set output mode back if necessary
  83         seek( pos, begin ); // sets the same position as the one in the memstream
  84 }
  85
  86
  87 /*
  88  * Copy constructor
  89  */
  90 CMessage::CMessage (const CMessage &other)
  91         :       CMemStream(),
  92                 _TypeSet(false)
  93 {
  94         operator= (other);
  95 }
  96
  97 /*
  98  * Assignment operator
  99  */
 100 CMessage &CMessage::operator= (const CMessage &other)
 101 {
 102 //      nlassertex( (!other.isReading()) || (!other.hasLockedSubMessage()), ("Storing %s", LockedSubMessageError) );
 103         nlassertex( (!isReading()) || (!hasLockedSubMessage()), ("Assigning %s", LockedSubMessageError) );
 104         if ( other.hasLockedSubMessage() )
 105         {
 106                 assignFromSubMessage(other);
 107         }
 108         else
 109         {
 110
 111                 CMemStream::operator= (other);
 112                 _Type = other._Type;
 113                 _TypeSet = other._TypeSet;
 114                 _Name = other._Name;
 115                 _HeaderSize = other._HeaderSize;
 116                 _SubMessagePosR = other._SubMessagePosR;
 117                 _LengthR = other._LengthR;
 118         }
 119
 120         return *this;
 121 }
 122
 123 void CMessage::swap(CMessage &other)
 124 {
 125         nlassert( !hasLockedSubMessage() );
 126         CMemStream::swap(other);
 127         _Name.swap(other._Name);
 128         std::swap(_SubMessagePosR, other._SubMessagePosR);
 129         std::swap(_LengthR, other._LengthR);
 130         std::swap(_HeaderSize, other._HeaderSize);
 131         std::swap(_TypeSet, other._TypeSet);
 132         std::swap(_Type, other._Type);
 133 }
 134
 135
 136 /**
 137  * Similar to operator=, but makes the current message contain *only* the locked sub message in msgin
 138  * or the whole msgin if it is not locked
 139  *
 140  * Preconditions:
 141  * - msgin is an input message (isReading())
 142  * - The current message is blank (new or reset with clear())
 143  *
 144  * Postconditions:
 145  * - If msgin has been locked using lockSubMessage(), the current message contains only the locked
 146  *   sub message in msgin, otherwise the current message is exactly msgin
 147  * - The current message is an input message, it is not locked
 148  */
 149 void CMessage::assignFromSubMessage( const CMessage& msgin )
 150 {
 151         nlassert( msgin.isReading() );
 152         nlassert( ! _TypeSet );
 153         if ( ! isReading() )
 154                 invert();
 155
 156         if ( msgin.hasLockedSubMessage() )
 157         {
 158                 fill( msgin.buffer(), msgin._LengthR );
 159                 readType();
 160                 seek( msgin.getPos(), IStream::begin );
 161         }
 162         else
 163         {
 164                 operator=( msgin );
 165         }
 166 }
 167
 168
 169 /*
 170  * Sets the message type as a string and put it in the buffer if we are in writing mode
 171  */
 172 void CMessage::setType (const std::string &name, TMessageType type)
 173 {
 174         // check if we already do a setType ()
 175         nlassert (!_TypeSet);
 176         // don't accept empty string
 177         nlassert (!name.empty ());
 178
 179         _Name = name;
 180         _Type = type;
 181
 182         if (!isReading ())
 183         {
 184                 // check if they don't already serial some stuffs
 185                 nlassert (length () == 0);
 186
 187                 // if we can send the id instead of the string, "just do it" (c)nike!
 188                 //NLMISC::CStringIdArray::TStringId id = _SIDA->getId (name);
 189
 190                 // Force binary mode for header
 191                 bool msgmode = _StringMode;
 192                 _StringMode = false;
 193
 194                 // debug features, we number all packet to be sure that they are all sent and received
 195                 // \todo remove this debug feature when ok
 196                 // this value will be fill after in the callback function
 197                 uint32 zeroValue = 123;
 198                 serial (zeroValue);
 199
 200
 201                 TFormat format;
 202                 format.LongFormat = FormatLong;
 203                 format.StringMode = msgmode;
 204                 format.MessageType = _Type;
 205                 //nldebug( "OUT format = %hu", (uint16)format );
 206                 serial (format);
 207
 208                 // End of binary header
 209                 _StringMode = msgmode;
 210
 211                 serial ((std::string&)name);
 212
 213                 _HeaderSize = getPos ();
 214         }
 215
 216         _TypeSet = true;
 217 }
 218
 219
 220 /*
 221  * Warning: MUST be of the same size than previous name!
 222  * Output message only.
 223  */
 224 void CMessage::changeType (const std::string &name)
 225 {
 226         sint32 prevPos = getPos();
 227         seek( sizeof(uint32)+sizeof(uint8), begin );
 228         serial ((std::string&)name);
 229         seek( prevPos, begin );
 230 }
 231
 232
 233 /*
 234  * Returns the size, in byte of the header that contains the type name of the message or the type number
 235  */
 236 uint32 CMessage::getHeaderSize () const
 237 {
 238         nlassert (_HeaderSize != 0xFFFFFFFF);
 239         nlassert(!hasLockedSubMessage());
 240         return _HeaderSize;
 241 }
 242
 243
 244 /*
 245  * The message was filled with an CMemStream, Now, we'll get the message type on this buffer
 246  */
 247 void CMessage::readType ()
 248 {
 249         nlassert (isReading ());
 250
 251         // debug features, we number all packet to be sure that they are all sent and received
 252         // \todo remove this debug feature when ok
 253
 254         // we remove the message from the message
 255         resetSubMessageInternals();
 256         const uint HeaderSize = 4;
 257         seek (HeaderSize, begin);
 258 //              uint32 zeroValue;
 259 //              serial (zeroValue);
 260
 261         // Force binary mode for header
 262         _StringMode = false;
 263
 264         TFormat format;
 265         serial (format);
 266         //nldebug( "IN format = %hu", (uint16)format );
 267
 268         // Set mode for the following of the buffer
 269         _StringMode = format.StringMode;
 270
 271         std::string name;
 272         serial (name);
 273         setType (name, TMessageType(format.MessageType));
 274         _HeaderSize = getPos();
 275 }
 276
 277
 278 /*
 279  * Get the message name (input message only) and advance the current pos
 280  */
 281 std::string CMessage::readTypeAtCurrentPos() const
 282 {
 283         nlassert( isReading() );
 284
 285         const uint HeaderSize = 4;
 286         seek( HeaderSize, current );
 287
 288         bool sm = _StringMode;
 289         _StringMode = false;
 290
 291         TFormat format;
 292         nlRead(*this, serial, format );
 293         bool LongFormat = format.LongFormat;
 294         _StringMode = format.StringMode;
 295         _Type = TMessageType(format.MessageType);
 296
 297         if ( LongFormat )
 298         {
 299                 std::string name;
 300                 nlRead(*this, serial, name );
 301                 _StringMode = sm;
 302                 return name;
 303         }
 304         else
 305                 nlerror( "Id not supported" );
 306
 307
 308         _StringMode = sm;
 309         return "";
 310 }
 311
 312
 313 // Returns true if the message type was already set
 314 bool CMessage::typeIsSet () const
 315 {
 316         return _TypeSet;
 317 }
 318
 319 // Clear the message. With this function, you can reuse a message to create another message
 320 void CMessage::clear ()
 321 {
 322         nlassertex( (!isReading()) || (!hasLockedSubMessage()), ("Clearing %s", LockedSubMessageError) );
 323
 324         CMemStream::clear ();
 325         _TypeSet = false;
 326         _SubMessagePosR = 0;
 327         _LengthR = 0;
 328 }
 329
 330 /*
 331  * Returns the type name in string if available. Be sure that the message have the name of the message type
 332  */
 333 std::string CMessage::getName () const
 334 {
 335         if ( hasLockedSubMessage() )
 336         {
 337                 CMessage& notconstMsg = const_cast<CMessage&>(*this);
 338                 sint32 savedPos = notconstMsg.getPos();
 339                 uint32 subPosSaved = _SubMessagePosR;
 340                 uint32 lenthRSaved = _LengthR;
 341                 const_cast<uint32&>(_SubMessagePosR) = 0;
 342 //              const_cast<uint32&>(_LengthR) = _Buffer.size();
 343                 const_cast<uint32&>(_LengthR) = _Buffer.getBuffer().size();
 344                 notconstMsg.seek( subPosSaved, begin ); // not really const... but removing the const from getName() would need too many const changes elsewhere
 345                 std::string name = notconstMsg.readTypeAtCurrentPos();
 346                 notconstMsg.seek( subPosSaved+savedPos, begin );
 347                 const_cast<uint32&>(_SubMessagePosR) = subPosSaved;
 348                 const_cast<uint32&>(_LengthR) = lenthRSaved;
 349                 return name;
 350         }
 351         else
 352         {
 353                 nlassert (_TypeSet);
 354                 return _Name;
 355         }
 356 }
 357
 358 CMessage::TMessageType CMessage::getType() const
 359 {
 360         if ( hasLockedSubMessage() )
 361         {
 362                 CMessage& notconstMsg = const_cast<CMessage&>(*this);
 363                 sint32 savedPos = notconstMsg.getPos();
 364                 uint32 subPosSaved = _SubMessagePosR;
 365                 uint32 lenthRSaved = _LengthR;
 366                 const_cast<uint32&>(_SubMessagePosR) = 0;
 367 //              const_cast<uint32&>(_LengthR) = _Buffer.size();
 368                 const_cast<uint32&>(_LengthR) = _Buffer.getBuffer().size();
 369                 notconstMsg.seek( subPosSaved, begin ); // not really const... but removing the const from getName() would need too many const changes elsewhere
 370                 notconstMsg.readTypeAtCurrentPos();
 371                 notconstMsg.seek( subPosSaved+savedPos, begin );
 372                 const_cast<uint32&>(_SubMessagePosR) = subPosSaved;
 373                 const_cast<uint32&>(_LengthR) = lenthRSaved;
 374                 return _Type;
 375         }
 376         else
 377         {
 378                 nlassert (_TypeSet);
 379                 return _Type;
 380         }
 381 }
 382
 383
 384 /* Returns a readable string to display it to the screen. It's only for debugging purpose!
 385  * Don't use it for anything else than to debugging, the string format could change in the future.
 386  * \param hexFormat If true, display all bytes in hexadecimal
 387  * \param textFormat If true, display all bytes as chars (above 31, otherwise '.')
 388  */
 389 std::string CMessage::toString( bool hexFormat, bool textFormat ) const
 390 {
 391         //nlassert (_TypeSet);
 392         std::string s = "('" + _Name + "')";
 393         if ( hexFormat )
 394                 s += " " + CMemStream::toString( true );
 395         if ( textFormat )
 396                 s += " " + CMemStream::toString( false );
 397         return s;
 398 }
 399
 400
 401 /*
 402  * Return an input stream containing the stream beginning in the message at the specified pos
 403  */
 404 NLMISC::CMemStream      CMessage::extractStreamFromPos( sint32 pos )
 405 {
 406         NLMISC::CMemStream msg( true );
 407         sint32 len = length() - pos;
 408         memcpy( msg.bufferToFill( len ), buffer() + pos, len );
 409         return msg;
 410 }
 411
 412
 413 /*
 414  * Encapsulate/decapsulate another message inside the current message
 415  */
 416 void    CMessage::serialMessage( CMessage& msg )
 417 {
 418         if ( isReading() )
 419         {
 420                 // Init 'msg' with the contents serialised from 'this'
 421                 uint32 len;
 422                 serial( len );
 423                 if ( ! msg.isReading() )
 424                         msg.invert();
 425                 serialBuffer( msg.bufferToFill( len ), len );
 426                 msg.readType();
 427                 msg.invert();
 428                 msg.seek( 0, CMemStream::end );
 429         }
 430         else
 431         {
 432                 // Store into 'this' the contents of 'msg'
 433                 uint32 len = msg.length();
 434                 serial( len );
 435                 serialBuffer( const_cast<uint8*>(msg.buffer()), msg.length() );
 436         }
 437 }
 438
 439 }