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

Timestamp:

May 10, 2006, 1:13:49 PM (18 years ago)

Author:

rennerc

Message:

reimplemented NetworkStream

File:

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

branches/network/src/lib/network/network_stream.cc

@@ -23 +23 @@
 #include "base_object.h"
 #include "network_protocol.h"
-#include "tcp_socket.h"
-#include "tcp_server_socket.h"
+#include "udp_socket.h"
+#include "udp_server_socket.h"
 #include "connection_monitor.h"
 #include "synchronizeable.h"
 #include "network_game_manager.h"
 #include "shared_network_data.h"
+
+#include "lib/util/loading/factory.h"
 
 #include "debug.h"
@@ -59 +61 @@
   this->type = NET_CLIENT;
   this->init();
-  this->networkSockets.push_back(new TcpSocket( host, port ));
+  this->peers[0].socket = new UdpSocket( host, port );
   this->networkProtocol = new NetworkProtocol();
   this->connectionMonitor = new ConnectionMonitor();
-  this->maxConnections = 1;
-}
-
-
-NetworkStream::NetworkStream( int port)
+  this->maxConnections = MAX_CONNECTIONS;
+}
+
+
+NetworkStream::NetworkStream( int port )
 {
   this->type = NET_SERVER;
   this->init();
-  this->serverSocket = new TcpServerSocket(port);
+  this->serverSocket = new UdpServerSocket(port);
   this->networkProtocol = new NetworkProtocol();
   this->connectionMonitor = new ConnectionMonitor();
-  this->networkSockets.push_back( NULL );
-  this->networkSockets[0] = NULL; //TODO: remove this
-  this->handshakes.push_back( NULL );
   this->bActive = true;
 }
@@ -88 +87 @@
   this->networkGameManager = NULL;
   myHostId = 0;
+  currentState = 0;
 }
 
@@ -99 +99 @@
   }
 
-  for (NetworkSocketVector::iterator i = networkSockets.begin(); i!=networkSockets.end(); i++)
-  {
-    if ( *i )
-    {
-      (*i)->disconnectServer();
-    }
-  }
-
-  for (HandshakeVector::iterator i = handshakes.begin(); i!=handshakes.end(); i++)
-  {
-    if ( *i )
-    {
-      delete (*i);
-    }
+  for ( PeerList::iterator i = peers.begin(); i!=peers.end(); i++)
+  {
+    if ( i->second.socket )
+    {
+      i->second.socket->disconnectServer();
+      delete i->second.socket;
+      i->second.socket = NULL;
+    }
+    
+    if ( i->second.handshake )
+    {
+      delete i->second.handshake;
+      i->second.handshake = NULL;
+    }
+  }
+  
+  if ( serverSocket )
+  {
+    delete serverSocket;
+    serverSocket = NULL;
   }
 
@@ -126 +132 @@
   // and one for handshake to reject client maxCon+1
   this->networkGameManager->setUniqueID( this->maxConnections + 2 );
-  //this->connectSynchronizeable( *(this->networkGameManager) );
-  this->setMaxConnections( 10 );
+
 }
 
@@ -135 +140 @@
   Handshake* hs = new Handshake(false);
   hs->setUniqueID( 0 );
-  this->handshakes.push_back(hs);
+  assert( peers[0].handshake == NULL );
+  peers[0].handshake = hs;
   //this->connectSynchronizeable(*hs);
   PRINTF(0)("NetworkStream: %s\n", hs->getName());
@@ -146 +152 @@
   sync.setNetworkStream( this );
 
-  if( this->networkSockets.size()>0 )
-    this->bActive = true;
+  this->bActive = true;
 }
 
@@ -158 +163 @@
     this->synchronizeables.erase(disconnectSynchro);
 
-  if( this->networkSockets.size()<=0 )
-    this->bActive = false;
+  this->bActive = false;
 }
 
@@ -165 +169 @@
 void NetworkStream::processData()
 {
+  currentState++;
+  
   if ( this->type == NET_SERVER )
     this->updateConnectionList();
   else
   {
-    if ( networkSockets[0] && !networkSockets[0]->isOk() )
+    if ( peers[0].socket && !peers[0].socket->isOk() )
     {
       PRINTF(1)("lost connection to server\n");
 
-      //delete networkSockets[i];
-      networkSockets[0]->disconnectServer();
-      networkSockets[0] = NULL;
-
-      if ( handshakes[0] )
-        delete handshakes[0];
-      handshakes[0] = NULL;
-    }
-  }
-
-  for (int i = 0; i<handshakes.size(); i++)
-  {
-    if ( handshakes[i] )
-    {
-      if ( handshakes[i]->completed() )
-      {
-        if ( handshakes[i]->ok() )
-        {
-          if ( type != NET_SERVER )
-          {
-            SharedNetworkData::getInstance()->setHostID( handshakes[i]->getHostId() );
-            myHostId = SharedNetworkData::getInstance()->getHostID();
-
-            this->networkGameManager = NetworkGameManager::getInstance();
-            this->networkGameManager->setUniqueID( handshakes[i]->getNetworkGameManagerId() );
-            //this->connectSynchronizeable( *(this->networkGameManager) );
-          }
-          else
-          {
-
-          }
-          PRINT(0)("handshake finished id=%d\n", handshakes[i]->getNetworkGameManagerId());
-
-
-          delete handshakes[i];
-          handshakes[i] = NULL;
-        }
-        else
-        {
-          PRINT(1)("handshake failed!\n");
-          networkSockets[i]->disconnectServer();
-          delete handshakes[i];
-          handshakes[i] = NULL;
-          //TODO: handle error
-        }
-      }
-    }
-  }
+      peers[0].socket->disconnectServer();
+      delete peers[0].socket;
+      peers[0].socket = NULL;
+
+      if ( peers[0].handshake )
+        delete peers[0].handshake;
+      peers[0].handshake = NULL;
+    }
+  }
+
+
 
 
   /* DOWNSTREAM */
-
+#if 0
 
 
@@ -341 +310 @@
         {
 #warning fix this
-#if 0
+
           if ( *it && (*it)->getUniqueID()==header.synchronizeableID )
           {
@@ -351 +320 @@
             continue;
           }
+
+        }
+
+      } while ( dataLength>0 );
+    }
+
+  }
 #endif
-        }
-
-      } while ( dataLength>0 );
-    }
-  }
 }
 
@@ -372 +343 @@
       clientId = freeSocketSlots.back();
       freeSocketSlots.pop_back();
-      networkSockets[clientId] = tempNetworkSocket;
-      handshakes[clientId] = new Handshake(true, clientId, this->networkGameManager->getUniqueID());
-      handshakes[clientId]->setUniqueID(clientId);
+      peers[clientId].socket = tempNetworkSocket;
+      peers[clientId].handshake = new Handshake(true, clientId, this->networkGameManager->getUniqueID());
+      peers[clientId].handshake->setUniqueID(clientId);
+      peers[clientId].userId = clientId;
     } else
     {
-      clientId = networkSockets.size();
-      networkSockets.push_back(tempNetworkSocket);
-      Handshake* tHs = new Handshake(true, clientId, this->networkGameManager->getUniqueID());
-      tHs->setUniqueID(clientId);
-      handshakes.push_back(tHs);
+      clientId = 0;
+      
+      for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+        if ( it->first >= clientId )
+          clientId = it->first + 1;
+      
+      peers[clientId].socket = tempNetworkSocket;
+      peers[clientId].handshake = new Handshake(true, clientId, this->networkGameManager->getUniqueID());
+      peers[clientId].handshake->setUniqueID(clientId);
+      peers[clientId].userId = clientId;
     }
 
     if ( clientId > this->maxConnections )
     {
-      handshakes[clientId]->doReject( "too many connections" );
+      peers[clientId].handshake->doReject( "too many connections" );
       PRINTF(0)("Will reject client %d because there are to many connections!\n", clientId);
     }
@@ -398 +375 @@
 
   //check if connections are ok else remove them
-  for ( int i = 1; i<networkSockets.size(); i++)
-  {
-    if ( networkSockets[i] && !networkSockets[i]->isOk() )
-    {
-      //TODO: tell EntityManager that this player left the game
-      PRINTF(0)("Client is gone: %d\n", i);
-
-      //delete networkSockets[i];
-      networkSockets[i]->disconnectServer();
-      networkSockets[i] = NULL;
-
-      if ( handshakes[i] )
-        delete handshakes[i];
-      handshakes[i] = NULL;
-
-
-      NetworkGameManager::getInstance()->signalLeftPlayer(i);
-
-      if ( i == networkSockets.size()-1 )
-      {
-        networkSockets.pop_back();
-        handshakes.pop_back();
-      }
-      else
-      {
-        freeSocketSlots.push_back(i);
-      }
-    }
-  }
-
-
-}
-
-void NetworkStream::setMaxConnections( int n )
-{
-  if ( !this->isServer() )
-  {
-    PRINTF(1)("Cannot set maxConnections because I am no server.\n");
-  }
-  if ( this->networkSockets.size() > 1 )
-  {
-    PRINTF(1)("Cannot set maxConnections because there are already %d connections.\n", this->networkSockets.size());
-    return;
-  }
-
-  if ( n > MAX_CONNECTIONS )
-  {
-    PRINTF(1)("Cannot set maxConnectiosn to %d because of hardcoded limit %d\n", n, MAX_CONNECTIONS);
-    return;
-  }
-
-  this->maxConnections = n;
-  this->networkGameManager->setUniqueID( n+2 );
-}
-
-
+  for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+  {
+    if ( it->second.socket && !it->second.socket->isOk() )
+    {
+      PRINTF(0)("Client is gone: %d\n", it->second.userId);
+
+      it->second.socket->disconnectServer();
+      delete it->second.socket;
+      it->second.socket = NULL;
+
+      if ( it->second.handshake )
+        delete it->second.handshake;
+      it->second.handshake = NULL;
+
+
+      NetworkGameManager::getInstance()->signalLeftPlayer(it->second.userId);
+
+      freeSocketSlots.push_back( it->second.userId );
+
+    }
+  }
+
+
+}
 
 void NetworkStream::debug()
@@ -485 +430 @@
 }
 
-
-
-
-
-
+/**
+ * check if handshakes completed
+ */
+void NetworkStream::handleHandshakes( )
+{
+  for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+  {
+    if ( it->second.handshake )
+    {
+      if ( it->second.handshake->completed() )
+      {
+        if ( it->second.handshake->ok() )
+        {
+          if ( type != NET_SERVER )
+          {
+            SharedNetworkData::getInstance()->setHostID( it->second.handshake->getHostId() );
+            myHostId = SharedNetworkData::getInstance()->getHostID();
+
+            this->networkGameManager = NetworkGameManager::getInstance();
+            this->networkGameManager->setUniqueID( it->second.handshake->getNetworkGameManagerId() );
+          }
+
+          PRINT(0)("handshake finished id=%d\n", it->second.handshake->getNetworkGameManagerId());
+
+
+          delete it->second.handshake;
+          it->second.handshake = NULL;
+        }
+        else
+        {
+          PRINT(1)("handshake failed!\n");
+          it->second.socket->disconnectServer();
+        }
+      }
+    }
+  }
+}
+
+/**
+ * handle upstream network traffic
+ */
+void NetworkStream::handleUpstream( )
+{
+  byte buf[UDP_PACKET_SIZE];
+  int offset;
+  int n;
+  
+  for ( PeerList::iterator peer = peers.begin(); peer != peers.end(); peer++ )
+  {
+    offset = INTSIZE; //make already space for length 
+    
+    if ( peer->second.socket )
+      continue;
+    
+    n = Converter::intToByteArray( currentState, buf + offset, UDP_PACKET_SIZE - offset );
+    assert( n == INTSIZE );
+    offset += n;
+    
+    n = Converter::intToByteArray( peer->second.lastAckedState, buf + offset, UDP_PACKET_SIZE - offset );
+    assert( n == INTSIZE );
+    offset += n;
+    
+    n = Converter::intToByteArray( peer->second.lastRecvedState, buf + offset, UDP_PACKET_SIZE - offset );
+    assert( n == INTSIZE );
+    offset += n;
+    
+    for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+    {
+      Synchronizeable & sync = **it;
+      
+      assert( offset + INTSIZE <= UDP_PACKET_SIZE );
+      
+      n = Converter::intToByteArray( sync.getUniqueID(), buf + offset, UDP_PACKET_SIZE - offset );
+      assert( n == INTSIZE );
+      offset += n;
+      
+      offset += sync.getStateDiff( peer->second.userId, buf + offset, UDP_PACKET_SIZE-offset, currentState, peer->second.lastAckedState, 0 );
+    }
+    
+    assert( Converter::intToByteArray( offset, buf, INTSIZE ) == INTSIZE );
+    
+    assert( peer->second.socket->writePacket( buf, offset ) );
+  }
+}
+
+/**
+ * handle downstream network traffic
+ */
+void NetworkStream::handleDownstream( )
+{
+  byte buf[UDP_PACKET_SIZE];
+  int offset = 0;
+  
+  int length = 0;
+  int packetLength = 0;
+  int uniqueId = 0;
+  int state = 0;
+  int ackedState = 0;
+  int fromState = 0;
+  
+  for ( PeerList::iterator peer = peers.begin(); peer != peers.end(); peer++ )
+  {
+    packetLength = peer->second.socket->readPacket( buf, UDP_PACKET_SIZE );
+    
+    assert( Converter::byteArrayToInt( buf, &length ) == INTSIZE );
+    assert( Converter::byteArrayToInt( buf + INTSIZE, &state ) == INTSIZE );
+    assert( Converter::byteArrayToInt( buf + 2*INTSIZE, &fromState ) == INTSIZE );
+    assert( Converter::byteArrayToInt( buf + 3*INTSIZE, &ackedState ) == INTSIZE );
+    
+    //if this is an old state drop it
+    if ( state <= peer->second.lastRecvedState )
+      continue;
+    
+    if ( packetLength != length )
+    {
+      PRINTF(1)("real packet length (%d) and transmitted packet length (%d) do not match!\n", packetLength, length);
+      peer->second.socket->disconnectServer();
+      continue;
+    }
+    
+    offset = 4*INTSIZE;
+    
+    while ( offset < length )
+    {
+      assert( Converter::byteArrayToInt( buf + offset, &uniqueId ) == INTSIZE );
+      offset += INTSIZE;
+      
+      Synchronizeable * sync = NULL;
+      
+      for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+      {
+        if ( (*it)->getUniqueID() == uniqueId )
+        {
+          sync = *it;
+          break;
+        }
+      }
+      
+      if ( sync == NULL )
+      {
+        //TODO dont accept new object from all peers (probably only servers)
+        int leafClassId;
+        if ( INTSIZE > length - offset )
+          break;
+        
+        Converter::byteArrayToInt( buf + offset, &leafClassId );
+        
+        BaseObject * b;
+        /* These are some small exeptions in creation: Not all objects can/should be created via Factory */
+        /* Exception 1: NullParent */
+        if( leafClassId == CL_NULL_PARENT)
+        {
+          PRINTF(1)("Can not create Class with ID %x!", (int)leafClassId);
+          break;
+        }
+        else
+          b = Factory::fabricate( (ClassID)leafClassId );
+
+        if ( !b )
+        {
+          PRINTF(1)("Could not fabricate Object with classID %x\n", leafClassId);
+          break;
+        }
+        
+        if ( b->isA(CL_SYNCHRONIZEABLE) )
+        {
+          sync = dynamic_cast<Synchronizeable*>(b);
+          sync->setUniqueID( uniqueId );
+          sync->setSynchronized(true);
+  
+          PRINTF(0)("Fabricated %s with id %d\n", sync->getClassName(), sync->getUniqueID());
+        }
+        else
+        {
+          PRINTF(1)("Class with ID %x is not a synchronizeable!", (int)leafClassId);
+          delete b;
+          break;
+        }
+      }
+      
+      offset += sync->setStateDiff( peer->second.userId, buf+offset, length-offset, state, fromState );
+    }
+    
+    if ( offset != length )
+    {
+      peer->second.socket->disconnectServer();
+    }
+    
+    peer->second.lastAckedState = ackedState;
+  }
+}
+
+
+
+
+
+