ryzom/client/src/session_browser.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2019  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 "stdpch.h"
  21 #include "game_share/utils.h"
  22 #include "session_browser.h"
  23
  24 #include "game_share/r2_share_itf.h"
  25
  26 #ifdef DEBUG_NEW
  27 #define new DEBUG_NEW
  28 #endif
  29
  30 using namespace std;
  31 using namespace NLMISC;
  32 using namespace NLNET;
  33 using namespace RSMGR;
  34
  35 /// The time the client stay connected to the session browser without requests
  36 const uint32 KeepConnectedTime = 3;
  37
  38 // a callback adaptor that queue the sent message for later sending.
  39 class CCallbackClientAdaptor : public CNelCallbackClientAdaptor
  40 {
  41         friend class CSessionBrowser;
  42
  43         // a queue of message to be sent by the comm thread
  44         std::queue<CMessage>    _SendQueue;
  45
  46         // The mutex used by the session browser thread
  47         NLMISC::CUnfairMutex    _Mutex;
  48
  49         // A flag to let some message passthrue without enqueuing (for authenticate)
  50         bool                                    _PassThrue;
  51
  52         CCallbackClientAdaptor(void *containerClass)
  53                 :       CNelCallbackClientAdaptor(containerClass),
  54                         _PassThrue(false)
  55         {
  56                 _CallbackClient.setPreDispatchCallback(&CCallbackClientAdaptor::cb_preDispatchMessage);
  57         }
  58
  59         CCallbackClient &getCallback()
  60         {
  61                 return _CallbackClient;
  62         }
  63
  64         virtual void connect( const NLNET::CInetAddress& /* addr */ )
  65         {
  66                 // do not connect now
  67         }
  68
  69
  70         virtual void send(const NLNET::CMessage &buffer, NLNET::TSockId hostid = NLNET::InvalidSockId, bool log = true)
  71         {
  72                 CAutoMutex<CUnfairMutex> mutex(_Mutex);
  73
  74                 if (!_PassThrue)
  75                 {
  76                         // queue the message for later sending.
  77                         nldebug("SB: Pushing a buffer into SendQueue (from %u elts)", _SendQueue.size());
  78                         _SendQueue.push(buffer);
  79                 }
  80                 else
  81                 {
  82                         // protect socket because update() can be called in the main thread while send() can be called with passthru=true in the session browser thread (by authenticate() for example)
  83                         _CallbackClient.send(buffer, hostid, log);
  84                 }
  85         }
  86
  87         // called by the callback client before each message dispatching
  88         static void cb_preDispatchMessage(CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
  89         {
  90                 CNelCallbackClientAdaptor *adaptor = static_cast<CNelCallbackClientAdaptor*>(netbase.getUserData());
  91                 if (adaptor != NULL)
  92                 {
  93                         CSessionBrowser *sb = static_cast<CSessionBrowser*>(adaptor->getContainerClass());
  94
  95                         sb->on_preDispatchMessage(msgin, from, netbase);
  96                 }
  97         }
  98
  99
 100 };
 101
 102
 103
 104 ///////////////////////////////////////////////////////////////////////////
 105 ///////////////////////////////////////////////////////////////////////////
 106
 107 CSessionBrowser::CSessionBrowser()
 108         :       CSessionBrowserServerWebClientItf(new CCallbackClientAdaptor(this)),
 109                 _TerminateComm(false),
 110                 _SignalConnFail(false),
 111                 _NBReceivedMessage(0),
 112                 _WaitingForMessage(false)
 113 {
 114         // start the comm thread
 115         _CommThread = IThread::create(this);
 116         _CommThread->start();
 117 }
 118
 119 CSessionBrowser::~CSessionBrowser()
 120 {
 121         // signal the comm thread to terminate
 122         _TerminateComm = true;
 123         // wait the termination of the thread
 124         _CommThread->wait();
 125
 126         // ok, we can leave
 127         delete _CommThread;
 128 }
 129
 130 /** Set auth info */
 131 void CSessionBrowser::setAuthInfo(const NLNET::CLoginCookie &cookie)
 132 {
 133         _LoginCookie = cookie;
 134 }
 135
 136 CCallbackClientAdaptor *CSessionBrowser::getCallbackAdaptor()
 137 {
 138         return static_cast<CCallbackClientAdaptor *>(_CallbackClient.get());
 139 }
 140
 141 void CSessionBrowser::connectItf(NLNET::CInetAddress address)
 142 {
 143         // call the interface connectItf
 144         CSessionBrowserServerWebClientItf::connectItf(address);
 145         _ServerAddr = address;
 146 }
 147
 148 void CSessionBrowser::clearSendQueue()
 149 {
 150         CCallbackClientAdaptor  *adaptor = getCallbackAdaptor();
 151         nldebug("SB: Clearing SendQueue");
 152         CAutoMutex<CUnfairMutex> mutex(adaptor->_Mutex);
 153         while (!adaptor->_SendQueue.empty())
 154                 adaptor->_SendQueue.pop();
 155 }
 156
 157 // the comm thread entry point
 158 void CSessionBrowser::run()
 159 {
 160         CCallbackClientAdaptor  *adaptor = getCallbackAdaptor();
 161         while(!_TerminateComm)
 162         {
 163                 // no server address available
 164                 while (!_ServerAddr.isValid())
 165                 {
 166                         // wait a little
 167                         nlSleep(100);
 168
 169                         if (_TerminateComm)
 170                                 break;
 171                 }
 172
 173 disconnected:
 174                 // disconnected, waiting for message to send
 175                 while (adaptor->_SendQueue.empty())
 176                 {
 177                         nlSleep(100);
 178
 179                         if (_TerminateComm)
 180                                 break;
 181                 }
 182
 183 retry_connection:
 184                 while (!adaptor->getCallback().connected())
 185                 {
 186                         // connecting...
 187                         try
 188                         {
 189                                 nldebug("SB: Connecting...");
 190                                 adaptor->getCallback().connect(_ServerAddr);
 191                         }
 192                         catch(...)
 193                         {
 194                                 // connection failed !
 195                                 // erase all queued messages
 196                                 clearSendQueue();
 197                                 // put an event in for the main loop
 198                                 _SignalConnFail = true;
 199                         }
 200                         if (_TerminateComm)
 201                                 break;
 202
 203                 }
 204
 205                 {
 206                         CAutoMutex<CUnfairMutex> mutex(adaptor->_Mutex);
 207                         // authenticate the client
 208                          adaptor->_PassThrue = true;
 209                         nldebug("SB: Authenticating");
 210                         // nico patch
 211                         {
 212                                 if (!connected()) // oddly sometimes it gets disconnected here
 213                                 {
 214                                         goto retry_connection;
 215                                 }
 216                         }
 217                         authenticate(_LoginCookie.getUserId(), _LoginCookie);
 218                         adaptor->_PassThrue = false;
 219                 }
 220 sendMessages:
 221                 // connected, sending messages
 222                 while (!adaptor->_SendQueue.empty())
 223                 {
 224                         bool popped = false;
 225                         {
 226                                 CAutoMutex<CUnfairMutex> mutex(adaptor->_Mutex);
 227                                 if (!adaptor->getCallback().connected())
 228                                 {
 229                                         nldebug("SB: Disconnecting when authenticating");
 230                                         clearSendQueue(); // TODO: REMOVE?
 231                                         goto disconnected;
 232                                 }
 233
 234                                 nldebug("SB: Sending next buffer of SendQueue");
 235                                 adaptor->getCallback().send(adaptor->_SendQueue.front());
 236                                 //if (adaptor->getCallback().connected()) // don't loose msg if it has not been sent (TODO: ADD?)
 237                                 {
 238                                         adaptor->_SendQueue.pop();
 239                                         popped = true;
 240                                 }
 241                         }
 242                         if (popped)
 243                                 nldebug("SB: Popping from SendQueue (now %u elts)", adaptor->_SendQueue.size());
 244                         else
 245                                 nldebug("SB: Disconnected when sending");
 246
 247                         if (_TerminateComm)
 248                                 break;
 249                 }
 250
 251                 // idle, waiting new message to send/receive or time out to disconnect
 252                 time_t startWait = CTime::getSecondsSince1970();
 253                 while (_WaitingForMessage || (adaptor->_SendQueue.empty() && CTime::getSecondsSince1970() - startWait < KeepConnectedTime))
 254                 {
 255                         nlSleep(100);
 256
 257                         if (_TerminateComm)
 258                                 break;
 259
 260                         {
 261                                 CAutoMutex<CUnfairMutex> mutex(adaptor->_Mutex);
 262                                 if (!adaptor->_SendQueue.empty())
 263                                         goto sendMessages;
 264
 265                                 if (!adaptor->getCallback().connected())
 266                                         goto disconnected;
 267                         }
 268                 }
 269
 270                 {
 271                         nldebug("SB: Disconnecting");
 272                         CAutoMutex<CUnfairMutex> mutex(adaptor->_Mutex);
 273 //                      if (!adaptor->_SendQueue.empty())
 274                                 // timeout, disconnect
 275                                 adaptor->getCallback().disconnect();
 276                 }
 277
 278                 if (_TerminateComm)
 279                         break;
 280
 281                 goto disconnected;
 282         }
 283 }
 284
 285 void CSessionBrowser::on_preDispatchMessage(CMessage &msgin, TSockId /* from */, CCallbackNetBase &/* netbase */)
 286 {
 287         ++_NBReceivedMessage;
 288         _LastReceivedMessageNames.push_back(msgin.getName());
 289 }
 290
 291
 292 void CSessionBrowser::update()
 293 {
 294         // check flag to callback a connection failure event
 295         if (_SignalConnFail)
 296         {
 297                 on_connectionFailed();
 298                 _SignalConnFail = false;
 299         }
 300
 301         //nldebug("SB: Updating module");
 302         CAutoMutex<CUnfairMutex> mutex(getCallbackAdaptor()->_Mutex);
 303         // call the underlying interface update
 304         CSessionBrowserServerWebClientItf::update();
 305 }
 306
 307 bool CSessionBrowser::waitOneMessage(const std::string &msgName)
 308 {
 309         nldebug("SB: Waiting for message");
 310         _WaitingForMessage = true;
 311         // cleanup the list of received messages
 312         _LastReceivedMessageNames.clear();
 313
 314         CCallbackClientAdaptor  *adaptor = getCallbackAdaptor();
 315
 316
 317         // loop while no message received, still connected or having message to send
 318         while (_LastReceivedMessageNames.empty()
 319                 && (adaptor->getCallback().connected() || !adaptor->_SendQueue.empty()))
 320         {
 321                 update();
 322
 323                 // give up the time slice
 324                 nlSleep(0);
 325
 326         }
 327
 328         _WaitingForMessage = false;
 329
 330         if (!_LastReceivedMessageNames.empty())
 331         {
 332                 // check the first received message match the requested one
 333                 bool receivedExpected =
 334                                 (_LastReceivedMessageNames.front() == msgName) ||
 335                                 (_LastReceivedMessageNames.front() == "JSSRE" && (msgName == "JSSR")); // harcoded: JSSRE may replace JSSR in some responses
 336                 STOP_IF(!receivedExpected, "BIG BAD BUG - Expected SBS message '"+msgName+"' but received '"+_LastReceivedMessageNames.front()+"'");
 337                 return receivedExpected;
 338         }
 339
 340         // sorry, wait failed
 341         return false;
 342 }
 343
 344 bool CSessionBrowser::connected()
 345 {
 346         return getCallbackAdaptor()->connected();
 347 }
 348
 349 void CSessionBrowser::send(const NLNET::CMessage& msg)
 350 {
 351         getCallbackAdaptor()->send(msg);
 352 }