Changeset 9406 in orxonox.OLD for trunk/src/lib/network/network_stream.cc

Timestamp:

Jul 24, 2006, 11:09:47 AM (18 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the proxy back

merged with commandsvn merge -r9346:HEAD ​https://svn.orxonox.net/orxonox/branches/proxy .

no conflicts

File:

• trunk/src/lib/network/network_stream.cc (modified) (35 diffs)

trunk/src/lib/network/network_stream.cc

@@ -12 +12 @@
    main-programmer: Christoph Renner rennerc@ee.ethz.ch
    co-programmer:   Patrick Boenzli  boenzlip@orxonox.ethz.ch
+
+     June 2006: finishing work on the network stream for pps presentation (rennerc@ee.ethz.ch)
+     July 2006: some code rearangement and integration of the proxy server mechanism (boenzlip@ee.ethz.ch)
 */
 
@@ -22 +25 @@
 #include "udp_socket.h"
 #include "udp_server_socket.h"
-#include "connection_monitor.h"
+#include "monitor/connection_monitor.h"
+#include "monitor/network_monitor.h"
 #include "synchronizeable.h"
+#include "ip.h"
 #include "network_game_manager.h"
 #include "shared_network_data.h"
@@ -42 +47 @@
 #include <algorithm>
 
-/* include your own header */
+
 #include "network_stream.h"
 
-/* probably unnecessary */
-using namespace std;
+
+#include "converter.h"
 
 
@@ -52 +57 @@
 
 
+/**
+ * empty constructor
+ */
 NetworkStream::NetworkStream()
     : DataStream()
@@ -57 +65 @@
   this->init();
   /* initialize the references */
-  this->type = NET_CLIENT;
-}
-
-
-/**
- * connect to a server as a client
- *  @param host: host name (address)
- *  @param port: port number
- */
-NetworkStream::NetworkStream( std::string host, int port )
-{
-  this->type = NET_CLIENT;
+  this->pInfo->nodeType = NET_CLIENT;
+}
+
+
+NetworkStream::NetworkStream( int nodeType)
+{
   this->init();
-  this->peers[0].socket = new UdpSocket( host, port );
-  this->peers[0].userId = 0;
-  this->peers[0].isServer = true;
-  this->peers[0].connectionMonitor = new ConnectionMonitor( 0 );
-}
-
-
-/**
- * start as a server
- *  @param port: at this port
- */
-NetworkStream::NetworkStream( int port )
-{
-  this->type = NET_SERVER;
-  this->init();
-  this->serverSocket = new UdpServerSocket(port);
-  this->bActive = true;
-}
+
+  this->pInfo->nodeType = nodeType;
+
+  switch( nodeType)
+  {
+    case NET_MASTER_SERVER:
+      // init the shared network data
+      SharedNetworkData::getInstance()->setHostID(0);
+//       SharedNetworkData::getInstance()->setNodeType(NET_MASTER_SERVER);
+      break;
+
+    case NET_PROXY_SERVER_ACTIVE:
+      // init the shared network data
+      SharedNetworkData::getInstance()->setHostID(0);
+//       SharedNetworkData::getInstance()->setNodeType(NET_PROXY_SERVER_ACTIVE);
+      break;
+    case NET_PROXY_SERVER_PASSIVE:
+            // init the shared network data
+      SharedNetworkData::getInstance()->setHostID(0);
+//       SharedNetworkData::getInstance()->setNodeType(NET_PROXY_SERVER_PASSIVE);
+      break;
+    case NET_CLIENT:
+//       SharedNetworkData::getInstance()->setNodeType(NET_CLIENT);
+      break;
+  }
+
+  SharedNetworkData::getInstance()->setDefaultSyncStream(this);
+
+  // get the local ip address
+  IPaddress ip;
+  SDLNet_ResolveHost( &ip, NULL, 0);
+  this->pInfo->ip = ip;
+}
+
 
 
@@ -97 +115 @@
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_STREAM, "NetworkStream");
-  this->bActive = false;
   this->serverSocket = NULL;
   this->networkGameManager = NULL;
-  myHostId = 0;
-  currentState = 0;
+  this->networkMonitor = NULL;
+
+  this->pInfo = new PeerInfo();
+  this->pInfo->userId = 0;
+  this->pInfo->lastAckedState = 0;
+  this->pInfo->lastRecvedState = 0;
+
+
+  this->currentState = 0;
 
   remainingBytesToWriteToDict = Preferences::getInstance()->getInt( "compression", "writedict", 0 );
@@ -147 +171 @@
   for ( SynchronizeableList::const_iterator it = getSyncBegin(); it != getSyncEnd(); it ++ )
     (*it)->setNetworkStream( NULL );
+
+  if( this->pInfo)
+    delete this->pInfo;
+
+  if( this->networkMonitor)
+    delete this->networkMonitor;
+}
+
+
+/**
+ * establish a connection to a remote master server
+ * @param host: host name
+ * @param port: the port number
+ */
+void NetworkStream::connectToMasterServer(std::string host, int port)
+{
+  int node = this->peers.size();
+  this->peers[node].socket = new UdpSocket( host, port );
+  this->peers[node].userId = 0;
+
+  this->peers[node].nodeType = NET_MASTER_SERVER;
+  this->peers[node].connectionMonitor = new ConnectionMonitor( 0 );
+  this->peers[node].ip = this->peers[node].socket->getRemoteAddress();
+}
+
+
+/**
+ * establish a connection to a remote proxy server
+ * @param host: host name
+ * @param port: the port number
+ */
+void NetworkStream::connectToProxyServer(std::string host, int port)
+{
+  int node = this->peers.size();
+  this->peers[node].socket = new UdpSocket( host, port );
+  this->peers[node].userId = 0;
+
+  this->peers[node].nodeType = NET_PROXY_SERVER_ACTIVE;
+  this->peers[node].connectionMonitor = new ConnectionMonitor( 0 );
+  this->peers[node].ip = this->peers[node].socket->getRemoteAddress();
+}
+
+
+/**
+ * create a server
+ * @param port: interface port for all clients
+ */
+void NetworkStream::createServer(int port)
+{
+  this->serverSocket = new UdpServerSocket(port);
 }
 
@@ -156 +230 @@
 {
   this->networkGameManager = NetworkGameManager::getInstance();
-  // setUniqueID( maxCon+2 ) because we need one id for every handshake
-  // and one for handshake to reject client maxCon+1
+
   this->networkGameManager->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
   MessageManager::getInstance()->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
@@ -165 +238 @@
 /**
  * starts the network handshake
+ * handsakes are always initialized from the client side first. this starts the handshake and therefore is only
+ * executed as client
  */
 void NetworkStream::startHandshake()
 {
-  Handshake* hs = new Handshake(false);
+  Handshake* hs = new Handshake(this->pInfo->nodeType);
   hs->setUniqueID( 0 );
   assert( peers[0].handshake == NULL );
   peers[0].handshake = hs;
 
+  // set the preferred nick name
   hs->setPreferedNickName( Preferences::getInstance()->getString( "multiplayer", "nickname", "Player" ) );
 
-//   peers[0].handshake->setSynchronized( true );
-  //this->connectSynchronizeable(*hs);
-  //this->connectSynchronizeable(*hs);
-  PRINTF(0)("NetworkStream: Handshake created: %s\n", hs->getName());
+  PRINTF(0)("NetworkStream: Handshake created: %s\n", hs->getCName());
 }
 
@@ -192 +265 @@
   sync.setNetworkStream( this );
 
-  this->bActive = true;
+//   this->bActive = true;
 }
 
@@ -215 +288 @@
 void NetworkStream::processData()
 {
+  // create the network monitor after all the init work and before there is any connection handlings
+  if( this->networkMonitor == NULL)
+    this->networkMonitor = new NetworkMonitor(this);
+
+
   int tick = SDL_GetTicks();
 
-  currentState++;
-
-  if ( this->type == NET_SERVER )
-  {
+  this->currentState++;
+  // there was a wrap around
+  if( this->currentState < 0)
+  {
+    PRINTF(1)("A wrap around in the state variable as occured. The server was running so long? Pls restart server or write a mail to the supporters!\n");
+  }
+
+  if ( this->pInfo->isMasterServer())
+  {
+    // execute everytthing the master server shoudl do
+    if ( serverSocket )
+      serverSocket->update();
+
+    this->updateConnectionList();
+  }
+  else if( this->pInfo->isProxyServer())
+  {
+    // execute everything the proxy server should do
     if ( serverSocket )
       serverSocket->update();
@@ -249 +341 @@
   cleanUpOldSyncList();
   handleHandshakes();
+
+  // update the network monitor
+  this->networkMonitor->process();
 
   // order of up/downstream is important!!!!
@@ -258 +353 @@
 
 /**
- * if we are a server update the connection list to accept new connections (clients)
- * also start the handsake for the new clients
+ * if we are a NET_MASTER_SERVER or NET_PROXY_SERVER_ACTIVE update the connection list to accept new
+ * connections (clients) also start the handsake for the new clients
  */
 void NetworkStream::updateConnectionList( )
@@ -276 +371 @@
       clientId = freeSocketSlots.back();
       freeSocketSlots.pop_back();
-      peers[clientId].socket = tempNetworkSocket;
-      peers[clientId].handshake = new Handshake(true, clientId, this->networkGameManager->getUniqueID(), MessageManager::getInstance()->getUniqueID() );
-      peers[clientId].connectionMonitor = new ConnectionMonitor( clientId );
-      peers[clientId].handshake->setUniqueID(clientId);
-      peers[clientId].userId = clientId;
-      peers[clientId].isServer = false;
     }
     else
@@ -290 +379 @@
         if ( it->first >= clientId )
           clientId = it->first + 1;
-
-      peers[clientId].socket = tempNetworkSocket;
-      peers[clientId].handshake = new Handshake(true, clientId, this->networkGameManager->getUniqueID(), MessageManager::getInstance()->getUniqueID());
-      peers[clientId].handshake->setUniqueID(clientId);
-      peers[clientId].connectionMonitor = new ConnectionMonitor( clientId );
-      peers[clientId].userId = clientId;
-      peers[clientId].isServer = false;
-
-      PRINTF(0)("num sync: %d\n", synchronizeables.size());
-    }
-
-    // check if there are too many clients connected
-    if ( clientId > MAX_CONNECTIONS )
-    {
-      peers[clientId].handshake->doReject( "too many connections" );
-      PRINTF(0)("Will reject client %d because there are to many connections!\n", clientId);
-    }
-    else
-    {
-      PRINTF(0)("New Client: %d\n", clientId);
-    }
-
-    //this->connectSynchronizeable(*handshakes[clientId]);
+    }
+    peers[clientId].socket = tempNetworkSocket;
+
+
+    // create new handshake and init its variables
+    peers[clientId].handshake = new Handshake(this->pInfo->nodeType, clientId, this->networkGameManager->getUniqueID(), MessageManager::getInstance()->getUniqueID());
+    peers[clientId].handshake->setUniqueID(clientId);
+
+    peers[clientId].connectionMonitor = new ConnectionMonitor( clientId );
+    peers[clientId].userId = clientId;
+
+    PRINTF(0)("num sync: %d\n", synchronizeables.size());
+
+    // get the proxy server informations and write them to the handshake, if any (proxy)
+    assert( this->networkMonitor != NULL);
+    PeerInfo* pi = this->networkMonitor->getFirstChoiceProxy();
+    if( pi != NULL)
+    {
+      peers[clientId].handshake->setProxy1Address( pi->ip);
+    }
+    pi = this->networkMonitor->getSecondChoiceProxy();
+    if( pi != NULL)
+      peers[clientId].handshake->setProxy2Address( pi->ip);
+
+    // check if the connecting client should reconnect to a proxy server
+    peers[clientId].handshake->setRedirect(/*this->networkMonitor->isReconnectNextClient()*/false);
+
+    // the connecting node of course is a client
+    peers[clientId].nodeType = NET_CLIENT;
+    peers[clientId].ip = peers[clientId].socket->getRemoteAddress();
+
+
+    // check if there are too many clients connected (DEPRECATED: new: the masterserver sends a list of proxy servers)
+//     if ( clientId > SharedNetworkData::getInstance()->getMaxPlayer() )
+//     {
+// //       peers[clientId].handshake->setRedirect(true);
+// //
+// //       peers[clientId].handshake->doReject( "too many connections" );
+//       PRINTF(0)("Will reject client %d because there are to many connections!\n", clientId);
+//     }
+//     else
+//     {
+//       PRINTF(0)("New Client: %d\n", clientId);
+//     }
+    PRINTF(0)("New Client: %d\n", clientId);
+
+
   }
 
@@ -339 +452 @@
       it->second.socket = NULL;
 
+      // remove the old connectin monitor
       if ( it->second.connectionMonitor )
         delete it->second.connectionMonitor;
       it->second.connectionMonitor = NULL;
 
+      // remove the handshake
       if ( it->second.handshake )
         delete it->second.handshake;
       it->second.handshake = NULL;
 
+      // and cleanup the user infos
       for ( SynchronizeableList::iterator it2 = synchronizeables.begin(); it2 != synchronizeables.end(); it2++ )
       {
@@ -373 +489 @@
 void NetworkStream::debug()
 {
-  if( this->isServer())
-    PRINT(0)(" Host ist Server with ID: %i\n", this->myHostId);
-  else
-    PRINT(0)(" Host ist Client with ID: %i\n", this->myHostId);
+  if( SharedNetworkData::getInstance()->isMasterServer()) {
+    PRINT(0)(" Host ist Master Server with ID: %i\n", this->pInfo->userId);
+  }
+  else if( SharedNetworkData::getInstance()->isProxyServer()) {
+    PRINT(0)(" Host ist Proxy Server with ID: %i\n", this->pInfo->userId);
+  }
+  else {
+    PRINT(0)(" Host ist Client with ID: %i\n", this->pInfo->userId);
+  }
 
   PRINT(0)(" Got %i connected Synchronizeables, showing active Syncs:\n", this->synchronizeables.size());
@@ -382 +503 @@
   {
     if( (*it)->beSynchronized() == true)
-      PRINT(0)("  Synchronizeable of class: %s::%s, with unique ID: %i, Synchronize: %i\n", (*it)->getClassName(), (*it)->getName(),
+      PRINT(0)("  Synchronizeable of class: %s::%s, with unique ID: %i, Synchronize: %i\n", (*it)->getClassCName(), (*it)->getCName(),
                (*it)->getUniqueID(), (*it)->beSynchronized());
   }
-  PRINT(0)(" Maximal Connections: %i\n", MAX_CONNECTIONS );
+  PRINT(0)(" Maximal Connections: %i\n", SharedNetworkData::getInstance()->getMaxPlayer() );
 
 }
@@ -414 +535 @@
     if ( it->second.handshake )
     {
+      // handshake finished
       if ( it->second.handshake->completed() )
       {
+        //handshake is correct
         if ( it->second.handshake->ok() )
         {
+          // the server gave it free for deletion
           if ( !it->second.handshake->allowDel() )
           {
-            if ( type != NET_SERVER )
+
+            if ( this->pInfo->isClient() )
             {
               SharedNetworkData::getInstance()->setHostID( it->second.handshake->getHostId() );
-              myHostId = SharedNetworkData::getInstance()->getHostID();
-
+              this->pInfo->userId = SharedNetworkData::getInstance()->getHostID();
+
+              it->second.nodeType = it->second.handshake->getRemoteNodeType();
+              it->second.ip = it->second.socket->getRemoteAddress();
+              // add the new server to the nodes list (it can be a NET_MASTER_SERVER or NET_PROXY_SERVER)
+              this->networkMonitor->addNode(&it->second);
+              // get proxy 1 address and add it
+              this->networkMonitor->addNode(it->second.handshake->getProxy1Address(), NET_PROXY_SERVER_ACTIVE);
+              // get proxy 2 address and add it
+              this->networkMonitor->addNode(it->second.handshake->getProxy2Address(), NET_PROXY_SERVER_ACTIVE);
+
+              // now check if the server accepted the connection
+              if( it->second.handshake->redirect())
+                this->handleReconnect( it->second.userId);
+
+              // create the new network game manager and init it
               this->networkGameManager = NetworkGameManager::getInstance();
               this->networkGameManager->setUniqueID( it->second.handshake->getNetworkGameManagerId() );
+              // init the new message manager
               MessageManager::getInstance()->setUniqueID( it->second.handshake->getMessageManagerId() );
             }
@@ -432 +572 @@
 
             PRINT(0)("handshake finished id=%d\n", it->second.handshake->getNetworkGameManagerId());
-
             it->second.handshake->del();
           }
           else
           {
+            // handshake finished registring new player
             if ( it->second.handshake->canDel() )
             {
-              if ( type == NET_SERVER )
+
+              if ( this->pInfo->isMasterServer() )
               {
-                handleNewClient( it->second.userId );
+                it->second.nodeType = it->second.handshake->getRemoteNodeType();
+                it->second.ip = it->second.socket->getRemoteAddress();
+
+                this->networkMonitor->addNode(&it->second);
+
+                this->handleNewClient( it->second.userId );
+
+                if ( PlayerStats::getStats( it->second.userId ) && it->second.handshake->getPreferedNickName() != "" )
+                {
+                  PlayerStats::getStats( it->second.userId )->setNickName( it->second.handshake->getPreferedNickName() );
+                }
+              }
+              else if ( this->pInfo->isProxyServer() )
+              {
+                it->second.nodeType = it->second.handshake->getRemoteNodeType();
+                it->second.ip = it->second.socket->getRemoteAddress();
+
+                this->networkMonitor->addNode(&it->second);
+
+                this->handleNewClient( it->second.userId );
 
                 if ( PlayerStats::getStats( it->second.userId ) && it->second.handshake->getPreferedNickName() != "" )
@@ -468 +628 @@
 
 /**
+ * this functions handles a reconnect event received from the a NET_MASTER_SERVER or NET_PROXY_SERVER
+ */
+void NetworkStream::handleReconnect(int userId)
+{
+  PRINTF(0)("===============================================\n");
+  PRINTF(0)("Client is redirected to the other proxy servers\n");
+  PRINTF(0)("===============================================\n");
+
+  return;
+
+  PeerInfo* pInfo = &this->peers[userId];
+
+  // reject the server
+  pInfo->handshake->doReject( "redirected to different server");
+
+  // flush the old synchronization states, since the numbering could be completely different
+  pInfo->lastAckedState = 0;
+  pInfo->lastRecvedState = 0;
+  // not sure if this works as expected
+  if( pInfo->handshake)
+    delete pInfo->handshake;
+
+  // disconnect from the current server and reconnect to proxy server
+  pInfo->socket->reconnectToServer( pInfo->handshake->getProxy1Address().ipString(), pInfo->handshake->getProxy1Address().port());
+
+  // and restart the handshake
+  this->startHandshake();
+}
+
+
+/**
  * handle upstream network traffic
  */
@@ -501 +692 @@
     for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
     {
+
       int oldOffset = offset;
       Synchronizeable & sync = **it;
+
 
       // do not include synchronizeables with uninit id and syncs that don't want to be synchronized
@@ -512 +705 @@
         continue;
 
-      // if we are a server and this is not our handshake
-      if ( isServer() && sync.getLeafClassID() == CL_HANDSHAKE && sync.getUniqueID() != peer->second.userId )
+      // if we are a server (both master and proxy servers) and this is not our handshake
+      if ( ( SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer() ) && sync.getLeafClassID() == CL_HANDSHAKE && sync.getUniqueID() != peer->second.userId )
         continue;
 
@@ -521 +714 @@
         continue;
 
+
+      assert( sync.getLeafClassID() != 0);
+
       assert( offset + INTSIZE <= UDP_PACKET_SIZE );
 
       // server fakes uniqueid == 0 for handshake
-      if ( this->isServer() && sync.getUniqueID() < MAX_CONNECTIONS - 1 )
+      if ( ( SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer() ) &&
+             sync.getUniqueID() <= SharedNetworkData::getInstance()->getMaxPlayer() + 1) // plus one to handle one client more than the max to redirect it
         n = Converter::intToByteArray( 0, buf + offset, UDP_PACKET_SIZE - offset );
       else
         n = Converter::intToByteArray( sync.getUniqueID(), buf + offset, UDP_PACKET_SIZE - offset );
 
+
       assert( n == INTSIZE );
       offset += n;
 
-      // make space for size
+      // make space for packet size
       offset += INTSIZE;
 
@@ -573 +771 @@
     // now compress the data with the zip library
     int compLength = 0;
-    if ( this->isServer() )
+    if ( SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer())
       compLength = Zip::getInstance()->zip( buf, offset, compBuf, UDP_PACKET_SIZE, dictServer );
     else
@@ -637 +835 @@
       assert( Converter::byteArrayToInt( buf + 2*INTSIZE, &fromState ) == INTSIZE );
       assert( Converter::byteArrayToInt( buf + 3*INTSIZE, &ackedState ) == INTSIZE );
-      //NETPRINTF(n)("ackedstate: %d\n", ackedState);
       offset = 4*INTSIZE;
 
       peer->second.connectionMonitor->processUnzippedIncomingPacket( tick, buf, packetLength, state, ackedState );
 
-      //NETPRINTF(n)("got packet: %d, %d\n", length, packetLength);
-
-    //if this is an old state drop it
+
+      //if this is an old state drop it
       if ( state <= peer->second.lastRecvedState )
         continue;
@@ -655 +851 @@
       }
 
-      while ( offset + 2*INTSIZE < length )
+      while ( offset + 2 * INTSIZE < length )
       {
         assert( offset > 0 );
@@ -669 +865 @@
         Synchronizeable * sync = NULL;
 
+        // look for the synchronizeable in question
         for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
         {
-        //                                        client thinks his handshake has id 0!!!!!
+          // client thinks his handshake has id 0!!!!!
           if ( (*it)->getUniqueID() == uniqueId || ( uniqueId == 0 && (*it)->getUniqueID() == peer->second.userId ) )
           {
@@ -679 +876 @@
         }
 
+        // this synchronizeable does not yet exist! create it
         if ( sync == NULL )
         {
           PRINTF(0)("could not find sync with id %d. try to create it\n", uniqueId);
+
+          // if it is an old synchronizeable already removed, ignore it
           if ( oldSynchronizeables.find( uniqueId ) != oldSynchronizeables.end() )
           {
@@ -688 +888 @@
           }
 
-          if ( !peers[peer->second.userId].isServer )
+          // if the node we got this unknown sync from is a client we ignore it (since it has no rights to create a new sync)
+          if ( peers[peer->second.userId].isClient() )
           {
             offset += syncDataLength;
@@ -705 +906 @@
           assert( leafClassId != 0 );
 
+
           BaseObject * b = NULL;
           /* These are some small exeptions in creation: Not all objects can/should be created via Factory */
@@ -710 +912 @@
           if( leafClassId == CL_NULL_PARENT || leafClassId == CL_SYNCHRONIZEABLE || leafClassId == CL_NETWORK_GAME_MANAGER )
           {
-            PRINTF(1)("Can not create Class with ID %x!\n", (int)leafClassId);
+            PRINTF(1)("Don't create Object with ID %x, ignored!\n", (int)leafClassId);
             offset += syncDataLength;
             continue;
@@ -730 +932 @@
             sync->setSynchronized(true);
 
-            PRINTF(0)("Fabricated %s with id %d\n", sync->getClassName(), sync->getUniqueID());
+            PRINTF(0)("Fabricated %s with id %d\n", sync->getClassCName(), sync->getUniqueID());
           }
           else
@@ -744 +946 @@
         int n = sync->setStateDiff( peer->second.userId, buf+offset, syncDataLength, state, fromState );
         offset += n;
-        //NETPRINTF(0)("SSSSSEEEEETTTTT: %s %d\n",sync->getClassName(), n);
 
       }
@@ -779 +980 @@
 /**
  * is executed when a handshake has finished
- * @todo create playable for new user
  */
 void NetworkStream::handleNewClient( int userId )
 {
+  // init and assign the message manager
   MessageManager::getInstance()->initUser( userId );
-
+  // do all game relevant stuff here
   networkGameManager->signalNewPlayer( userId );
 }
+
 
 /**