nel/src/net/module_l5_transport.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 #include "nel/net/module_gateway.h"
  19 #include "nel/net/module.h"
  20 #include "nel/net/module_manager.h"
  21 #include "nel/net/module_socket.h"
  22 #include "nel/net/module_message.h"
  23 #include "nel/net/unified_network.h"
  24 #include "nel/net/service.h"
  25 #include "nel/net/net_log.h"
  26
  27
  28 using namespace std;
  29 using namespace NLMISC;
  30
  31
  32
  33 namespace NLNET
  34 {
  35         typedef uint8   TL5TransportId;
  36
  37         struct TTransportDesc
  38         {
  39                 TL5TransportId          TransportId;
  40                 string                          SubNetName;
  41                 bool                            InResponse;
  42
  43                 void serial(NLMISC::IStream &s)
  44                 {
  45                         s.serial(TransportId);
  46                         s.serial(SubNetName);
  47                         s.serial(InResponse);
  48                 }
  49         };
  50
  51         /** the specialized route for l5 transport */
  52         class CL5Route : public CGatewayRoute
  53         {
  54         public:
  55                 /// the service ID of the outbound service
  56                 TServiceId              ServiceId;
  57
  58                 /// The transport ID at the outbound
  59                 TL5TransportId  ForeignTransportId;
  60
  61
  62                 CL5Route(IGatewayTransport *transport)
  63                         : CGatewayRoute(transport)
  64                 {
  65                 }
  66
  67                 void sendMessage(const CMessage &message) const;
  68         };
  69
  70         /** Utility class that generate 8bits unique transport id.
  71          *      The total L5 transport instance is limited to 256.
  72          *      This really should be enough or you have a problem in
  73          *      your design !
  74          *      The allocator keep released ID as long as possible
  75          *      and reallocated them only when all other ids
  76          *      have been used/allocated.
  77          */
  78         class CTransportIdAllocator
  79         {
  80                 NLMISC_SAFE_SINGLETON_DECL(CTransportIdAllocator);
  81         private:
  82                 deque<TL5TransportId>   _FreeIds;
  83                 set<TL5TransportId>             _UsedIds;
  84
  85                 CTransportIdAllocator()
  86                 {
  87                         // fill the list of free ids;
  88                         for (TL5TransportId i=0; i<TL5TransportId(UINT64_CONSTANT(0xffffffffffffffff)); ++i)
  89                         {
  90                                 _FreeIds.push_back(i);
  91                         }
  92                 }
  93
  94         public:
  95                 TL5TransportId allocateId()
  96                 {
  97                         nlassert(!_FreeIds.empty());
  98                         TL5TransportId ret = _FreeIds.front();
  99                         _FreeIds.pop_front();
 100                         nlassert(_UsedIds.find(ret) == _UsedIds.end());
 101                         _UsedIds.insert(ret);
 102                         return ret;
 103                 }
 104
 105                 void releaseId(TL5TransportId id)
 106                 {
 107                         nlassert(_UsedIds.find(id) != _UsedIds.end());
 108                         _UsedIds.erase(id);
 109                         _FreeIds.push_back(id);
 110                 }
 111         };
 112
 113         NLMISC_SAFE_SINGLETON_IMPL(CTransportIdAllocator);
 114
 115 #define LAYER5_CLASS_NAME "L5Transport"
 116
 117         /** Gateway transport using layer 5 */
 118         class CGatewayL5Transport : public IGatewayTransport
 119         {
 120                 friend class CL5Route;
 121         public:
 122                 /// This transport ID
 123                 TL5TransportId  _TransportId;
 124
 125                 /// current open status
 126                 bool                    _Open;
 127                 /// Subnet name
 128                 string                  _SubNetName;
 129
 130                 typedef std::map<TServiceId, CL5Route*> TRouteMap;
 131                 /// The table that keep track of all routes
 132                 TRouteMap       _Routes;
 133
 134                 typedef std::map<TL5TransportId, CGatewayL5Transport*>  TTransportDispatcher;
 135                 /// Global index of transport use to dispatch received message
 136                 static TTransportDispatcher     _TransportDispatcher;
 137
 138                 /// Constructor
 139                 CGatewayL5Transport(const IGatewayTransport::TCtorParam &param)
 140                         : IGatewayTransport(param),
 141                         _Open(false)
 142                 {
 143                         // allocate a transport unique ID
 144                         _TransportId = CTransportIdAllocator::getInstance().allocateId();
 145
 146                         // store the transport in the dispatcher
 147                         _TransportDispatcher.insert(make_pair(_TransportId, this));
 148
 149                         // L5 transport is always peer invisible
 150                         PeerInvisible = true;
 151                 }
 152
 153                 ~CGatewayL5Transport()
 154                 {
 155                         if (_Open)
 156                         {
 157                                 // the transport is still open, close it before destruction
 158                                 close();
 159                         }
 160
 161                         // remove the transport from the dispatcher
 162                         nlassert(_TransportDispatcher.find(_TransportId) != _TransportDispatcher.end());
 163                         _TransportDispatcher.erase(_TransportId);
 164                         // release the unique id
 165                         CTransportIdAllocator::getInstance().releaseId(_TransportId);
 166                 }
 167
 168                 const std::string &getClassName() const
 169                 {
 170                         static string className(LAYER5_CLASS_NAME);
 171                         return className;
 172                 }
 173
 174                 virtual void update()
 175                 {
 176                 }
 177
 178                 virtual uint32 getRouteCount() const
 179                 {
 180                         return (uint32)_Routes.size();
 181                 }
 182
 183                 void dump(NLMISC::CLog &log) const
 184                 {
 185                         IModuleManager &mm = IModuleManager::getInstance();
 186                         log.displayNL("  NeL Net layer 5 transport");
 187                         if (!_Open)
 188                         {
 189                                 log.displayNL("  The transport is currently closed.");
 190                         }
 191                         else
 192                         {
 193                                 log.displayNL("  The transport is open and support %u routes :",
 194                                         _Routes.size());
 195                                 TRouteMap::const_iterator first(_Routes.begin()), last(_Routes.end());
 196                                 for (; first != last; ++first)
 197                                 {
 198                                         TServiceId      sid = first->first;
 199                                         CL5Route *route = first->second;
 200                                         log.displayNL("    + route to service %hu('%s'), %u entries in the proxy translation table :",
 201                                                 sid.get(),
 202                                                 CUnifiedNetwork::getInstance()->getServiceName(sid).c_str(),
 203                                                 route->ForeignToLocalIdx.getAToBMap().size());
 204
 205                                         {
 206                                                 CGatewayRoute::TForeignToLocalIdx::TAToBMap::const_iterator first(route->ForeignToLocalIdx.getAToBMap().begin()), last(route->ForeignToLocalIdx.getAToBMap().end());
 207                                                 for (; first != last; ++first)
 208                                                 {
 209                                                         IModuleProxy *modProx = mm.getModuleProxy(first->second);
 210
 211                                                         log.displayNL("      - Proxy '%s' : local proxy id %u => foreign module id %u",
 212                                                                 modProx != NULL ? modProx->getModuleName().c_str() : "ERROR, invalid module",
 213                                                                 first->second,
 214                                                                 first->first);
 215                                                 }
 216                                         }
 217                                 }
 218                         }
 219                 }
 220
 221                 void onCommand(const CMessage &/* command */)
 222                 {
 223                         // nothing done for now
 224                         throw EInvalidCommand();
 225                 }
 226                 /// The gateway send a textual command to the transport
 227                 bool onCommand(const TParsedCommandLine &command)
 228                 {
 229                         if (command.SubParams.size() < 1)
 230                                 throw  EInvalidCommand();
 231
 232                         const std::string &commandName = command.SubParams[0]->ParamName;
 233                         if (commandName == "open")
 234                         {
 235                                 string subNetName;
 236
 237                                 /// look for an optional sub network name
 238                                 const TParsedCommandLine *netName = command.SubParams[0]->getParam("SubNet");
 239                                 if (netName != NULL)
 240                                 {
 241                                         subNetName = netName->ParamValue;
 242                                 }
 243
 244                                 open(subNetName);
 245                         }
 246                         else if (commandName == "close")
 247                         {
 248                                 close();
 249                         }
 250                         else
 251                                 return false;
 252
 253                         return true;
 254                 }
 255
 256
 257                 /// Open the server by establishing route with all known services
 258                 void open(const std::string &subNetName)
 259                 {
 260                         H_AUTO(L5_open);
 261
 262                         static TUnifiedCallbackItem L5TransportCallback[] =
 263                         {
 264                                 {"GW_L5_MSG",   CGatewayL5Transport::cbDispatchL5Message        },
 265                                 {"GW_L5_ADDTP", CGatewayL5Transport::cbL5AddTransport           },
 266                                 {"GW_L5_REMTP", CGatewayL5Transport::cbL5RemoveTransport        },
 267                         };
 268
 269                         if (_Open == true)
 270                                 throw ETransportError("Transport already open");
 271
 272                         _SubNetName = subNetName;
 273
 274
 275                         CUnifiedNetwork *un = CUnifiedNetwork::getInstance();
 276
 277                         static bool callbackRegistered = false;
 278
 279                         if (!callbackRegistered)
 280                         {
 281                                 LNETL6_DEBUG("LNETL6: L5 transport open : registering callbacks");
 282                                 // set the service con/disconnect callback
 283                                 un->setServiceUpCallback("*", CGatewayL5Transport::cbOnServiceUp);
 284                                 un->setServiceDownCallback("*", CGatewayL5Transport::cbOnServiceDown);
 285                                 // set the message callback
 286                                 un->addCallbackArray(L5TransportCallback, sizeof(L5TransportCallback) / sizeof(TUnifiedCallbackItem));
 287
 288                                 callbackRegistered = true;
 289                         }
 290
 291
 292                         // create route and open route for each existing service
 293                         const vector<TServiceId>        &connList = un->getConnectionList();
 294
 295                         set<TServiceId> uniqueService(connList.begin(), connList.end());
 296
 297                         while (!uniqueService.empty())
 298                         {
 299                                 TServiceId sid = *(uniqueService.begin());
 300                                 uniqueService.erase(uniqueService.begin());
 301
 302                                 if ( un->isConnectionConnected(sid))
 303                                 {
 304                                         // send transport descriptor to other service
 305                                         onServiceUp(un->getServiceName(sid), sid);
 306                                 }
 307                                 else
 308                                 {
 309                                         // the Connection is not established right now. We wait for the ServiceUp callback
 310                                 }
 311
 312                         }
 313
 314                         _Open = true;
 315                 }
 316
 317                 /// Close the server, this will close all route
 318                 void close()
 319                 {
 320                         H_AUTO(L5_close);
 321
 322                         if (_Open == false)
 323                                 throw ETransportError("closeServer : The server is not open");
 324
 325                         // close all client connections
 326                         while (!_Routes.empty())
 327                         {
 328                                 CL5Route *route = _Routes.begin()->second;
 329                                 TServiceId sid = route->ServiceId;
 330                                 onServiceDown(CUnifiedNetwork::getInstance()->getServiceName(sid), sid);
 331                         }
 332
 333                         _Open = false;
 334                 }
 335
 336
 337                 /***************************************************/
 338                 /** Event management                              **/
 339                 /***************************************************/
 340
 341                 void onServiceUp(const std::string &serviceName, TServiceId sid)
 342                 {
 343                         H_AUTO(L5_onServiceUp);
 344
 345                         LNETL6_DEBUG("LNETL6: L5 transport onServiceUp('%s')", serviceName.c_str());
 346                         // send the transport descriptor to the new service
 347                         TTransportDesc  desc;
 348                         desc.SubNetName = _SubNetName;
 349                         desc.TransportId = _TransportId;
 350                         desc.InResponse = false;
 351
 352                         CMessage msg("GW_L5_ADDTP");
 353                         msg.serial(desc);
 354
 355                         CUnifiedNetwork::getInstance()->send(sid, msg);
 356
 357                         // the route will be created by receiving this message
 358                 }
 359
 360                 void onServiceDown(const std::string &/* serviceName */, TServiceId sid)
 361                 {
 362                         H_AUTO(L5_onServicedown);
 363
 364                         LNETL6_DEBUG("LNETL6: L5 transport onServiceDown('%hu')", sid.get());
 365                         // retrieve the route
 366                         TRouteMap::iterator it(_Routes.find(sid));
 367                         if (it == _Routes.end())
 368                         {
 369                                 nlinfo("Transport L5 : service down, can't find a route for the service");
 370                                 return;
 371                         }
 372                         CL5Route *route = it->second;
 373
 374                         // warn the gateway
 375                         _Gateway->onRouteRemoved(route);
 376
 377                         // release the route
 378                         _Routes.erase(it);
 379                         delete route;
 380                 }
 381
 382                 // Called to dispatch an incoming message to the gateway
 383                 void onDispatchMessage(const CMessage &msgin, TServiceId sid)
 384                 {
 385                         H_AUTO(L5_onDispatchMessage);
 386
 387                         LNETL6_DEBUG("LNETL6: L5 transport onDispatchMessage from service %hu", sid.get());
 388                         /// retrieve the route for dispatching
 389                         TRouteMap::iterator it(_Routes.find(sid));
 390                         if (it == _Routes.end())
 391                         {
 392                                 nlwarning("Gateway '%s' : Can't find route for service %hu for dispatching, message is discarded",
 393                                         _Gateway->getGatewayName().c_str(),
 394                                         sid.get());
 395                                 return;
 396                         }
 397
 398                         // read the message size
 399                         uint32 msgLen;
 400                         nlRead(msgin, serial, msgLen);
 401
 402                         // lock the sub message
 403                         msgin.lockSubMessage(msgLen);
 404
 405                         _Gateway->onReceiveMessage(it->second, msgin);
 406
 407                         // unlock the sub message
 408                         msgin.unlockSubMessage();
 409                 }
 410
 411                 void onAddTransport(TServiceId sid, TTransportDesc &desc)
 412                 {
 413                         H_AUTO(L5_onAddTransport);
 414
 415                         LNETL6_DEBUG("LNETL6: L5 transport onAddTransport from service %hu", sid.get());
 416                         // we need to create a route for this transport
 417                         // create a new route and send the route open message
 418
 419                         if (_Routes.find(sid) != _Routes.end())
 420                         {
 421                                 LNETL6_DEBUG("LNETL6: L5 transport onAddTransport a route for this service alredy exist");
 422                                 return;
 423                         }
 424
 425                         CL5Route *route = new CL5Route(this);
 426
 427                         route->ServiceId = sid;
 428                         route->ForeignTransportId = desc.TransportId;
 429
 430                         // store the route infos
 431                         _Routes.insert(make_pair(sid, route));
 432
 433                         // notify the gateway about the new route
 434                         _Gateway->onRouteAdded(route);
 435
 436                         if (desc.InResponse == false)
 437                         {
 438                                 // we need to send back this transport info to this service
 439                                 TTransportDesc desc;
 440                                 desc.InResponse = true;
 441                                 desc.SubNetName = _SubNetName;
 442                                 desc.TransportId = _TransportId;
 443
 444                                 CMessage msg("GW_L5_ADDTP");
 445                                 msg.serial(desc);
 446
 447                                 CUnifiedNetwork::getInstance()->send(sid, msg);
 448                         }
 449                 }
 450
 451                 void onRemoveTransport(TServiceId sid, TTransportDesc &desc)
 452                 {
 453                         H_AUTO(L5_onRemoveTransport);
 454
 455                         LNETL6_DEBUG("LNETL6: L5 transport onRemoveTransport from service %hu", sid.get());
 456                         // Remove the route
 457                         TRouteMap::iterator it(_Routes.find(sid));
 458                         if (it == _Routes.end())
 459                         {
 460                                 nlwarning("onRemoveTransport : can't find a route to the transport %hu on service %u",
 461                                         desc.TransportId,
 462                                         sid.get());
 463                                 return;
 464                         }
 465
 466                         CL5Route *route = it->second;
 467
 468                         // notify the gateway about the removed route
 469                         _Gateway->onRouteRemoved(route);
 470
 471                         // erase the route info and delete the route
 472                         _Routes.erase(it);
 473                         delete route;
 474                 }
 475
 476                 /***************************************************/
 477                 /** static callback forwarder                     **/
 478                 /***************************************************/
 479                 /// callback from layer 5
 480
 481                 static void cbL5AddTransport(CMessage &msgin, const std::string &/* serviceName */, TServiceId sid)
 482                 {
 483                         LNETL6_DEBUG("LNETL6: L5 transport cbL5AddTransport from service %hu", sid.get());
 484                         // Receive a transport descriptor from another service, create
 485                         // a route for it
 486
 487                         TTransportDesc  desc;
 488
 489                         msgin.serial(desc);
 490
 491                         // for each existing transport here, check if they are in the
 492                         // same sub net, if so, callback them for route creation
 493
 494                         TTransportDispatcher::iterator first(_TransportDispatcher.begin()), last(_TransportDispatcher.end());
 495                         for (; first != last; ++first)
 496                         {
 497                                 CGatewayL5Transport *transport = first->second;
 498                                 if (transport->_Open
 499                                         && transport->_SubNetName == desc.SubNetName
 500                                         && (sid != IService::getInstance()->getServiceId()
 501                                                 || desc.TransportId != transport->_TransportId))
 502                                 {
 503                                         // this one is on the same subnet
 504                                         transport->onAddTransport(sid, desc);
 505                                 }
 506                         }
 507                 }
 508
 509                 static void cbL5RemoveTransport(CMessage &msgin, const std::string &/* serviceName */, TServiceId sid)
 510                 {
 511                         LNETL6_DEBUG("LNETL6: L5 transport cbL5RemoveTransport from service %hu", sid.get());
 512                         // Receive a transport descriptor from another service, delete
 513                         // the route for it
 514
 515                         TTransportDesc  desc;
 516
 517                         msgin.serial(desc);
 518
 519                         // for each existing transport here, check if they are in the
 520                         // same sub net, if so, callback them for route creation
 521
 522                         TTransportDispatcher::iterator first(_TransportDispatcher.begin()), last(_TransportDispatcher.end());
 523                         for (; first != last; ++first)
 524                         {
 525                                 CGatewayL5Transport *transport = first->second;
 526                                 if (transport->_Open
 527                                         && transport->_SubNetName == desc.SubNetName
 528                                         && desc.TransportId != transport->_TransportId)
 529                                 {
 530                                         // this one is on the same subnet
 531                                         transport->onRemoveTransport(sid, desc);
 532                                 }
 533                         }
 534                 }
 535
 536                 static void cbDispatchL5Message (CMessage &msgin, const std::string &serviceName, TServiceId sid)
 537                 {
 538                         LNETL6_DEBUG("LNETL6: L5 transport cbDispatch called, receiving from %s", serviceName.c_str());
 539                         // dispatch the message to the route associated with the service
 540                         // the first info in the message is the transport id
 541                         TL5TransportId transportId;
 542                         msgin.serial(transportId);
 543
 544                         // look for a corresponding transport
 545                         TTransportDispatcher::iterator it(_TransportDispatcher.find(transportId));
 546                         if (it == _TransportDispatcher.end())
 547                         {
 548                                 nlwarning("ReceiveL5Message, can't find transport id %u for dispatching, message is discarded",
 549                                         transportId);
 550                                 return;
 551                         }
 552
 553                         CGatewayL5Transport *transport = it->second;
 554                         transport->onDispatchMessage(msgin, sid);
 555                 }
 556
 557                 static  void cbOnServiceUp (const std::string &serviceName, TServiceId sid, void * /* arg */)
 558                 {
 559                         LNETL6_DEBUG("LNETL6: L5 transport cbOnServiceUp called, service up for %s", serviceName.c_str());
 560                         // callback all open transport about the new service
 561                         TTransportDispatcher::iterator first(_TransportDispatcher.begin()), last(_TransportDispatcher.end());
 562                         for (; first != last; ++first)
 563                         {
 564                                 CGatewayL5Transport *transport = first->second;
 565
 566                                 if (transport->_Open)
 567                                         transport->onServiceUp(serviceName, sid);
 568                         }
 569                 }
 570
 571                 static  void cbOnServiceDown (const std::string &serviceName, TServiceId sid, void * /* arg */)
 572                 {
 573                         LNETL6_DEBUG("LNETL6: L5 transport cbOnServicedown called, service down for %s", serviceName.c_str());
 574                         // callback all open transport about the removed service
 575                         TTransportDispatcher::iterator first(_TransportDispatcher.begin()), last(_TransportDispatcher.end());
 576                         for (; first != last; ++first)
 577                         {
 578                                 CGatewayL5Transport *transport = first->second;
 579
 580                                 if (transport->_Open)
 581                                         transport->onServiceDown(serviceName, sid);
 582                         }
 583                 }
 584
 585         };
 586
 587         CGatewayL5Transport::TTransportDispatcher       CGatewayL5Transport::_TransportDispatcher;
 588
 589         // register this class in the transport factory
 590         NLMISC_REGISTER_OBJECT(IGatewayTransport, CGatewayL5Transport, std::string, string(LAYER5_CLASS_NAME));
 591
 592         void CL5Route::sendMessage(const CMessage &message) const
 593         {
 594                 NLNET_AUTO_DELTE_ASSERT;
 595                 H_AUTO(L5Route_sendMessage);
 596
 597                 CGatewayL5Transport *trpt = static_cast<CGatewayL5Transport*>(_Transport);
 598
 599                 // create a transport message
 600                 CMessage wrapper("GW_L5_MSG");
 601                 // serial the transport identifier
 602                 wrapper.serial(trpt->_TransportId);;
 603
 604                 // insert the message in the wrapper
 605                 nlWrite(wrapper, serialMessage, message);
 606                 // send the message
 607                 CUnifiedNetwork::getInstance()->send(ServiceId, wrapper);
 608         }
 609
 610
 611
 612         void forceGatewayL5TransportLink()
 613         {
 614         }
 615
 616 } // namespace NLNET