Changeset 9347 in orxonox.OLD for branches/proxy/src/lib/network/network_stream.cc

Timestamp:

Jul 20, 2006, 11:43:27 AM (19 years ago)

Author:

bensch

Message:

orxonox/proxy: merged the proxy.old back again, and it seems to work.

Merged with command
svn merge -r9247:HEAD ​https://svn.orxonox.net/orxonox/branches/proxy.old .

no conflicts

File:

• branches/proxy/src/lib/network/network_stream.cc (modified) (27 diffs)

branches/proxy/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;
 
@@ -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
+  this->pInfo->nodeType = NET_CLIENT;
+}
+
+
+/**
+ * start as a client, connect to a server
  *  @param host: host name (address)
  *  @param port: port number
@@ -68 +76 @@
 NetworkStream::NetworkStream( std::string host, int port )
 {
-  this->type = NET_CLIENT;
   this->init();
+  // init the peers[0] the server to ceonnect to
   this->peers[0].socket = new UdpSocket( host, port );
   this->peers[0].userId = 0;
-  this->peers[0].isServer = true;
+  this->peers[0].nodeType = NET_MASTER_SERVER;
   this->peers[0].connectionMonitor = new ConnectionMonitor( 0 );
+  this->peers[0].ip = this->peers[0].socket->getRemoteAddress();
+  // and set also the localhost
+  this->pInfo->nodeType = NET_CLIENT;
+  // get the local ip address
+  IPaddress ip;
+  SDLNet_ResolveHost( &ip, NULL, port );
+  this->pInfo->ip = ip;
 }
 
@@ -83 +98 @@
 NetworkStream::NetworkStream( int port )
 {
-  this->type = NET_SERVER;
   this->init();
   this->serverSocket = new UdpServerSocket(port);
-  this->bActive = true;
+  this->pInfo->nodeType = NET_MASTER_SERVER;
+  // get the local ip address
+  IPaddress ip;
+  SDLNet_ResolveHost( &ip, NULL, port );
+  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;
 }
 
@@ -165 +195 @@
 /**
  * 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());
 }
@@ -192 +222 @@
   sync.setNetworkStream( this );
 
-  this->bActive = true;
+//   this->bActive = true;
 }
 
@@ -215 +245 @@
 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->nodeType == NET_MASTER_SERVER )
+  {
+    // execute everytthing the master server shoudl do
     if ( serverSocket )
       serverSocket->update();
 
     this->updateConnectionList();
+  }
+  else if( this->pInfo->nodeType == NET_PROXY_SERVER_ACTIVE)
+  {
+    // execute everything the proxy server should do
   }
   else
@@ -249 +294 @@
   cleanUpOldSyncList();
   handleHandshakes();
+
+  // update the network monitor
+  this->networkMonitor->process();
 
   // order of up/downstream is important!!!!
@@ -258 +306 @@
 
 /**
- * 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 +324 @@
       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 +332 @@
         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);
+      PRINTF(0)("proxy1 ip set to: %s\n", pi->ip.ipString().c_str());
+    }
+
+    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());
+
+    // 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);
+
+
   }
 
@@ -373 +440 @@
 void NetworkStream::debug()
 {
-  if( this->isServer())
-    PRINT(0)(" Host ist Server with ID: %i\n", this->myHostId);
+  if( this->isMasterServer())
+    PRINT(0)(" Host ist Server with ID: %i\n", this->pInfo->userId);
   else
-    PRINT(0)(" Host ist Client with ID: %i\n", this->myHostId);
+    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());
@@ -385 +452 @@
                (*it)->getUniqueID(), (*it)->beSynchronized());
   }
-  PRINT(0)(" Maximal Connections: %i\n", MAX_CONNECTIONS );
+  PRINT(0)(" Maximal Connections: %i\n", SharedNetworkData::getInstance()->getMaxPlayer() );
 
 }
@@ -414 +481 @@
     if ( it->second.handshake )
     {
+      // handshake finished
       if ( it->second.handshake->completed() )
       {
+        //handshake is correct
         if ( it->second.handshake->ok() )
         {
           if ( !it->second.handshake->allowDel() )
           {
-            if ( type != NET_SERVER )
+            if ( this->pInfo->nodeType == NET_CLIENT )
             {
               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);
+              PRINTF(0)("proxy1 ip read to: %s\n", it->second.handshake->getProxy1Address().ipString().c_str());
+              // 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() );
             }
@@ -437 +522 @@
           else
           {
+            // handshake finished registring new player
             if ( it->second.handshake->canDel() )
             {
-              if ( type == NET_SERVER )
+              if ( this->pInfo->nodeType == NET_MASTER_SERVER )
               {
-                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() != "" )
@@ -468 +559 @@
 
 /**
+ * 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");
+
+  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
  */
@@ -513 +633 @@
 
       // if we are a server and this is not our handshake
-      if ( isServer() && sync.getLeafClassID() == CL_HANDSHAKE && sync.getUniqueID() != peer->second.userId )
+      if ( isMasterServer() && sync.getLeafClassID() == CL_HANDSHAKE && sync.getUniqueID() != peer->second.userId )
         continue;
 
@@ -524 +644 @@
 
       // server fakes uniqueid == 0 for handshake
-      if ( this->isServer() && sync.getUniqueID() < MAX_CONNECTIONS - 1 )
+      if ( this->isMasterServer() && sync.getUniqueID() < SharedNetworkData::getInstance()->getMaxPlayer() - 1 )
         n = Converter::intToByteArray( 0, buf + offset, UDP_PACKET_SIZE - offset );
       else
@@ -573 +693 @@
     // now compress the data with the zip library
     int compLength = 0;
-    if ( this->isServer() )
+    if ( this->isMasterServer() )
       compLength = Zip::getInstance()->zip( buf, offset, compBuf, UDP_PACKET_SIZE, dictServer );
     else
@@ -637 +757 @@
       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;
@@ -688 +806 @@
           }
 
-          if ( !peers[peer->second.userId].isServer )
+          if ( !peers[peer->second.userId].isMasterServer() )
           {
             offset += syncDataLength;
@@ -779 +897 @@
 /**
  * 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 );
-}
+
+  // register the new client at the network monitor
+//   this->networkMonitor->addClient();
+}
+
 
 /**