ryzom/client/src/gateway_fec_transport.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   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 "stdpch.h"
  18 #include "nel/net/module.h"
  19 #include "nel/net/module_manager.h"
  20 #include "nel/net/module_gateway.h"
  21 // client include
  22 #if !defined(RZ_CLIENT_DRONE)
  23 #  include "net_manager.h"
  24 #  include "network_connection.h"
  25 #else
  26 #  include "../client_drone/network_connection.h"
  27 #  include "../client_drone/simulated_client.h"
  28 #  include "../game_share/generic_xml_msg_mngr.h"
  29 #endif
  30
  31 using namespace std;
  32 using namespace NLMISC;
  33 using namespace NLNET;
  34
  35 extern CGenericXmlMsgHeaderManager GenericMsgHeaderMngr;
  36
  37 /** the specialized route for frontend client transport */
  38 class CFEClientRoute : public CGatewayRoute
  39 {
  40 public:
  41
  42         // the network connection to use to send data
  43         CNetworkConnection      *NetConn;
  44
  45
  46         CFEClientRoute(IGatewayTransport *transport, CNetworkConnection *netConn)
  47                 : CGatewayRoute(transport),
  48                 NetConn(netConn)
  49         {
  50                 // warn the server that the transport is open
  51                 CBitMemStream bms;
  52                 GenericMsgHeaderMngr.pushNameToStream( "MODULE_GATEWAY:FEOPEN", bms );
  53
  54                 sendRawMessage(bms);
  55         }
  56
  57         ~CFEClientRoute()
  58         {
  59                 // warn the server that the transport is closed
  60                 CBitMemStream bms;
  61                 GenericMsgHeaderMngr.pushNameToStream( "MODULE_GATEWAY:FECLOSE", bms );
  62
  63                 sendRawMessage(bms);
  64         }
  65
  66
  67         void sendMessage(const CMessage &message) const
  68         {
  69                 // wrap the message in a transport message
  70                 CBitMemStream wrapper;
  71                 GenericMsgHeaderMngr.pushNameToStream( "MODULE_GATEWAY:GATEWAY_MSG", wrapper );
  72 //              wrapper.serial(message.getName());
  73 //              wrapper.serialBufferWithSize(const_cast<uint8*>(message.buffer())+message.getHeaderSize(), message.length()-message.getHeaderSize());
  74                 wrapper.serialBufferWithSize(const_cast<uint8*>(message.buffer()), message.length());
  75
  76                 sendRawMessage(wrapper);
  77         }
  78
  79         // send a bit mem stream to the server
  80         void sendRawMessage(CBitMemStream &message) const
  81         {
  82                 NetConn->push(message);
  83         }
  84 };
  85
  86
  87
  88
  89 #define FE_CLIENT_CLASS_NAME "FEClient"
  90 /** Transport for module gateway through front end service, client part. */
  91 class CGatewayFEClientTransport : public IGatewayTransport
  92 {
  93         friend class CFEClientRoute;
  94 public:
  95         /// Invalid command
  96         class EInvalidCommand : public NLMISC::Exception
  97         {
  98         };
  99
 100         /// The established route if any
 101         CFEClientRoute  *_Route;
 102
 103         /// Status of the transport.
 104         bool                    _Open;
 105         /// A flag that is false after opening the transport until we receive one message
 106         bool                    _FirstMessageReceived;
 107
 108         enum TMessageType
 109         {
 110                 mt_route_open,
 111                 mt_route_close,
 112                 mt_gw_msg,
 113         };
 114         /// Storage for message pending because or bad ordering
 115         struct TWaitingMessage
 116         {
 117                 TMessageType    MessageType;
 118                 CBitMemStream   Message;
 119         };
 120
 121         typedef map<uint8, TWaitingMessage>     TWaitingMessages;
 122         /// The list of message waiting because or bad ordering
 123         TWaitingMessages        _WaitingMessages;
 124
 125         /// The message serial number that we are waiting to dispatch
 126         uint8                           _NextAwaitedMessage;
 127
 128 #if !defined(RZ_CLIENT_DRONE)
 129         // store the unique active transport (only one transport of this type can be activated at a time)
 130         static CGatewayFEClientTransport *&OpenTransport()
 131         {
 132                 static CGatewayFEClientTransport *openTransport = NULL;
 133
 134                 return openTransport;
 135         }
 136 #else
 137         CSimulatedClient        *SimClient;
 138 #endif
 139
 140         /// Constructor
 141         CGatewayFEClientTransport(const IGatewayTransport::TCtorParam &param)
 142                 : IGatewayTransport(param),
 143                 _Route(NULL),
 144                 _Open(false),
 145                 _FirstMessageReceived(false),
 146                 _NextAwaitedMessage(0)
 147         {
 148 #if defined(RZ_CLIENT_DRONE)
 149                 SimClient = CSimulatedClient::currentContext();
 150 #endif
 151         }
 152
 153         ~CGatewayFEClientTransport()
 154         {
 155 #if !defined(RZ_CLIENT_DRONE)
 156                 if (OpenTransport() == this)
 157                 {
 158                         // the transport is still open, close it before destruction
 159                         close();
 160                 }
 161 #else
 162                 // close anyway
 163                 close();
 164 #endif
 165         }
 166
 167         const std::string &getClassName() const
 168         {
 169                 static string className(FE_CLIENT_CLASS_NAME);
 170                 return className;
 171         }
 172
 173         virtual void update()
 174         {
 175         }
 176
 177         virtual uint32 getRouteCount() const
 178         {
 179                 return _Route != NULL ? 1 : 0;
 180         }
 181
 182         void dump(NLMISC::CLog &log) const
 183         {
 184                 IModuleManager &mm = IModuleManager::getInstance();
 185                 log.displayNL("  Frontend service transport, client part");
 186                 if (!_Open)
 187                 {
 188                         log.displayNL("  The connection is currently closed.");
 189                 }
 190                 else
 191                 {
 192                         log.displayNL("  The connection is open :");
 193
 194                         if (_Route == NULL)
 195                         {
 196                                 log.displayNL("    There is no route.");
 197                         }
 198                         else
 199                         {
 200                                 CFEClientRoute *route = _Route;
 201                                 log.displayNL("    The route has %u entries in the proxy translation table :",
 202                                         route->ForeignToLocalIdx.getAToBMap().size());
 203                                 {
 204                                         CGatewayRoute::TForeignToLocalIdx::TAToBMap::const_iterator first(route->ForeignToLocalIdx.getAToBMap().begin()), last(route->ForeignToLocalIdx.getAToBMap().end());
 205                                         for (; first != last; ++first)
 206                                         {
 207                                                 IModuleProxy *modProx = mm.getModuleProxy(first->second);
 208
 209                                                 log.displayNL("      - Proxy '%s' : local proxy id %u => foreign module id %u",
 210                                                         modProx != NULL ? modProx->getModuleName().c_str() : "ERROR, invalid module",
 211                                                         first->second,
 212                                                         first->first);
 213                                         }
 214                                 }
 215                         }
 216                 }
 217         }
 218
 219         void onCommand(const CMessage &/* command */)
 220         {
 221                 // nothing done for now
 222                 throw EInvalidCommand();
 223         }
 224         /// The gateway send a textual command to the transport
 225         bool onCommand(const TParsedCommandLine &command)
 226         {
 227                 if (command.SubParams.size() < 1)
 228                         throw  EInvalidCommand();
 229
 230                 const std::string &commandName = command.SubParams[0]->ParamName;
 231                 if (commandName == "open")
 232                 {
 233                         if (_Open)
 234                         {
 235                                 nlwarning("The transport is already open");
 236                                 return false;
 237                         }
 238 #if !defined(RZ_CLIENT_DRONE)
 239                         if (OpenTransport() != NULL)
 240                         {
 241                                 nlwarning("A transport is already open, only one transport can be open at a time");
 242                                 return false;
 243                         }
 244 #endif
 245
 246                         open();
 247                 }
 248                 else if (commandName == "close")
 249                 {
 250                         close();
 251                 }
 252                 else
 253                         return false;
 254
 255                 return true;
 256         }
 257
 258         /// Open the connection by intercepting client gateway message
 259         void open()
 260         {
 261                 if (_Open)
 262                 {
 263                         nlwarning("Transport already open");
 264                         return;
 265                 }
 266 #if !defined(RZ_CLIENT_DRONE)
 267                 if (OpenTransport() != NULL)
 268                         throw ETransportError("connect : a transport is already connected !");
 269
 270                 // set this transport as the open transport
 271                 OpenTransport() = this;
 272 #else
 273                 // associate this transport with the simulated client for later dispatching
 274                 SimClient->setGatewayTransport(this);
 275 #endif
 276
 277                 _Open = true;
 278                 _FirstMessageReceived = false;
 279                 // create a route
 280                 onConnection();
 281         }
 282
 283         /// Close the server, this will close the listing socket and any active connection
 284         void close()
 285         {
 286                 if (!_Open)
 287                 {
 288                         nlwarning("Transport not open");
 289                         return;
 290                 }
 291 #if !defined(RZ_CLIENT_DRONE)
 292                 if (OpenTransport() != this)
 293                         throw ETransportError("close : The connection is not open");
 294
 295 #else
 296                 // associate this transport with the simulated client for later dispatching
 297                 SimClient->setGatewayTransport(NULL);
 298 #endif
 299
 300                 if( _Route != NULL)
 301                         onDisconnection();
 302
 303                 _Open = false;
 304                 _FirstMessageReceived = false;
 305
 306 #if !defined(RZ_CLIENT_DRONE)
 307                 // this transport is no longer open
 308                 OpenTransport() = NULL;
 309 #endif
 310         }
 311
 312
 313         /***************************************************/
 314         /** Event management                              **/
 315         /***************************************************/
 316
 317         // handle the connection of the client
 318         void onConnection ( )
 319         {
 320                 if (_Route != NULL)
 321                 {
 322                         nlwarning("onConnection : route already created !");
 323                         return;
 324                 }
 325
 326                 CNetworkConnection *netConn;
 327 #if defined(RZ_CLIENT_DRONE)
 328                 netConn = &SimClient->getNetworkConnection();
 329 #else
 330                 netConn = &NetMngr;
 331 #endif
 332                 // Create a new route for this connection
 333                 _Route = new CFEClientRoute(this, netConn);
 334
 335                 // callback the gateway
 336                 _Gateway->onRouteAdded(_Route);
 337         }
 338
 339         // handle the deconnection of a new client on the client
 340         void onDisconnection ()
 341         {
 342                 if (_Route == NULL)
 343                 {
 344                         nlwarning("onDisconnection : route not created !");
 345                         return;
 346                 }
 347
 348                 // callback the gateway that this route is no more
 349                 _Gateway->onRouteRemoved(_Route);
 350
 351                 // delete the route
 352                 delete _Route;
 353                 _Route = NULL;
 354         }
 355
 356         // Called to dispatch an incoming message to the gateway
 357         void onDispatchMessage(NLMISC::CBitMemStream &bms)
 358         {
 359                 if (_Route == NULL)
 360                 {
 361                         nlwarning("onDispatchMessage : no route created, message will be discarded");
 362                         return;
 363                 }
 364
 365                 // now, we have received a message
 366                 _FirstMessageReceived = true;
 367
 368                 // Build a CMessage from the bit mem stream
 369 //              string msgName;
 370 //              bms.serial(msgName);
 371
 372                 // create an input stream for dispatching
 373                 CMessage msg("", true);
 374                 uint32 len;
 375                 bms.serial(len);
 376                 bms.serialBuffer(msg.bufferToFill(len), len);
 377                 msg.readType();
 378
 379                 // forward to gateway
 380                 _Gateway->onReceiveMessage(_Route, msg);
 381         }
 382
 383         // a message has been processed, try to process waiting message
 384         void processPendingMessage()
 385         {
 386                 if (_WaitingMessages.empty())
 387                         return;
 388
 389                 TWaitingMessages::iterator it(_WaitingMessages.find(_NextAwaitedMessage));
 390                 while (it != _WaitingMessages.end())
 391                 {
 392                         TWaitingMessage &wm = _WaitingMessages.find(_NextAwaitedMessage)->second;
 393
 394                         switch (wm.MessageType)
 395                         {
 396                         case mt_route_open:
 397                                 impulsionGatewayOpen(wm.Message, false);
 398                                 break;
 399                         case mt_route_close:
 400                                 impulsionGatewayClose(wm.Message, false);
 401                                 break;
 402                         case mt_gw_msg:
 403                                 impulsionGatewayMessage(wm.Message, false);
 404                                 break;
 405                         }
 406
 407                         // remove the processed message
 408                         _WaitingMessages.erase(it);
 409                         // advance to next message, _NextAwaitedMessage is incremented by impulsion handler
 410                         it = _WaitingMessages.find(_NextAwaitedMessage);
 411                 }
 412         }
 413
 414         // impulsion gateway open callback handler
 415         void impulsionGatewayOpen(NLMISC::CBitMemStream &bms, bool readSerialNumber)
 416         {
 417                 uint8 serialNumber;
 418                 if (readSerialNumber)
 419                         bms.serial(serialNumber);
 420                 else
 421                         serialNumber = _NextAwaitedMessage;
 422
 423                 if (serialNumber != _NextAwaitedMessage)
 424                 {
 425                         // store the message for later processing
 426                         nlassert(_WaitingMessages.find(serialNumber) == _WaitingMessages.end());
 427                         _WaitingMessages[serialNumber].Message.swap(bms);
 428 //                      _WaitingMessages[serialNumber].Message = bms;
 429                         _WaitingMessages[serialNumber].MessageType = mt_route_open;
 430
 431                         return;
 432                 }
 433
 434                 // advance to next message for next reception
 435                 ++_NextAwaitedMessage;
 436
 437                 if (_Route != NULL && _FirstMessageReceived)
 438                 {
 439                         // there is already a route here, and it have received some message,
 440                         // we need to delete it
 441                         onDisconnection();
 442                 }
 443
 444                 if (_Route == NULL)
 445                         // if there is no route, create one
 446                         onConnection();
 447
 448                 // try to process some messages
 449                 if (readSerialNumber)
 450                         processPendingMessage();
 451         }
 452
 453         // impulsion gateway message callback handler
 454         void impulsionGatewayMessage(NLMISC::CBitMemStream &bms, bool readSerialNumber)
 455         {
 456                 uint8 serialNumber;
 457                 if (readSerialNumber)
 458                         bms.serial(serialNumber);
 459                 else
 460                         serialNumber = _NextAwaitedMessage;
 461
 462                 if (serialNumber != _NextAwaitedMessage)
 463                 {
 464                         // store the message for later processing
 465                         nlassert(_WaitingMessages.find(serialNumber) == _WaitingMessages.end());
 466                         _WaitingMessages[serialNumber].Message.swap(bms);
 467 //                      _WaitingMessages[serialNumber].Message = bms;
 468                         _WaitingMessages[serialNumber].MessageType = mt_gw_msg;
 469
 470                         return;
 471                 }
 472
 473                 // advance to next message for next reception
 474                 ++_NextAwaitedMessage;
 475
 476                 onDispatchMessage(bms);
 477
 478                 if (readSerialNumber)
 479                         processPendingMessage();
 480         }
 481
 482
 483         // impulsion gateway open callback handler
 484         void impulsionGatewayClose(NLMISC::CBitMemStream &bms, bool readSerialNumber)
 485         {
 486                 uint8 serialNumber;
 487                 if (readSerialNumber)
 488                         bms.serial(serialNumber);
 489                 else
 490                         serialNumber = _NextAwaitedMessage;
 491
 492                 if (serialNumber != _NextAwaitedMessage)
 493                 {
 494                         // store the message for later processing
 495                         nlassert(_WaitingMessages.find(serialNumber) == _WaitingMessages.end());
 496                         _WaitingMessages[serialNumber].Message.swap(bms);
 497 //                      _WaitingMessages[serialNumber].Message = bms;
 498                         _WaitingMessages[serialNumber].MessageType = mt_route_close;
 499
 500                         return;
 501                 }
 502
 503                 // advance to next message for next reception
 504                 ++_NextAwaitedMessage;
 505
 506                 if (_Route == NULL)
 507                 {
 508                         // there is no route open
 509                         return;
 510                 }
 511
 512                 onDisconnection();
 513
 514                 if (readSerialNumber)
 515                         processPendingMessage();
 516         }
 517
 518
 519         /***************************************************/
 520
 521         static CGatewayFEClientTransport *getCurrentTransport()
 522         {
 523 #if defined(RZ_CLIENT_DRONE)
 524                 // the current transport is set to the current context of the client drone
 525                 if (CSimulatedClient::currentContext() == NULL)
 526                         return NULL;
 527                 if (CSimulatedClient::currentContext()->getGatewayTransport() == NULL)
 528                         return NULL;
 529
 530                 return static_cast<CGatewayFEClientTransport*>(CSimulatedClient::currentContext()->getGatewayTransport());
 531 #else
 532                 // normal client mode, there is only one transport
 533                 return OpenTransport();
 534 #endif
 535
 536         }
 537 };
 538
 539
 540
 541 void cbImpulsionGatewayOpen(NLMISC::CBitMemStream &bms)
 542 {
 543         if (CGatewayFEClientTransport::getCurrentTransport() != NULL)
 544                 CGatewayFEClientTransport::getCurrentTransport()->impulsionGatewayOpen(bms, true);
 545 }
 546
 547
 548 // impulsion gateway message callback handler
 549 void cbImpulsionGatewayMessage(NLMISC::CBitMemStream &bms)
 550 {
 551         if (CGatewayFEClientTransport::getCurrentTransport() != NULL)
 552                 CGatewayFEClientTransport::getCurrentTransport()->impulsionGatewayMessage(bms, true);
 553 }
 554
 555 // impulsion gateway close callback handler
 556 void cbImpulsionGatewayClose(NLMISC::CBitMemStream &bms)
 557 {
 558         if (CGatewayFEClientTransport::getCurrentTransport() != NULL)
 559                 CGatewayFEClientTransport::getCurrentTransport()->impulsionGatewayClose(bms, true);
 560 }
 561
 562
 563
 564 // register this class in the transport factory
 565 NLMISC_REGISTER_OBJECT(IGatewayTransport, CGatewayFEClientTransport, std::string, string(FE_CLIENT_CLASS_NAME));
 566