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

Timestamp:

May 29, 2006, 3:28:41 PM (19 years ago)

Author:

patrick

Message:

trunk: merged the network branche back to trunk.

File:

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

trunk/src/lib/network/network_stream.cc

@@ -23 +23 @@
 #include "base_object.h"
 #include "network_protocol.h"
-#include "network_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 "message_manager.h"
+#include "preferences.h"
+#include "zip.h"
+
+#include "src/lib/util/loading/resource_manager.h"
+
+#include "network_log.h"
+
+
+#include "lib/util/loading/factory.h"
 
 #include "debug.h"
@@ -49 +60 @@
   /* initialize the references */
   this->type = NET_CLIENT;
-  this->networkProtocol = new NetworkProtocol();
-  this->connectionMonitor = new ConnectionMonitor();
-}
-
-
-NetworkStream::NetworkStream(IPaddress& address)
+}
+
+
+NetworkStream::NetworkStream( std::string host, int port )
 {
   this->type = NET_CLIENT;
   this->init();
-  this->networkSockets.push_back(new NetworkSocket(address));
-  this->networkProtocol = new NetworkProtocol();
-  this->connectionMonitor = new ConnectionMonitor();
-  this->maxConnections = 1;
-}
-
-
-NetworkStream::NetworkStream(unsigned int port)
+  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 );
+}
+
+
+NetworkStream::NetworkStream( int port )
 {
   this->type = NET_SERVER;
   this->init();
-  this->serverSocket = new ServerSocket(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->serverSocket = new UdpServerSocket(port);
   this->bActive = true;
 }
@@ -87 +91 @@
   this->networkGameManager = NULL;
   myHostId = 0;
+  currentState = 0;
+  
+  remainingBytesToWriteToDict = Preferences::getInstance()->getInt( "compression", "writedict", 0 );
+  
+  assert( Zip::getInstance()->loadDictionary( "testdict" ) );
 }
 
@@ -98 +107 @@
   }
 
-  for (NetworkSocketVector::iterator i = networkSockets.begin(); i!=networkSockets.end(); i++)
-  {
-    if ( *i )
-    {
-      (*i)->disconnectServer();
-      (*i)->destroy();
-    }
-  }
-
-  for (HandshakeVector::iterator i = handshakes.begin(); i!=handshakes.end(); i++)
-  {
-    if ( *i )
-    {
-      delete (*i);
-    }
-  }
-
-  delete connectionMonitor;
-  delete networkProtocol;
+  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;
+  }
+
 }
 
@@ -125 +137 @@
   // setUniqueID( maxCon+2 ) because we need one id for every handshake
   // and one for handshake to reject client maxCon+1
-  this->networkGameManager->setUniqueID( this->maxConnections + 2 );
-  //this->connectSynchronizeable( *(this->networkGameManager) );
-  this->setMaxConnections( 10 );
+  this->networkGameManager->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
+  MessageManager::getInstance()->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
 }
 
@@ -135 +146 @@
   Handshake* hs = new Handshake(false);
   hs->setUniqueID( 0 );
-  this->handshakes.push_back(hs);
+  assert( peers[0].handshake == NULL );
+  peers[0].handshake = hs;
+//   peers[0].handshake->setSynchronized( true );
   //this->connectSynchronizeable(*hs);
-  PRINTF(0)("NetworkStream: %s\n", hs->getName());
+  //this->connectSynchronizeable(*hs);
+  PRINTF(0)("NetworkStream: Handshake created: %s\n", hs->getName());
 }
 
@@ -146 +160 @@
   sync.setNetworkStream( this );
 
-  if( this->networkSockets.size()>0 )
-    this->bActive = true;
+  this->bActive = true;
 }
 
@@ -157 +170 @@
   if (disconnectSynchro != this->synchronizeables.end())
     this->synchronizeables.erase(disconnectSynchro);
-
-  if( this->networkSockets.size()<=0 )
-    this->bActive = false;
+  
+  oldSynchronizeables[sync.getUniqueID()] = SDL_GetTicks();
 }
 
@@ -165 +177 @@
 void NetworkStream::processData()
 {
+  currentState++;
+  
   if ( this->type == NET_SERVER )
+  {
+    if ( serverSocket )
+      serverSocket->update();
+    
     this->updateConnectionList();
+  }
   else
   {
-    if ( networkSockets[0] && !networkSockets[0]->isOk() )
+    if ( peers[0].socket && ( !peers[0].socket->isOk() || peers[0].connectionMonitor->hasTimedOut() ) )
     {
       PRINTF(1)("lost connection to server\n");
 
-      //delete networkSockets[i];
-      networkSockets[0]->disconnectServer();
-      networkSockets[0]->destroy();
-      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() )
+      peers[0].socket->disconnectServer();
+      delete peers[0].socket;
+      peers[0].socket = NULL;
+
+      if ( peers[0].handshake )
+        delete peers[0].handshake;
+      peers[0].handshake = NULL;
+    }
+  }
+
+  cleanUpOldSyncList();
+  handleHandshakes();
+  
+  // order of up/downstream is important!!!!
+  // don't change it
+  handleDownstream();
+  handleUpstream();
+
+}
+
+void NetworkStream::updateConnectionList( )
+{
+  //check for new connections
+
+  NetworkSocket* tempNetworkSocket = serverSocket->getNewSocket();
+
+  if ( tempNetworkSocket )
+  {
+    int clientId;
+    if ( freeSocketSlots.size() >0 )
+    {
+      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
+    {
+      clientId = 1;
+      
+      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(), 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());
+    }
+
+    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]);
+  }
+
+  //check if connections are ok else remove them
+  for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+  {
+    if (  
+          it->second.socket &&
+          ( 
+            !it->second.socket->isOk()  ||
+            it->second.connectionMonitor->hasTimedOut()
+          )
+       )
+    {
+      std::string reason = "disconnected";
+      if ( it->second.connectionMonitor->hasTimedOut() )
+        reason = "timeout";
+      PRINTF(0)("Client is gone: %d (%s)\n", it->second.userId, reason.c_str());
+      
+      assert(false);
+
+      it->second.socket->disconnectServer();
+      delete it->second.socket;
+      it->second.socket = NULL;
+
+      if ( it->second.handshake )
+        delete it->second.handshake;
+      it->second.handshake = NULL;
+      
+      for ( SynchronizeableList::iterator it2 = synchronizeables.begin(); it2 != synchronizeables.end(); it2++ )
       {
-        if ( handshakes[i]->ok() )
+        (*it2)->cleanUpUser( it->second.userId );
+      }
+
+      NetworkGameManager::getInstance()->signalLeftPlayer(it->second.userId);
+
+      freeSocketSlots.push_back( it->second.userId );
+
+    }
+  }
+
+
+}
+
+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);
+
+  PRINT(0)(" Got %i connected Synchronizeables, showing active Syncs:\n", this->synchronizeables.size());
+  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
+  {
+    if( (*it)->beSynchronized() == true)
+      PRINT(0)("  Synchronizeable of class: %s::%s, with unique ID: %i, Synchronize: %i\n", (*it)->getClassName(), (*it)->getName(),
+               (*it)->getUniqueID(), (*it)->beSynchronized());
+  }
+  PRINT(0)(" Maximal Connections: %i\n", MAX_CONNECTIONS );
+
+}
+
+
+int NetworkStream::getSyncCount()
+{
+  int n = 0;
+  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
+    if( (*it)->beSynchronized() == true)
+      ++n;
+
+  //return synchronizeables.size();
+  return n;
+}
+
+/**
+ * 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( handshakes[i]->getHostId() );
-            myHostId = SharedNetworkData::getInstance()->getHostID();
-
-            this->networkGameManager = NetworkGameManager::getInstance();
-            this->networkGameManager->setUniqueID( handshakes[i]->getNetworkGameManagerId() );
-            //this->connectSynchronizeable( *(this->networkGameManager) );
+          if ( !it->second.handshake->allowDel() )
+          {
+            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() );
+              MessageManager::getInstance()->setUniqueID( it->second.handshake->getMessageManagerId() );
+            }
+              
+
+            PRINT(0)("handshake finished id=%d\n", it->second.handshake->getNetworkGameManagerId());
+
+            it->second.handshake->del();
           }
           else
           {
-
-          }
-          PRINT(0)("handshake finished id=%d\n", handshakes[i]->getNetworkGameManagerId());
-
-
-          delete handshakes[i];
-          handshakes[i] = NULL;
+            if ( it->second.handshake->canDel() )
+            {
+              if ( type == NET_SERVER )
+              {
+                handleNewClient( it->second.userId );
+              }
+              
+              PRINT(0)("handshake finished delete it\n");
+              delete it->second.handshake;
+              it->second.handshake = NULL;
+            }
+          }
+
         }
         else
         {
           PRINT(1)("handshake failed!\n");
-          networkSockets[i]->disconnectServer();
-          delete handshakes[i];
-          handshakes[i] = NULL;
-          //TODO: handle error
+          it->second.socket->disconnectServer();
         }
       }
     }
   }
-
-
-  /* DOWNSTREAM */
-
-
-
-  int dataLength;
-  int reciever;
-  Header header;
-  int counter;
-
-  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
-  {
-    counter = 0;
-
-    if ( (*it)!=NULL && (*it)->beSynchronized() /*&& (*it)->getOwner() == myHostId*/ )
-    {
-      do {
-        counter++;
-
-        //check for endless loop
-        if ( counter > 50 )
+}
+
+/**
+ * handle upstream network traffic
+ */
+void NetworkStream::handleUpstream( )
+{
+  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++ )
+    {
+      int oldOffset = offset;
+      Synchronizeable & sync = **it;
+      
+      if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
+        continue;
+
+      //if handshake not finished only sync handshake
+      if ( peer->second.handshake && sync.getLeafClassID() != CL_HANDSHAKE )
+        continue;
+      
+      if ( isServer() && sync.getLeafClassID() == CL_HANDSHAKE && sync.getUniqueID() != peer->second.userId )
+        continue;
+      
+      //do not sync null parent
+      if ( sync.getLeafClassID() == CL_NULL_PARENT )
+        continue;
+
+      assert( offset + INTSIZE <= UDP_PACKET_SIZE );
+      
+      //server fakes uniqueid=0 for handshake
+      if ( this->isServer() && sync.getUniqueID() < MAX_CONNECTIONS - 1 )
+        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
+      offset += INTSIZE;
+
+      n = sync.getStateDiff( peer->second.userId, buf + offset, UDP_PACKET_SIZE-offset, currentState, peer->second.lastAckedState, -1000 );
+      offset += n;
+      //NETPRINTF(0)("GGGGGEEEEETTTTT: %s (%d) %d\n",sync.getClassName(), sync.getUniqueID(), n);
+      
+      assert( Converter::intToByteArray( n, buf + offset - n - INTSIZE, INTSIZE ) == INTSIZE );
+      
+      //check if all bytes == 0 -> remove data 
+      //TODO not all synchronizeables like this maybe add Synchronizeable::canRemoveZeroDiff()
+      bool allZero = true; 
+      for ( int i = 0; i < n; i++ ) 
+      { 
+         if ( buf[i+oldOffset+2*INTSIZE] != 0 ) 
+           allZero = false; 
+      } 
+
+      if ( allZero ) 
+      { 
+        //NETPRINTF(n)("REMOVE ZERO DIFF: %s (%d)\n", sync.getClassName(), sync.getUniqueID()); 
+        offset = oldOffset; 
+      } 
+
+      
+    }
+    
+    for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+    {
+      Synchronizeable & sync = **it;
+      
+      if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
+        continue;
+      
+      sync.handleSentState( peer->second.userId, currentState, peer->second.lastAckedState );
+    }
+    
+    assert( Converter::intToByteArray( offset, buf, INTSIZE ) == INTSIZE );
+    
+    int compLength = Zip::getInstance()->zip( buf, offset, compBuf, UDP_PACKET_SIZE );
+    
+    if ( compLength < 0 )
+    {
+      PRINTF(1)("compression failed!\n");
+      continue;
+    }
+    
+    assert( peer->second.socket->writePacket( compBuf, compLength ) );
+    
+    if ( this->remainingBytesToWriteToDict > 0 )
+      writeToNewDict( buf, offset );
+    
+    peer->second.connectionMonitor->processUnzippedOutgoingPacket( buf, offset, currentState );
+    peer->second.connectionMonitor->processZippedOutgoingPacket( compBuf, compLength, currentState );
+    
+    //NETPRINTF(n)("send packet: %d userId = %d\n", offset, peer->second.userId);
+  }
+}
+
+/**
+ * handle downstream network traffic
+ */
+void NetworkStream::handleDownstream( )
+{
+  int offset = 0;
+  
+  int length = 0;
+  int packetLength = 0;
+  int compLength = 0;
+  int uniqueId = 0;
+  int state = 0;
+  int ackedState = 0;
+  int fromState = 0;
+  int syncDataLength = 0;
+  
+  for ( PeerList::iterator peer = peers.begin(); peer != peers.end(); peer++ )
+  {
+    
+    if ( !peer->second.socket )
+      continue;
+
+    while ( 0 < (compLength = peer->second.socket->readPacket( compBuf, UDP_PACKET_SIZE )) )
+    {
+      //TODO tell monitor about zipped packet. because dropped packets dont count to bandwidth
+      //PRINTF(0)("GGGGGOOOOOOOOOOTTTTTTTT: %d\n", compLength);
+      packetLength = Zip::getInstance()->unZip( compBuf, compLength, buf, UDP_PACKET_SIZE );
+      
+      if ( packetLength < 4*INTSIZE )
+      {
+        if ( packetLength != 0 )
+          PRINTF(1)("got too small packet: %d\n", packetLength);
+        continue;
+      }
+      
+      if ( this->remainingBytesToWriteToDict > 0 )
+        writeToNewDict( buf, packetLength );
+    
+      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 );
+      //NETPRINTF(n)("ackedstate: %d\n", ackedState);
+      offset = 4*INTSIZE;
+
+      //NETPRINTF(n)("got packet: %d, %d\n", length, packetLength);
+    
+    //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;
+      }
+      
+      while ( offset + 2*INTSIZE < length )
+      {
+        assert( offset > 0 );
+        assert( Converter::byteArrayToInt( buf + offset, &uniqueId ) == INTSIZE );
+        offset += INTSIZE;
+      
+        assert( Converter::byteArrayToInt( buf + offset, &syncDataLength ) == INTSIZE );
+        offset += INTSIZE;
+        
+        assert( syncDataLength > 0 );
+        assert( syncDataLength < 10000 );
+      
+        Synchronizeable * sync = NULL;
+        
+        for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+        { 
+        //                                        client thinks his handshake has id 0!!!!!
+          if ( (*it)->getUniqueID() == uniqueId || ( uniqueId == 0 && (*it)->getUniqueID() == peer->second.userId ) )
+          {
+            sync = *it;
+            break;
+          }
+        }
+        
+        if ( sync == NULL )
         {
-          PRINTF(1)("there seems to be an error in readBytes of %s\n", (*it)->getClassName());
-          assert(false);
+          PRINTF(0)("could not find sync with id %d. try to create it\n", uniqueId);
+          if ( oldSynchronizeables.find( uniqueId ) != oldSynchronizeables.end() )
+          {
+            offset += syncDataLength;
+            continue;
+          }
+          
+          if ( !peers[peer->second.userId].isServer )
+          {
+            offset += syncDataLength;
+            continue;
+          }
+          
+          int leafClassId;
+          if ( INTSIZE > length - offset )
+          {
+            offset += syncDataLength;
+            continue;
+          }
+
+          Converter::byteArrayToInt( buf + offset, &leafClassId );
+          
+          assert( leafClassId != 0 );
+        
+          BaseObject * b = NULL;
+          /* These are some small exeptions in creation: Not all objects can/should be created via Factory */
+          /* Exception 1: NullParent */
+          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);
+            offset += syncDataLength;
+            continue;
+          }
+          else
+            b = Factory::fabricate( (ClassID)leafClassId );
+
+          if ( !b )
+          {
+            PRINTF(1)("Could not fabricate Object with classID %x\n", leafClassId);
+            offset += syncDataLength;
+            continue;
+          }
+
+          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!\n", (int)leafClassId);
+            delete b;
+            offset += syncDataLength;
+            continue;
+          }
         }
 
-        reciever = 0;
-        dataLength = (*it)->readBytes(downBuffer, DATA_STREAM_BUFFER_SIZE, &reciever);
-
-        if ( dataLength<=0 ){
-          reciever = 0;
+        int n = sync->setStateDiff( peer->second.userId, buf+offset, syncDataLength, state, fromState ); 
+        offset += n;
+        //NETPRINTF(0)("SSSSSEEEEETTTTT: %s %d\n",sync->getClassName(), n);
+
+      }
+      
+      if ( offset != length )
+      {
+        PRINTF(0)("offset (%d) != length (%d)\n", offset, length);
+        peer->second.socket->disconnectServer();
+      }
+      
+      //TODO REMOVE THIS
+      int saveOffset = offset;
+      
+      for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+      {
+        Synchronizeable & sync = **it;
+      
+        if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
           continue;
-        }
-
-        dataLength = networkProtocol->createHeader((byte*)downBuffer, dataLength, DATA_STREAM_BUFFER_SIZE, static_cast<const Synchronizeable&>(*(*it)));
-
-        Header* header = (Header*)downBuffer;
-        if ( header->synchronizeableID < this->maxConnections+2 )
-        {
-          //if ( !isServer() ) PRINTF(0)("RESET UNIQUEID FROM %d TO 0 maxCon=%d\n", header->synchronizeableID, this->maxConnections);
-          header->synchronizeableID = 0;
-        }
-        else
-        {
-          //if ( !isServer() ) PRINTF(0)("UNIQUEID=%d\n", header->synchronizeableID);
-        }
-
-        if ( dataLength<=0 )
-          continue;
-
-        if ( reciever!=0 )
-        {
-          if ( reciever < 0)
-          {
-            for ( int i = 0; i<networkSockets.size(); i++)
-            {
-              if ( i!=abs(reciever) && networkSockets[i] != NULL )
-              {
-                PRINTF(0)("write %d bytes to socket %d uniqueid %d reciever %d\n", dataLength, i, (*it)->getUniqueID(), reciever);
-                networkSockets[i]->writePacket(downBuffer, dataLength);
-              }
-            }
-          }
-          else
-          {
-            if ( networkSockets[reciever] != NULL )
-            {
-              PRINTF(5)("write %d bytes to socket %d\n", dataLength, reciever);
-              networkSockets[reciever]->writePacket(downBuffer, dataLength);
-            }
-            else
-            {
-              PRINTF(1)("networkSockets[reciever] == NULL\n");
-            }
-          }
-        }
-        else
-        {
-          for ( int i = 0; i<networkSockets.size(); i++)
-          {
-            if ( networkSockets[i] != NULL )
-            {
-              PRINTF(5)("write %d bytes to socket %d\n", dataLength, i);
-              networkSockets[i]->writePacket(downBuffer, dataLength);
-            }
-          }
-        }
-
-      } while( reciever!=0 );
-    }
-  }
-
-  /* UPSTREAM */
-
-  for ( int i = 0; i<networkSockets.size(); i++)
-  {
-    if ( networkSockets[i] )
-    {
-      do {
-        dataLength = networkSockets[i]->readPacket(upBuffer, DATA_STREAM_BUFFER_SIZE);
-
-        if ( dataLength<=0 )
-          continue;
-
-        header = networkProtocol->extractHeader(upBuffer, dataLength);
-        dataLength -= sizeof(header);
-
-        PRINTF(5)("read %d bytes from socket uniqueID = %d\n", dataLength, header.synchronizeableID);
-
-        if ( dataLength != header.length )
-        {
-          PRINTF(1)("packetsize in header and real packetsize do not match! %d:%d\n", dataLength, header.length);
-          continue;
-        }
-
-        if ( header.synchronizeableID == 0 )
-        {
-          header.synchronizeableID = i;
-        }
-
-        for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
-        {
-          if ( *it && (*it)->getUniqueID()==header.synchronizeableID )
-          {
-            if ( (*it)->writeBytes(upBuffer+sizeof(header), dataLength, i) != header.length )
-            {
-              PRINTF(1)("%s did not read all the data id = %d!\n", (*it)->getClassName(), (*it)->getUniqueID());
-              break;
-            }
-            continue;
-          }
-        }
-
-      } while ( dataLength>0 );
-    }
-  }
-}
-
-void NetworkStream::updateConnectionList( )
-{
-  //check for new connections
-
-  NetworkSocket* tempNetworkSocket = serverSocket->getNewSocket();
-
-  if ( tempNetworkSocket )
-  {
-    int clientId;
-    if ( freeSocketSlots.size() >0 )
-    {
-      clientId = freeSocketSlots.back();
-      freeSocketSlots.pop_back();
-      networkSockets[clientId] = tempNetworkSocket;
-      handshakes[clientId] = new Handshake(true, clientId, this->networkGameManager->getUniqueID());
-      handshakes[clientId]->setUniqueID(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);
-    }
-
-    if ( clientId > this->maxConnections )
-    {
-      handshakes[clientId]->doReject();
-      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]);
-  }
-
-
-  //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]->destroy();
-      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();
+      
+        sync.handleRecvState( peer->second.userId, state, fromState );
       }
-      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());
+      
+      peer->second.connectionMonitor->processZippedIncomingPacket( compBuf, compLength, state, ackedState );
+      peer->second.connectionMonitor->processUnzippedIncomingPacket( buf, offset, state, ackedState );
+    
+      assert( peer->second.lastAckedState <= ackedState );
+      peer->second.lastAckedState = ackedState;
+      
+      assert( peer->second.lastRecvedState < state );
+      peer->second.lastRecvedState = state;
+      
+      assert( saveOffset == offset );
+      
+    }
+  
+  }
+  
+}
+
+/**
+ * is executed when a handshake has finished
+ * @todo create playable for new user
+ */
+void NetworkStream::handleNewClient( int userId )
+{
+  MessageManager::getInstance()->initUser( userId );
+  
+  networkGameManager->signalNewPlayer( userId );
+}
+
+/**
+ * removes old items from oldSynchronizeables
+ */
+void NetworkStream::cleanUpOldSyncList( )
+{
+  int now = SDL_GetTicks();
+  
+  for ( std::map<int,int>::iterator it = oldSynchronizeables.begin(); it != oldSynchronizeables.end();  )
+  {
+    if ( it->second < now - 10*1000 )
+    {
+      std::map<int,int>::iterator delIt = it;
+      it++;
+      oldSynchronizeables.erase( delIt );
+      continue;
+    }
+    it++;
+  }
+}
+
+/**
+ * writes data to DATA/dicts/newdict
+ * @param data pointer to data
+ * @param length length
+ */
+void NetworkStream::writeToNewDict( byte * data, int length )
+{
+  if ( remainingBytesToWriteToDict <= 0 )
     return;
-  }
-
-  if ( n > MAX_CONNECTIONS )
-  {
-    PRINTF(1)("Cannot set maxConnectiosn to %d because of hardcoded limit %d\n", n, MAX_CONNECTIONS);
+  
+  if ( length > remainingBytesToWriteToDict )
+    length = remainingBytesToWriteToDict;
+  
+  std::string fileName = ResourceManager::getInstance()->getDataDir();
+  fileName += "/dicts/newdict";
+  
+  FILE * f = fopen( fileName.c_str(), "a" );
+  
+  if ( !f )
+  {
+    PRINTF(2)("could not open %s\n", fileName.c_str());
+    remainingBytesToWriteToDict = 0;
     return;
   }
-
-  this->maxConnections = n;
-  this->networkGameManager->setUniqueID( n+2 );
-}
-
-
-
-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);
-
-  PRINT(0)(" Got %i connected Synchronizeables, showing active Syncs:\n", this->synchronizeables.size());
-  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
-  {
-    if( (*it)->beSynchronized() == true)
-      PRINT(0)("  Synchronizeable of class: %s::%s, with unique ID: %i, Synchronize: %i\n", (*it)->getClassName(), (*it)->getName(),
-               (*it)->getUniqueID(), (*it)->beSynchronized());
-  }
-  PRINT(0)(" Maximal Connections: %i\n", this->maxConnections);
-
-}
-
-
-int NetworkStream::getSyncCount()
-{
-  int n = 0;
-  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
-    if( (*it)->beSynchronized() == true)
-      ++n;
-
-  //return synchronizeables.size();
-  return n;
-}
-
-
-
-
-
-
+  
+  if ( fwrite( data, 1, length, f ) != length )
+  {
+    PRINTF(2)("could not write to file\n");
+    fclose( f );
+    return;
+  }
+  
+  fclose( f );
+  
+  remainingBytesToWriteToDict -= length;  
+}
+
+
+
+
+
+