nel/src/net/transport_class.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 /*
  18  * Limitations: Not threadsafe, not reentrant.
  19  */
  20
  21 //
  22 // Includes
  23 //
  24
  25 #include "stdnet.h"
  26
  27 #include "nel/misc/types_nl.h"
  28 #include "nel/misc/debug.h"
  29 #include "nel/misc/entity_id.h"
  30 #include "nel/misc/sheet_id.h"
  31
  32 #include "nel/net/unified_network.h"
  33
  34 #include "nel/net/transport_class.h"
  35
  36 #ifdef DEBUG_NEW
  37 #define new DEBUG_NEW
  38 #endif
  39
  40 //
  41 // Namespace
  42 //
  43
  44 using namespace std;
  45 using namespace NLMISC;
  46 using namespace NLNET;
  47
  48 namespace NLNET {
  49
  50 //
  51 // Globals
  52 //
  53
  54 NLMISC::CVariable<bool> VerboseNETTC("nel","VerboseNETTC","Enable verbose logging in CTransportClass operations",true,0,true);
  55
  56
  57 //
  58 // Variables
  59 //
  60
  61 uint CTransportClass::Mode = 0; // 0=nothing 1=read 2=write 3=register
  62
  63 map<string, CTransportClass::CRegisteredClass>  CTransportClass::LocalRegisteredClass;  // registered class that are in my program
  64
  65 CTransportClass::CRegisteredClass       CTransportClass::TempRegisteredClass;
  66
  67 NLNET::CMessage CTransportClass::TempMessage;
  68
  69 vector<CTransportClass::CRegisteredBaseProp *> CTransportClass::DummyProp;
  70
  71 bool CTransportClass::Init = false;
  72
  73
  74 //
  75 // Functions
  76 //
  77
  78 string typeToString (CTransportClass::TProp type)
  79 {
  80         string conv[] = {
  81                 "PropUInt8", "PropUInt16", "PropUInt32", "PropUInt64",
  82                 "PropSInt8", "PropSInt16", "PropSInt32", "PropSInt64",
  83                 "PropBool", "PropFloat", "PropDouble", "PropString", "PropDataSetRow", "PropSheetId", "PropUCString", "PropUKN" };
  84 //              "PropBool", "PropFloat", "PropDouble", "PropString", "PropDataSetRow", "PropEntityId", "PropSheetId", "PropUKN" };
  85
  86         if (type > CTransportClass::PropUKN)
  87                 return "<InvalidType>";
  88         return conv[type];
  89 }
  90
  91 void CTransportClass::displayDifferentClass (TServiceId sid, const string &className, const vector<CRegisteredBaseProp> &otherClass, const vector<CRegisteredBaseProp *> &myClass)
  92 {
  93         NETTC_INFO ("NETTC: Service with sid %hu send me the TransportClass '%s' with differents properties:", sid.get(), className.c_str());
  94         NETTC_INFO ("NETTC:  My local TransportClass is:");
  95         for (uint i = 0; i < myClass.size(); i++)
  96         {
  97                 NETTC_INFO ("NETTC:    Property: %d Name: '%s' type: '%s'", i, myClass[i]->Name.c_str(), typeToString(myClass[i]->Type).c_str());
  98         }
  99
 100         NETTC_INFO ("NETTC:  The other side TransportClass is:");
 101         for (uint i = 0; i < otherClass.size(); i++)
 102         {
 103                 NETTC_INFO ("NETTC:    Property: %d Name: '%s' type: '%s'", i, otherClass[i].Name.c_str(), typeToString(otherClass[i].Type).c_str());
 104         }
 105 }
 106
 107 void CTransportClass::registerOtherSideClass (TServiceId sid, TOtherSideRegisteredClass &osrc)
 108 {
 109         for (TOtherSideRegisteredClass::iterator it = osrc.begin(); it != osrc.end (); it++)
 110         {
 111                 // find the class name in the map
 112
 113                 TRegisteredClass::iterator res = LocalRegisteredClass.find ((*it).first);
 114                 if (res == LocalRegisteredClass.end ())
 115                 {
 116                         // The other service knows a class that we don't
 117                         // there was previously an nlwarning here but that was wrong because it is quite normal for this to happen when one service
 118                         // ueses different transport classes to communicate with several different services, so the message has been changed to an nldebug
 119                         NETTC_DEBUG ("NETTC: the other side class '%s' declared from service %d is not registered in my system, skip it", (*it).first.c_str(),(uint32)sid.get());
 120                         continue;
 121                 }
 122
 123                 if (sid.get() >= (*res).second.Instance->States.size ())
 124                         (*res).second.Instance->States.resize (sid.get()+1);
 125
 126                 (*res).second.Instance->States[sid.get()].clear ();
 127
 128                 for (sint j = 0; j < (sint)(*it).second.size (); j++)
 129                 {
 130                         // check each prop to see the correspondance
 131
 132                         // try to find the prop name in the array
 133                         uint k;
 134                         for (k = 0; k < (*res).second.Instance->Prop.size(); k++)
 135                         {
 136                                 if ((*it).second[j].Name == (*res).second.Instance->Prop[k]->Name)
 137                                 {
 138                                         if ((*it).second[j].Type != (*res).second.Instance->Prop[k]->Type)
 139                                         {
 140                                                 nlwarning ("NETTC: Property '%s' of the class '%s' have not the same type in the 2 sides (%s %s)", (*it).second[j].Name.c_str(), (*it).first.c_str(), typeToString((*it).second[j].Type).c_str(), typeToString((*res).second.Instance->Prop[k]->Type).c_str());
 141                                         }
 142                                         break;
 143                                 }
 144                         }
 145                         if (k == (*res).second.Instance->Prop.size())
 146                         {
 147                                 // not found, put -1
 148                                 (*res).second.Instance->States[sid.get()].push_back (make_pair (-1, (*it).second[j].Type));
 149                         }
 150                         else
 151                         {
 152                                 // same, store the index
 153                                 (*res).second.Instance->States[sid.get()].push_back (make_pair (k, PropUKN));
 154                         }
 155                 }
 156
 157                 // check if the version are the same
 158                 if ((*it).second.size () != (*res).second.Instance->Prop.size ())
 159                 {
 160                         // 2 class don't have the same number of prop => different class => display class
 161                         displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop);
 162                 }
 163                 else
 164                 {
 165                         // check if the prop are same
 166                         for (uint i = 0; i < (*res).second.Instance->Prop.size (); i++)
 167                         {
 168                                 if ((*res).second.Instance->Prop[i]->Name != (*it).second[i].Name)
 169                                 {
 170                                         // different name => different class => display class
 171                                         displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop);
 172                                         break;
 173                                 }
 174                                 else if ((*res).second.Instance->Prop[i]->Type != (*it).second[i].Type)
 175                                 {
 176                                         // different type => different class => display class
 177                                         displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop);
 178                                         break;
 179                                 }
 180                         }
 181                 }
 182         }
 183
 184         displayLocalRegisteredClass ();
 185 }
 186
 187
 188 void CTransportClass::registerClass (CTransportClass &instance)
 189 {
 190         nlassert (Init);
 191         nlassert (Mode == 0);
 192
 193         // set the mode to register
 194         Mode = 3;
 195
 196         // clear the current class
 197         TempRegisteredClass.clear ();
 198
 199         // set the instance pointer
 200         TempRegisteredClass.Instance = &instance;
 201
 202         // fill name and props
 203         TempRegisteredClass.Instance->description ();
 204
 205         // add the new registered class in the array
 206         LocalRegisteredClass[TempRegisteredClass.Instance->Name] = TempRegisteredClass;
 207
 208         // set to mode none
 209         Mode = 0;
 210 }
 211
 212 void CTransportClass::unregisterClass ()
 213 {
 214         for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++)
 215         {
 216                 for (uint j = 0; j < (*it).second.Instance->Prop.size (); j++)
 217                 {
 218                         delete (*it).second.Instance->Prop[j];
 219                 }
 220                 (*it).second.Instance->Prop.clear ();
 221                 (*it).second.Instance = NULL;
 222         }
 223         LocalRegisteredClass.clear ();
 224 }
 225
 226 void CTransportClass::displayLocalRegisteredClass (CRegisteredClass &c)
 227 {
 228         NETTC_DEBUG ("NETTC:  > %s", c.Instance->Name.c_str());
 229         for (uint j = 0; j < c.Instance->Prop.size (); j++)
 230         {
 231                 NETTC_DEBUG ("NETTC:    > %s %s", c.Instance->Prop[j]->Name.c_str(), typeToString(c.Instance->Prop[j]->Type).c_str());
 232         }
 233
 234         for (uint l = 0; l < c.Instance->States.size (); l++)
 235         {
 236                 if (c.Instance->States[l].size () != 0)
 237                 {
 238                         NETTC_DEBUG ("NETTC:      > sid: %u", l);
 239                         for (uint k = 0; k < c.Instance->States[l].size (); k++)
 240                         {
 241                                 NETTC_DEBUG ("NETTC:      - %d type : %s", c.Instance->States[l][k].first, typeToString(c.Instance->States[l][k].second).c_str());
 242                         }
 243                 }
 244         }
 245 }
 246
 247 void CTransportClass::displayLocalRegisteredClass ()
 248 {
 249         NETTC_DEBUG ("NETTC:> LocalRegisteredClass:");
 250         for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++)
 251         {
 252                 displayLocalRegisteredClass ((*it).second);
 253         }
 254 }
 255
 256 void cbTCReceiveMessage (CMessage &msgin, const string &name, TServiceId sid)
 257 {
 258         NETTC_DEBUG ("NETTC: cbReceiveMessage");
 259
 260         CTransportClass::TempMessage.clear();
 261         CTransportClass::TempMessage.assignFromSubMessage( msgin );
 262
 263         string className;
 264         CTransportClass::readHeader(CTransportClass::TempMessage, className);
 265
 266         CTransportClass::TRegisteredClass::iterator it = CTransportClass::LocalRegisteredClass.find (className);
 267         if (it == CTransportClass::LocalRegisteredClass.end ())
 268         {
 269                 nlwarning ("NETTC: Receive unknown transport class '%s' received from %s-%hu", className.c_str(), name.c_str(), sid.get());
 270                 return;
 271         }
 272
 273         nlassert ((*it).second.Instance != NULL);
 274
 275         if (!(*it).second.Instance->read (name, sid))
 276         {
 277                 nlwarning ("NETTC: Can't read the transportclass '%s' received from %s-%hu (probably not registered on sender service)", className.c_str(), name.c_str(), sid.get());
 278         }
 279 }
 280
 281 void cbTCReceiveOtherSideClass (CMessage &msgin, const string &/* name */, TServiceId sid)
 282 {
 283         NETTC_DEBUG ("NETTC: cbReceiveOtherSideClass");
 284
 285         CTransportClass::TOtherSideRegisteredClass osrc;
 286
 287         uint32 nbClass;
 288         msgin.serial (nbClass);
 289
 290         NETTC_DEBUG ("NETTC: %d class", nbClass);
 291
 292         for (uint i = 0; i < nbClass; i++)
 293         {
 294                 string className;
 295                 msgin.serial (className);
 296
 297                 osrc.push_back(make_pair (className, vector<CTransportClass::CRegisteredBaseProp>()));
 298
 299                 uint32 nbProp;
 300                 msgin.serial (nbProp);
 301
 302                 NETTC_DEBUG ("NETTC:   %s (%d prop)", className.c_str(), nbProp);
 303
 304                 for (uint j = 0; j < nbProp; j++)
 305                 {
 306                         CTransportClass::CRegisteredBaseProp prop;
 307                         msgin.serial (prop.Name);
 308                         msgin.serialEnum (prop.Type);
 309                         NETTC_DEBUG ("NETTC:     %s %s", prop.Name.c_str(), typeToString(prop.Type).c_str());
 310                         osrc[osrc.size()-1].second.push_back (prop);
 311                 }
 312         }
 313
 314         // we have the good structure
 315         CTransportClass::registerOtherSideClass (sid, osrc);
 316 }
 317
 318 static TUnifiedCallbackItem CallbackArray[] =
 319 {
 320         { "CT_LRC", cbTCReceiveOtherSideClass },
 321         { "CT_MSG", cbTCReceiveMessage },
 322 };
 323
 324 void cbTCUpService (const std::string &serviceName, TServiceId sid, void * /* arg */)
 325 {
 326         NETTC_DEBUG ("NETTC: CTransportClass Service %s %hu is up", serviceName.c_str(), sid.get());
 327         if (sid.get() >= 256)
 328                 return;
 329         CTransportClass::sendLocalRegisteredClass (sid);
 330 }
 331
 332 void CTransportClass::init ()
 333 {
 334         // this isn't an error!
 335         if (Init) return;
 336
 337         CUnifiedNetwork::getInstance()->addCallbackArray (CallbackArray, sizeof (CallbackArray) / sizeof (CallbackArray[0]));
 338
 339         // create an instance of all d'ifferent prop types
 340
 341         DummyProp.resize (PropUKN);
 342
 343         nlassert (PropUInt8 < PropUKN); DummyProp[PropUInt8] = new CTransportClass::CRegisteredProp<uint8>;
 344         nlassert (PropUInt16 < PropUKN); DummyProp[PropUInt16] = new CTransportClass::CRegisteredProp<uint16>;
 345         nlassert (PropUInt32 < PropUKN); DummyProp[PropUInt32] = new CTransportClass::CRegisteredProp<uint32>;
 346         nlassert (PropUInt64 < PropUKN); DummyProp[PropUInt64] = new CTransportClass::CRegisteredProp<uint64>;
 347         nlassert (PropSInt8 < PropUKN); DummyProp[PropSInt8] = new CTransportClass::CRegisteredProp<sint8>;
 348         nlassert (PropSInt16 < PropUKN); DummyProp[PropSInt16] = new CTransportClass::CRegisteredProp<sint16>;
 349         nlassert (PropSInt32 < PropUKN); DummyProp[PropSInt32] = new CTransportClass::CRegisteredProp<sint32>;
 350         nlassert (PropSInt64 < PropUKN); DummyProp[PropSInt64] = new CTransportClass::CRegisteredProp<sint64>;
 351         nlassert (PropBool < PropUKN); DummyProp[PropBool] = new CTransportClass::CRegisteredProp<bool>;
 352         nlassert (PropFloat < PropUKN); DummyProp[PropFloat] = new CTransportClass::CRegisteredProp<float>;
 353         nlassert (PropDouble < PropUKN); DummyProp[PropDouble] = new CTransportClass::CRegisteredProp<double>;
 354         nlassert (PropString < PropUKN); DummyProp[PropString] = new CTransportClass::CRegisteredProp<string>;
 355 //      nlassert (PropDataSetRow < PropUKN); DummyProp[PropDataSetRow] = new CTransportClass::CRegisteredProp<TDataSetRow>;
 356 //      nlassert (PropEntityId < PropUKN); DummyProp[PropEntityId] = new CTransportClass::CRegisteredProp<CEntityId>;
 357         nlassert (PropSheetId < PropUKN); DummyProp[PropSheetId] = new CTransportClass::CRegisteredProp<CSheetId>;
 358         nlassert (PropUCString < PropUKN); DummyProp[PropUCString] = new CTransportClass::CRegisteredProp<ucstring>;
 359
 360         // we have to know when a service comes, so add callback (put the callback before all other one because we have to send this message first)
 361         CUnifiedNetwork::getInstance()->setServiceUpCallback("*", cbTCUpService, NULL, false);
 362
 363         Init = true;
 364 }
 365
 366 void CTransportClass::release ()
 367 {
 368         unregisterClass ();
 369
 370         for (uint i = 0; i < DummyProp.size (); i++)
 371         {
 372                 delete DummyProp[i];
 373         }
 374         DummyProp.clear ();
 375 }
 376
 377 void CTransportClass::createLocalRegisteredClassMessage ()
 378 {
 379         TempMessage.clear ();
 380         if (TempMessage.isReading())
 381                 TempMessage.invert();
 382         TempMessage.setType ("CT_LRC");
 383
 384         uint32 nbClass = (uint32)LocalRegisteredClass.size ();
 385         TempMessage.serial (nbClass);
 386
 387         for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++)
 388         {
 389                 nlassert ((*it).first == (*it).second.Instance->Name);
 390
 391                 TempMessage.serial ((*it).second.Instance->Name);
 392
 393                 uint32 nbProp = (uint32)(*it).second.Instance->Prop.size ();
 394                 TempMessage.serial (nbProp);
 395
 396                 for (uint j = 0; j < (*it).second.Instance->Prop.size (); j++)
 397                 {
 398                         // send the name and the type of the prop
 399                         TempMessage.serial ((*it).second.Instance->Prop[j]->Name);
 400                         TempMessage.serialEnum ((*it).second.Instance->Prop[j]->Type);
 401                 }
 402         }
 403 }
 404
 405
 406 /*
 407  * Get the name of message (for displaying), or extract the class name if it is a transport class.
 408  *
 409  * Preconditions:
 410  * - msgin is an input message that contains a valid message
 411  *
 412  * Postconditions:
 413  * - the pos in msgin was modified
 414  * - msgName contains "msg %s" or "transport class %s" where %s is the name of message, or the name
 415  * transport class is the message is a CT_MSG.
 416  */
 417 void getNameOfMessageOrTransportClass( NLNET::CMessage& msgin, std::string& msgName )
 418 {
 419         if ( msgin.getName() == "CT_MSG" )
 420         {
 421                 try
 422                 {
 423                         msgin.seek( msgin.getHeaderSize(), NLMISC::IStream::begin );
 424                         msgin.serial( msgName );
 425                 }
 426                 catch (const EStreamOverflow&)
 427                 {
 428                         msgName = "<Name not found>";
 429                 }
 430                 msgName = "transport class " + msgName;
 431         }
 432         else
 433         {
 434                 msgName = "msg " + msgin.getName();
 435         }
 436 }
 437
 438 } // NLNET