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

Timestamp:

Jul 27, 2006, 10:44:28 AM (19 years ago)

Author:

bensch

Message:

merged the proxy back

File:

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

trunk/src/lib/network/network_stream.cc

@@ -65 +65 @@
   this->init();
   /* initialize the references */
-  this->pInfo->nodeType = NET_CLIENT;
+  this->pInfo->nodeType = NET_UNASSIGNED;
 }
 
@@ -79 +79 @@
     case NET_MASTER_SERVER:
       // init the shared network data
-      SharedNetworkData::getInstance()->setHostID(0);
-//       SharedNetworkData::getInstance()->setNodeType(NET_MASTER_SERVER);
+      SharedNetworkData::getInstance()->setHostID(NET_ID_MASTER_SERVER);
       break;
-
     case NET_PROXY_SERVER_ACTIVE:
       // init the shared network data
-      SharedNetworkData::getInstance()->setHostID(0);
-//       SharedNetworkData::getInstance()->setNodeType(NET_PROXY_SERVER_ACTIVE);
+      SharedNetworkData::getInstance()->setHostID(NET_ID_PROXY_SERVER_01);
       break;
     case NET_PROXY_SERVER_PASSIVE:
-            // init the shared network data
-      SharedNetworkData::getInstance()->setHostID(0);
-//       SharedNetworkData::getInstance()->setNodeType(NET_PROXY_SERVER_PASSIVE);
+      // init the shared network data
+      SharedNetworkData::getInstance()->setHostID(NET_ID_PROXY_SERVER_01);
       break;
     case NET_CLIENT:
-//       SharedNetworkData::getInstance()->setNodeType(NET_CLIENT);
+      SharedNetworkData::getInstance()->setHostID(NET_ID_UNASSIGNED);
       break;
   }
@@ -115 +111 @@
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_STREAM, "NetworkStream");
-  this->serverSocket = NULL;
+  this->clientSocket = NULL;
+  this->proxySocket = NULL;
   this->networkGameManager = NULL;
   this->networkMonitor = NULL;
@@ -124 +121 @@
   this->pInfo->lastRecvedState = 0;
 
+  this->bRedirect = false;
 
   this->currentState = 0;
@@ -142 +140 @@
 NetworkStream::~NetworkStream()
 {
-  if ( this->serverSocket )
-  {
-    serverSocket->close();
-    delete serverSocket;
-    serverSocket = NULL;
+  if ( this->clientSocket )
+  {
+    clientSocket->close();
+    delete clientSocket;
+    clientSocket = NULL;
+  }
+  if ( this->proxySocket)
+  {
+    proxySocket->close();
+    delete proxySocket;
+    proxySocket = NULL;
   }
   for ( PeerList::iterator i = peers.begin(); i!=peers.end(); i++)
@@ -187 +191 @@
 void NetworkStream::connectToMasterServer(std::string host, int port)
 {
-  int node = this->peers.size();
+  int node = NET_ID_MASTER_SERVER;
+  // this create the new node in the peers map
   this->peers[node].socket = new UdpSocket( host, port );
-  this->peers[node].userId = 0;
+  this->peers[node].userId = NET_ID_MASTER_SERVER;
 
   this->peers[node].nodeType = NET_MASTER_SERVER;
-  this->peers[node].connectionMonitor = new ConnectionMonitor( 0 );
+  this->peers[node].connectionMonitor = new ConnectionMonitor( NET_ID_MASTER_SERVER );
   this->peers[node].ip = this->peers[node].socket->getRemoteAddress();
 }
@@ -202 +207 @@
  * @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();
+void NetworkStream::connectToProxyServer(int proxyId, std::string host, int port)
+{
+  PRINTF(0)("connect to proxy %s, this is proxyId %i\n", host.c_str(), proxyId);
+
+  // this creates the new proxyId in the peers map
+  this->peers[proxyId].socket = new UdpSocket( host, port );
+  this->peers[proxyId].userId = proxyId;
+
+  this->peers[proxyId].nodeType = NET_PROXY_SERVER_ACTIVE;
+  this->peers[proxyId].connectionMonitor = new ConnectionMonitor( proxyId );
+  this->peers[proxyId].ip = this->peers[proxyId].socket->getRemoteAddress();
 }
 
@@ -218 +225 @@
  * @param port: interface port for all clients
  */
-void NetworkStream::createServer(int port)
-{
-  this->serverSocket = new UdpServerSocket(port);
+void NetworkStream::createServer(int clientPort, int proxyPort)
+{
+  PRINTF(0)(" Creating new Server: listening for clients on port %i and for proxies on port %i", clientPort, proxyPort);
+  this->clientSocket= new UdpServerSocket(clientPort);
+  this->proxySocket = new UdpServerSocket(proxyPort);
 }
 
@@ -240 +249 @@
  * handsakes are always initialized from the client side first. this starts the handshake and therefore is only
  * executed as client
- */
-void NetworkStream::startHandshake()
+ * @param userId: start handshake for this user id (optional, default == 0)
+ */
+void NetworkStream::startHandshake(int userId)
 {
   Handshake* hs = new Handshake(this->pInfo->nodeType);
-  hs->setUniqueID( 0 );
-  assert( peers[0].handshake == NULL );
-  peers[0].handshake = hs;
+  // fake the unique id
+  hs->setUniqueID( NET_UID_HANDSHAKE );
+  assert( peers[userId].handshake == NULL );
+  peers[userId].handshake = hs;
 
   // set the preferred nick name
@@ -259 +270 @@
  * it all over the network and creating it on the other platforms (if and only if it is a
  * server
+ * @param sync: the synchronizeable to add
  */
 void NetworkStream::connectSynchronizeable(Synchronizeable& sync)
@@ -264 +276 @@
   this->synchronizeables.push_back(&sync);
   sync.setNetworkStream( this );
-
-//   this->bActive = true;
 }
 
@@ -271 +281 @@
 /**
  * removes the synchronizeable from the list of synchronized entities
+ * @param sync: the syncronizeable to remove
  */
 void NetworkStream::disconnectSynchronizeable(Synchronizeable& sync)
@@ -302 +313 @@
   }
 
-  if ( this->pInfo->isMasterServer())
+  if ( SharedNetworkData::getInstance()->isMasterServer())
   {
     // execute everytthing the master server shoudl do
-    if ( serverSocket )
-      serverSocket->update();
+    if ( this->clientSocket )
+      this->clientSocket->update();
+    if( this->proxySocket)
+      this->proxySocket->update();
 
     this->updateConnectionList();
   }
-  else if( this->pInfo->isProxyServer())
-  {
-    // execute everything the proxy server should do
-    if ( serverSocket )
-      serverSocket->update();
+  else if( SharedNetworkData::getInstance()->isProxyServerActive())
+  {
+    //execute everything the proxy server should do
+    if ( this->clientSocket )
+      this->clientSocket->update();
+    if( this->proxySocket)
+      this->proxySocket->update();
 
     this->updateConnectionList();
   }
-  else
+
+#warning make this more modular: every proxy/master server connection should be watched for termination
+  if( !SharedNetworkData::getInstance()->isMasterServer())
   {
     // check if the connection is ok else terminate and remove
-    if ( peers[0].socket && ( !peers[0].socket->isOk() || peers[0].connectionMonitor->hasTimedOut() ) )
-    {
+    if ( !peers.empty() && peers[NET_ID_MASTER_SERVER].socket &&
+          ( !peers[NET_ID_MASTER_SERVER].socket->isOk() ||
+          peers[NET_ID_MASTER_SERVER].connectionMonitor->hasTimedOut() ) )
+    {
+      this->handleDisconnect( NET_ID_MASTER_SERVER);
       PRINTF(1)("lost connection to server\n");
-
-      peers[0].socket->disconnectServer();
-      delete peers[0].socket;
-      peers[0].socket = NULL;
-
-      if ( peers[0].handshake )
-        delete peers[0].handshake;
-      peers[0].handshake = NULL;
-
-      if ( peers[0].connectionMonitor )
-        delete peers[0].connectionMonitor;
-      peers[0].connectionMonitor = NULL;
-    }
-  }
-
-  cleanUpOldSyncList();
-  handleHandshakes();
+    }
+    // check if there is a redirection command
+    if( this->bRedirect)
+    {
+      this->handleReconnect( NET_ID_MASTER_SERVER);
+    }
+  }
+
+  this->cleanUpOldSyncList();
+  this->handleHandshakes();
 
   // update the network monitor
@@ -347 +360 @@
   // order of up/downstream is important!!!!
   // don't change it
-  handleDownstream( tick );
-  handleUpstream( tick );
-}
-
-
-/**
- * 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
+  this->handleDownstream( tick );
+  this->handleUpstream( tick );
+}
+
+
+/**
+ * @brief handles incoming connections
+ *
+ * if we are a NET_MASTER_SERVER or NET_PROXY_SERVER_ACTIVE update the connection list to accept new connections (clients)
+ * start and initialize the handsake for the new clients
  */
 void NetworkStream::updateConnectionList( )
@@ -360 +375 @@
   //check for new connections
 
-  NetworkSocket* tempNetworkSocket = serverSocket->getNewSocket();
-
-  // we got new network node
-  if ( tempNetworkSocket )
-  {
-    int clientId;
-    // if there is a list of free client id slots, take these
-    if ( freeSocketSlots.size() > 0 )
-    {
-      clientId = freeSocketSlots.back();
-      freeSocketSlots.pop_back();
-    }
-    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;
-
-
-    // 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);
-
-
-  }
-
+  NetworkSocket* tempNetworkSocket = NULL;
+  int userId;
+
+  if( this->clientSocket != NULL)
+  {
+    tempNetworkSocket = this->clientSocket->getNewSocket();
+
+    // we got new NET_CLIENT connecting
+    if ( tempNetworkSocket )
+    {
+      // determine the network node id
+      if ( freeSocketSlots.size() > 0 )
+      {
+        userId = freeSocketSlots.back();
+        freeSocketSlots.pop_back();
+      }
+      else
+      {
+        userId = 1;
+
+        for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+          if ( it->first >= userId )
+            userId = it->first + 1;
+      }
+      // this creates a new entry in the peers list
+      peers[userId].socket = tempNetworkSocket;
+      peers[userId].nodeType = NET_CLIENT;
+
+      // handle the newly connected client
+      this->handleConnect(userId);
+
+      PRINTF(0)("New Client: %d\n", userId);
+    }
+  }
+
+
+  if( this->proxySocket != NULL)
+  {
+    tempNetworkSocket = this->proxySocket->getNewSocket();
+
+    // we got new NET_PROXY_SERVER_ACTIVE connecting
+    if ( tempNetworkSocket )
+    {
+      // determine the network node id
+      if ( freeSocketSlots.size() > 0 )
+      {
+        userId = freeSocketSlots.back();
+        freeSocketSlots.pop_back();
+      }
+      else
+      {
+        userId = 1;
+
+        for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+          if ( it->first >= userId )
+            userId = it->first + 1;
+      }
+
+      // this creates a new entry in the peers list
+      peers[userId].socket = tempNetworkSocket;
+      peers[userId].nodeType = NET_PROXY_SERVER_ACTIVE;
+
+      // handle the newly connected proxy server
+      this->handleConnect(userId);
+
+      PRINTF(0)("New proxy connected: %d\n", userId);
+    }
+  }
 
 
@@ -446 +461 @@
       PRINTF(0)("Client is gone: %d (%s)\n", it->second.userId, reason.c_str());
 
-
-      // clean up the network data
-      it->second.socket->disconnectServer();
-      delete it->second.socket;
-      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++ )
-      {
-        (*it2)->cleanUpUser( it->second.userId );
-      }
-
-      NetworkGameManager::getInstance()->signalLeftPlayer(it->second.userId);
-
-      freeSocketSlots.push_back( it->second.userId );
-
-      PeerList::iterator delit = it;
+      this->handleDisconnect( it->second.userId);
+
       it++;
-
-      peers.erase( delit );
-
       continue;
     }
@@ -487 +474 @@
 
 
+/**
+ * this handles new connections
+ * @param userId: the id of the new user node
+ */
+void NetworkStream::handleConnect( int userId)
+{
+  // create new handshake and init its variables
+  peers[userId].handshake = new Handshake(this->pInfo->nodeType, userId, this->networkGameManager->getUniqueID(), MessageManager::getInstance()->getUniqueID());
+  peers[userId].handshake->setUniqueID(userId);
+
+  peers[userId].connectionMonitor = new ConnectionMonitor( userId );
+  peers[userId].userId = userId;
+
+  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[userId].handshake->setProxy1Address( pi->ip);
+  }
+  pi = this->networkMonitor->getSecondChoiceProxy();
+  if( pi != NULL)
+    peers[userId].handshake->setProxy2Address( pi->ip);
+
+  // check if the connecting client should reconnect to a proxy server
+  if( SharedNetworkData::getInstance()->isMasterServer())
+    peers[userId].handshake->setRedirect(/*this->networkMonitor->isReconnectNextClient()*/false);
+
+  // the connecting node of course is a client
+  peers[userId].ip = peers[userId].socket->getRemoteAddress();
+}
+
+
+
+/**
+ * some debug output
+ */
 void NetworkStream::debug()
 {
@@ -492 +518 @@
     PRINT(0)(" Host ist Master Server with ID: %i\n", this->pInfo->userId);
   }
-  else if( SharedNetworkData::getInstance()->isProxyServer()) {
+  else if( SharedNetworkData::getInstance()->isProxyServerActive()) {
     PRINT(0)(" Host ist Proxy Server with ID: %i\n", this->pInfo->userId);
   }
@@ -541 +567 @@
         if ( it->second.handshake->ok() )
         {
-          // the server gave it free for deletion
+          // write the first informations into the node so they can be read from there for case differentiation
+          it->second.nodeType = it->second.handshake->getRemoteNodeType();
+
+          // the counter part didn't mark it free for deletion yet
           if ( !it->second.handshake->allowDel() )
           {
-
-            if ( this->pInfo->isClient() )
+            // make sure this is a connection:
+            // - client       <==> master server
+            // - proxy server <==> master server
+            if(  SharedNetworkData::getInstance()->isClient() || SharedNetworkData::getInstance()->isProxyServerActive() && it->second.isMasterServer())
             {
+              PRINTF(0)("Handshake: i am in client role\n");
+
               SharedNetworkData::getInstance()->setHostID( it->second.handshake->getHostId() );
               this->pInfo->userId = SharedNetworkData::getInstance()->getHostID();
 
-              it->second.nodeType = it->second.handshake->getRemoteNodeType();
-              it->second.ip = it->second.socket->getRemoteAddress();
+#warning the ip address is not set here because it results in a segfault when connecting to a proxy server => trace this later
+//               it->second.ip = it->second.socket->getRemoteAddress();
+
+              // 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);
@@ -560 +596 @@
 
               // now check if the server accepted the connection
-              if( it->second.handshake->redirect())
-                this->handleReconnect( it->second.userId);
+              if( SharedNetworkData::getInstance()->isClient() && it->second.handshake->redirect() )
+              {
+                this->bRedirect = true;
+              }
 
               // create the new network game manager and init it
@@ -570 +608 @@
             }
 
-
             PRINT(0)("handshake finished id=%d\n", it->second.handshake->getNetworkGameManagerId());
             it->second.handshake->del();
+
           }
           else
@@ -580 +618 @@
             {
 
-              if ( this->pInfo->isMasterServer() )
+              if (  SharedNetworkData::getInstance()->isMasterServer() )
               {
-                it->second.nodeType = it->second.handshake->getRemoteNodeType();
                 it->second.ip = it->second.socket->getRemoteAddress();
 
@@ -594 +631 @@
                 }
               }
-              else if ( this->pInfo->isProxyServer() )
+              else if ( SharedNetworkData::getInstance()->isProxyServerActive() && it->second.isClient() )
               {
-                it->second.nodeType = it->second.handshake->getRemoteNodeType();
+                PRINTF(0)("Handshake: i am in server role\n");
+
                 it->second.ip = it->second.socket->getRemoteAddress();
 
@@ -632 +670 @@
 void NetworkStream::handleReconnect(int userId)
 {
+  this->bRedirect = false;
+  PeerInfo* pInfo = &this->peers[userId];
+
   PRINTF(0)("===============================================\n");
   PRINTF(0)("Client is redirected to the other proxy servers\n");
+  PRINTF(0)("  user id: %i\n", userId);
+  PRINTF(0)("  connecting to: %s\n", this->networkMonitor->getFirstChoiceProxy()->ip.ipString().c_str());
   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;
+
+  // temp save the ip address here
+  IP proxyIP = pInfo->handshake->getProxy1Address();
 
   // disconnect from the current server and reconnect to proxy server
-  pInfo->socket->reconnectToServer( pInfo->handshake->getProxy1Address().ipString(), pInfo->handshake->getProxy1Address().port());
+  this->handleDisconnect( userId);
+  this->connectToProxyServer(NET_ID_PROXY_SERVER_01, proxyIP.ipString(), 9999);
+  #warning the ports are not yet integrated correctly in the ip class
 
   // and restart the handshake
-  this->startHandshake();
-}
+  this->startHandshake( userId);
+}
+
+
+/**
+ * handles the disconnect event
+ * @param userId id of the user to remove
+ */
+void NetworkStream::handleDisconnect( int userId )
+{
+  peers[userId].socket->disconnectServer();
+  delete peers[userId].socket;
+  peers[userId].socket = NULL;
+
+  if ( peers[userId].handshake )
+    delete peers[userId].handshake;
+  peers[userId].handshake = NULL;
+
+  if ( peers[userId].connectionMonitor )
+    delete peers[userId].connectionMonitor;
+  peers[userId].connectionMonitor = NULL;
+
+
+  for ( SynchronizeableList::iterator it2 = synchronizeables.begin(); it2 != synchronizeables.end(); it2++ )  {
+    (*it2)->cleanUpUser( userId );
+  }
+
+  if( SharedNetworkData::getInstance()->isMasterServer())
+    NetworkGameManager::getInstance()->signalLeftPlayer(userId);
+
+  this->freeSocketSlots.push_back( userId );
+
+  peers.erase( userId);
+}
+
 
 
 /**
  * handle upstream network traffic
+ * @param tick: seconds elapsed since last update
  */
 void NetworkStream::handleUpstream( int tick )
@@ -698 +770 @@
 
       // do not include synchronizeables with uninit id and syncs that don't want to be synchronized
-      if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
+      if ( !sync.beSynchronized() || sync.getUniqueID() <= NET_UID_UNASSIGNED )
         continue;
 
@@ -706 +778 @@
 
       // 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 )
+      if ( ( SharedNetworkData::getInstance()->isMasterServer() ||
+             SharedNetworkData::getInstance()->isProxyServerActive() &&  peer->second.isClient())
+             && sync.getLeafClassID() == CL_HANDSHAKE && sync.getUniqueID() != peer->second.userId )
         continue;
 
@@ -720 +794 @@
 
       // server fakes uniqueid == 0 for handshake
-      if ( ( SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer() ) &&
+      if ( ( SharedNetworkData::getInstance()->isMasterServer() ||
+             SharedNetworkData::getInstance()->isProxyServerActive() &&  peer->second.isClient() ) &&
              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 );
@@ -760 +835 @@
       Synchronizeable & sync = **it;
 
-      if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
+      // again exclude all unwanted syncs
+      if ( !sync.beSynchronized() || sync.getUniqueID() <= NET_UID_UNASSIGNED)
         continue;
 
@@ -771 +847 @@
     // now compress the data with the zip library
     int compLength = 0;
-    if ( SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer())
+    if ( SharedNetworkData::getInstance()->isMasterServer() ||
+         SharedNetworkData::getInstance()->isProxyServerActive())
       compLength = Zip::getInstance()->zip( buf, offset, compBuf, UDP_PACKET_SIZE, dictServer );
     else
@@ -888 +965 @@
           }
 
-          // 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() )
+          // if the node we got this unknown sync we ignore it if:
+          //  - the remote host is a client
+          //  - the remote host is a proxy server and we are master server
+          // (since it has no rights to create a new sync)
+          if ( peers[peer->second.userId].isClient() ||
+               (peers[peer->second.userId].isProxyServerActive() && SharedNetworkData::getInstance()->isMasterServer()))
           {
             offset += syncDataLength;
@@ -960 +1041 @@
         Synchronizeable & sync = **it;
 
-        if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
+        if ( !sync.beSynchronized() || sync.getUniqueID() <= NET_UID_UNASSIGNED )
           continue;