Changeset 9406 for trunk/src/lib/network – Orxonox

trunk/src/lib/network/Makefile.am

-                      r8623
+                      r9406
                       shared_network_data.cc \
                       network_socket.cc \
-                      connection_monitor.cc \
                       network_stream.cc \
                       data_stream.cc \
 …
                       network_game_manager.cc \
                       converter.cc \
+                      peer_info.cc \
                       message_manager.cc \
                       network_log.cc \
 …
                       player_stats.cc \
                       udp_broadcast.cc \
+                      \
+                      proxy/network_settings.cc \
+                      \
+                                  monitor/connection_monitor.cc \
+                      monitor/network_monitor.cc \
+                      monitor/network_node.cc \
+                      \
                       synchronizeable_var/synchronizeable_var.cc \
 …
                       synchronizeable_var/synchronizeable_float.cc \
                       synchronizeable_var/synchronizeable_bool.cc \
+                      synchronizeable_var/synchronizeable_uint.cc
+                      synchronizeable_var/synchronizeable_uint.cc \
+                      synchronizeable_var/synchronizeable_ip.cc \
+                      \
+                      ip.cc
+noinst_HEADERS = synchronizeable.h \
+                 network_manager.h \
+                 shared_network_data.h \
+                 network_socket.h \
+                 connection_monitor.h \
+                 network_stream.h \
+                 data_stream.h \
+                 network_protocol.h \
+                 server_socket.h \
+                 tcp_server_socket.h \
+                 tcp_socket.h \
+                 udp_server_socket.h \
+                 udp_socket.h \
+                 handshake.h \
+                 network_game_manager.h \
+                 converter.h \
+                 netdefs.h \
+                 message_manager.h \
+                 network_log.h \
+                 zip.h \
+                 player_stats.h \
+                 udp_broadcast.h \
+                 \
+                 synchronizeable_var/synchronizeable_var.h \
+                 synchronizeable_var/synchronizeable_vector.h \
+                 synchronizeable_var/synchronizeable_int.h \
+                 synchronizeable_var/synchronizeable_quaternion.h \
+                 synchronizeable_var/synchronizeable_string.h \
+                 synchronizeable_var/synchronizeable_float.h \
+                 synchronizeable_var/synchronizeable_bool.h \
+                 synchronizeable_var/synchronizeable_uint.h
+noinst_HEADERS = \
+                netdefs.h \
+                nettypes.h \
+                netincl.h \
+                \
+                synchronizeable.h \
+                network_manager.h \
+                shared_network_data.h \
+                network_socket.h \
+                network_stream.h \
+                data_stream.h \
+                network_protocol.h \
+                server_socket.h \
+                tcp_server_socket.h \
+                tcp_socket.h \
+                udp_server_socket.h \
+                udp_socket.h \
+                handshake.h \
+                network_game_manager.h \
+                converter.h \
+                peer_info.h \
+                netdefs.h \
+                message_manager.h \
+                network_log.h \
+                zip.h \
+                player_stats.h \
+                udp_broadcast.h \
+                \
+                proxy/network_settings.cc \
+                \
+                monitor/connection_monitor.h \
+                monitor/network_monitor.h \
+                monitor/network_node.h \
+                \
+                synchronizeable_var/synchronizeable_var.h \
+                synchronizeable_var/synchronizeable_vector.h \
+                synchronizeable_var/synchronizeable_int.h \
+                synchronizeable_var/synchronizeable_quaternion.h \
+                synchronizeable_var/synchronizeable_string.h \
+                synchronizeable_var/synchronizeable_float.h \
+                synchronizeable_var/synchronizeable_bool.h \
+                synchronizeable_var/synchronizeable_uint.h \
+                synchronizeable_var/synchronizeable_ip.h \
+                \
+                ip.h

trunk/src/lib/network/converter.cc

-                      r8362
+                      r9406
 ### File Specific:
    main-programmer: Benjamin Wuest
    co-programmer: ...
+   main-programmer: Benjamin Wuest (bwuest@ee.ethz.ch)
+   co-programmer: Christoph Renner (rennerc@ee.ethz.ch)
 */
 …
 /* using namespace std is default, this needs to be here */
+using namespace std;
 /*!
 …
+{
   /* set the class id for the base object */
-  //this->setClassID(CL_ENTITY_MANAGER, "EntityManager");
+}

trunk/src/lib/network/data_stream.cc

r8623	r9406
19	19
20	20	/* using namespace std is default, this needs to be here */
21		using namespace std;
	21
22	22
23	23

trunk/src/lib/network/handshake.cc

-                      r9235
+                      r9406
 ### File Specific:
    main-programmer: christoph
    co-programmer:
+   main-programmer: Christoph Renner (rennerc@ee.ethz.ch)
+   co-programmer: Patirck Boenzli (boenzlip@orxonox.ethz.ch)
 */
-/* this is for debug output. It just says, that all calls to PRINT() belong to the DEBUG_MODULE_NETWORK module
-   For more information refere to https://www.orxonox.net/cgi-bin/trac.cgi/wiki/DebugOutput
-*/
 #define DEBUG_MODULE_NETWORK
 …
 #include "debug.h"
+Handshake::Handshake( bool server, int clientId, int networkGameManagerId, int messageManagerId )
+ Handshake::Handshake( int nodeType, int clientId, int networkGameManagerId, int messageManagerId )
   : Synchronizeable()
+{
 …
   this->setClassID(CL_HANDSHAKE, "Handshake");
-  this->setIsServer(server);
+  // register all variable handlers
   orxId_handler = registerVarId( new SynchronizeableInt( &localState.orxId, &remoteState.orxId, "orxonoxId", PERMISSION_ALL ) );
   version_handler = registerVarId( new SynchronizeableInt( &localState.version, &remoteState.version, "version", PERMISSION_ALL ) );
 …
   errorString_handler = registerVarId( new SynchronizeableString( &localState.errorString, &remoteState.errorString, "errorString", PERMISSION_ALL ) );
+  this->nodeTypeHandler = registerVarId( new SynchronizeableInt( &localState.nodeType, &remoteState.nodeType, "nodeType", PERMISSION_ALL ) );
   candel_id = registerVarId( new SynchronizeableInt( &localState.canDel, &remoteState.canDel, "canDel", PERMISSION_ALL ) );
   registerVar( new SynchronizeableString( &localState.preferedNickName, &remoteState.preferedNickName, "preferedNickName", PERMISSION_ALL ) );
+  // now synchronize only two of the available proxy server addresses
+  registerVar( new SynchronizeableIP( &this->proxy1, &this->proxy1, "proxy server 1", PERMISSION_MASTER_SERVER ) );
+  registerVar( new SynchronizeableIP( &this->proxy2, &this->proxy2, "proxy server 2", PERMISSION_MASTER_SERVER ) );
+  registerVar( new SynchronizeableInt( &this->redirectProxy, &this->redirectProxy, "proxy server redirection flag", PERMISSION_MASTER_SERVER ) );
+  // init the local state
   localState.completed = 0;
   localState.error = 0;
 …
   localState.orxId = _ORXONOX_ID;
   localState.version = _ORXONOX_VERSION;
+  localState.nodeType = nodeType;
   localState.canDel = 0;
+  // init the remote state
   remoteState.completed = 0;
   remoteState.error = 0;
 …
   remoteState.orxId = 0;
   remoteState.version = 0;
+  remoteState.nodeType = NET_CLIENT;
   remoteState.canDel = 0;
+  this->proxy1 = IP(0, 0);
+  this->proxy2 = IP(0, 0);
+  this->redirectProxy = 0;
+  // activate the synchronization process
   this->setSynchronized(true);
   PRINTF(0)("Handshake created clientId = %d\n", clientId);
+}
 /**
 …
   for ( std::list<int>::iterator it = id.begin(); it != id.end(); it++ )
+  {
+    if ( *it == orxId_handler )
+    // orxonox id handler
+    if ( *it == this->orxId_handler )
+    {
       if ( remoteState.orxId != _ORXONOX_ID )
 …
         continue;
+      }
+    }
+    if ( *it == version_handler )
+    // orxonox version handler
+    if ( *it == this->version_handler )
+    {
       if ( remoteState.version != _ORXONOX_VERSION )
 …
         continue;
+      }
+    }
+    // node type handler: for each node type there is a specific action to be taken
+    if ( *it == this->nodeTypeHandler)
+    {
+      if ( remoteState.nodeType == NET_MASTER_SERVER )
+      {
+        continue;
+      }
+      else if( remoteState.nodeType == NET_PROXY_SERVER_ACTIVE)
+      {
+        continue;
+      }
+      else if( remoteState.nodeType == NET_CLIENT)
+      {
+        continue;
+      }
+    }
+    // cancel
     if ( *it == candel_id )
+    {
       PRINTF(0)("handshake finished candel changed\n");
+    }
+  }
   if (
       remoteState.orxId == _ORXONOX_ID &&
       remoteState.version == _ORXONOX_VERSION
+     )
+  // handshake completed
+  if ( remoteState.orxId == _ORXONOX_ID &&
+       remoteState.version == _ORXONOX_VERSION )
+  {
     localState.completed = 1;
+  }
+}

trunk/src/lib/network/handshake.h

-                      r9235
+                      r9406
 /*!
  * @file network_stream.h
+ *  implementation of a network pipe
+ *  implementation of a network pipe. This node handles the handshake of two network nodes and exchanges informationas
+ * vial to the connection setup.
+ *
+ * the local node only writes in the localState variable. the remoteState variable will be written from the remote network node
+ * so don't write into it!
  */
 …
 #include "base_object.h"
+#include "ip.h"
 #include "synchronizeable.h"
+#include "shared_network_data.h"
+#define _ORXONOX_ID 0xF91337A0
+//!< a struct to save the handshakes to
+struct HandshakeState
+{
+  int           orxId;                         //!< orxonox id
+  int           version;                       //!< network protocol version
+#define _ORXONOX_VERSION 1
+  int           networkManagerId;              //!< unique id of the network manager
+  int           messageManagerId;              //!< unique id of the message manager
+  int           hostId;                        //!< host id
+  int           nodeType;                      //!< type of the network node
+struct HandshakeState {
+  int orxId;
+  int version;
+  int networkManagerId;
+  int messageManagerId;
+  int hostId;
+  int completed;
+  int canDel;
+  int error;
+  std::string errorString;
+  int           completed;                     //!< true if completed
+  int           canDel;                        //!< true if marked for deletion
+  int           error;                         //!< error number
+  std::string   errorString;                   //!< error string
   //additional data
   std::string preferedNickName;
+  std::string   preferedNickName;              //!< prefered nick name
 };
+//!< the handshake itself with some interface functions
 class Handshake : public Synchronizeable
+{
   public:
+    Handshake( bool server, int clientId = 0, int networkGameManagerId = 0, int messageManagerId = 0 );
+    inline bool       completed(){ return localState.completed != 0 && remoteState.completed != 0; }
+    inline bool       ok(){ return localState.error == 0 && remoteState.error == 0; }
+    inline int        getHostId(){ return remoteState.hostId; }
+    inline int        getNetworkGameManagerId(){ return remoteState.networkManagerId; }
+    inline int        getMessageManagerId(){ return remoteState.messageManagerId; }
+    inline void       doReject( std::string reason ){ localState.error = 1; localState.errorString = "the server rejected your connection ["+ reason +"]"; }
+    inline bool       canDel(){ return localState.canDel == 1 && remoteState.canDel == 1; }
+    inline bool       allowDel(){ return localState.canDel == 1; }
+    inline void       del(){ localState.canDel = 1; }
+    inline void       setPreferedNickName( const std::string & nick ){ localState.preferedNickName = nick; }
+    Handshake( int nodeType, int clientId = 0, int networkGameManagerId = 0, int messageManagerId = 0 );
+    /* functions indicating states of the handshake */
+    /** @returns true if the handshake is completed */
+    inline bool completed(){ return localState.completed != 0 && remoteState.completed != 0; }
+    /** @returns true if no error has occured until now */
+    inline bool ok(){ return localState.error == 0 && remoteState.error == 0; }
+    /** stops the handshake and reject the other side with @param reason: string describing the reason */
+    inline void doReject( std::string reason ){ localState.error = 1; localState.errorString = "the server rejected your connection ["+ reason +"]"; }
+    /** @returns true if the handshake is finished and the instances can be deleted */
+    inline bool canDel(){ return localState.canDel == 1 && remoteState.canDel == 1; }
+    /** @returns true if the local state can be removed*/
+    inline bool allowDel(){ return localState.canDel == 1; }
+    /** marks the handshake to be deleted */
+    inline void del(){ localState.canDel = 1; }
+    /* the actual informations exchanged in the handshake */
+    /** @returns the host id of the remote host */
+    inline int  getHostId(){ return remoteState.hostId; }
+    /** @returns the unique id of the network game manager*/
+    inline int  getNetworkGameManagerId(){ return remoteState.networkManagerId; }
+    /** @returns the unique id of the message manager */
+    inline int  getMessageManagerId(){ return remoteState.messageManagerId; }
+    /** @returns the node type of the remote host */
+    inline int getRemoteNodeType() { return this->remoteState.nodeType; }
+    /** sets @param nick the prefereded nick name */
+    inline void setPreferedNickName( const std::string & nick ){ localState.preferedNickName = nick; }
+    /** @returns the prefered nick name */
     inline std::string getPreferedNickName(){ return remoteState.preferedNickName; }
+    /** @returns if true the local client should reconnect to a proxy server from the proxy server list */
+    inline bool redirect() { return this->redirectProxy;}
+    /** @param flag: indicating if the client should be redirected */
+    inline void setRedirect(bool flag) { if( SharedNetworkData::getInstance()->isClient()) return; this->redirectProxy = (int)flag; }
+    /** @param address: the address of the proxy server 1 if any */
+    inline void setProxy1Address(IP address) { if( SharedNetworkData::getInstance()->isClient()) return; this->proxy1 = address; }
+    /** @returns the address of the proxy server 1 if any */
+    inline IP getProxy1Address() { return this->proxy1; }
+    /** @param address: the address of the proxy server 2 if any */
+    inline void setProxy2Address(IP address) { if( SharedNetworkData::getInstance()->isClient()) return; this->proxy2 = address; }
+    /** @returns the address of the proxy server 2 if any */
+    inline IP getProxy2Address() { return this->proxy2; }
+    /* variable handler function */
     virtual void varChangeHandler( std::list<int> & id );
   private:
+    HandshakeState localState;
+    HandshakeState remoteState;
+    int netManId_handler;
+    int msgManId_handler;
+    int hostId_handler;
+    int completed_handler;
+    int error_handler;
+    int errorString_handler;
+    int orxId_handler;
+    int version_handler;
+    int candel_id;
+    HandshakeState     localState;                            //!< the local handshake state
+    HandshakeState     remoteState;                           //!< the remote handshake state
+    int                orxId_handler;                         //!< orxonox id handler
+    int                version_handler;                       //!< orxonox version id handler
+    int                netManId_handler;                      //!< network manager handler
+    int                msgManId_handler;                      //!< message manager handler
+    int                hostId_handler;                        //!< host id handler
+    int                nodeTypeHandler;                       //!< node type handler
+    int                proxy1Handler;                         //!< handler for the proxy
+    int                proxy2Handler;                         //!< handler for the proxy
+    int                completed_handler;                     //!< handshake completion handler
+    int                error_handler;                         //!< handshake error handler
+    int                errorString_handler;                   //!< handshake error string handler
+    int                candel_id;                             //!< handshake deletion handler
+    int                nodeType;                              //!, the type of the network node
+    int                redirectProxy;                         //!< true if the client should reconnect to a proxy server
+    IP                 proxy1;                               //!< ip address of the first proxy (0.0.0.0 of not available)
+    IP                 proxy2;                               //!< ip address of the second proxy (0.0.0.0 of not available)
 };

trunk/src/lib/network/message_manager.cc

-                      r9059
+                      r9406
 #include "network_stream.h"
 #include "shared_network_data.h"
+using namespace std;
+#include "converter.h"
+#include <cassert>
 MessageManager* MessageManager::singletonRef = NULL;
 …
+      }
+    }
     it->second.messages.clear();
     it->second.toAck.clear();
+  }
   messageQueue.clear();
   this->messageHandlerMap.clear();
   MessageManager::singletonRef = NULL;
+}
 …
   int i = 0;
   int n;
   n = Converter::intToByteArray( messageQueue[userId].toAck.size(), data + i, maxLength );
   i += n;
   assert( n == INTSIZE );
   for ( std::list<int>::iterator it = messageQueue[userId].toAck.begin(); it != messageQueue[userId].toAck.end(); it++)
+  {
 …
     assert( n == INTSIZE );
+  }
   messageQueue[userId].toAck.clear();
   n = Converter::intToByteArray( messageQueue[userId].messages.size(), data + i, maxLength );
   i += n;
   assert( n == INTSIZE );
   for ( std::list<NetworkMessage>::iterator it = messageQueue[userId].messages.begin(); it != messageQueue[userId].messages.end(); it++ )
+  {
 …
     i += n;
     assert( n == INTSIZE );
     n = Converter::intToByteArray( it->number, data + i, maxLength );
     i += n;
     assert( n == INTSIZE );
     n = Converter::intToByteArray( it->messageId, data + i, maxLength );
     i += n;
     assert( n == INTSIZE );
     assert( i + it->length <= maxLength );
     memcpy( data + i, it->data, it->length );
     i += it->length;
+  }
   return i;
+}
 …
   int i = 0;
   int n;
   int nAcks;
   assert( i + INTSIZE <= length );
   n = Converter::byteArrayToInt( data + i, &nAcks );
   assert( n == INTSIZE );
   i += n;
   std::list<int> acks;
   int number;
   for ( int j = 0; j < nAcks; j++ )
+  {
 …
     assert( n == INTSIZE );
     i += n;
     acks.push_back( number );
+  }
   int nMessages;
   assert( i + INTSIZE <= length );
   n = Converter::byteArrayToInt( data + i, &nMessages );
 …
   int messageLength, messageId;
   for ( int j = 0; j < nMessages; j++ )
+  {
 …
     assert( n == INTSIZE );
     i += n;
     assert( i + INTSIZE <= length );
     n = Converter::byteArrayToInt( data + i, &number );
     assert( n == INTSIZE );
     i += n;
     assert( i + INTSIZE <= length );
     n = Converter::byteArrayToInt( data + i, &messageId );
     assert( n == INTSIZE );
     i += n;
     if ( number > 0 )
       messageQueue[userId].toAck.push_back( number );
     assert( i + messageLength <= length );
     assert( messageHandlerMap.find( (MessageId)messageId ) != messageHandlerMap.end() );
 …
+      {
         NetworkMessage msg;
         msg.data = new byte[messageLength];
         memcpy( msg.data, data + i, messageLength );
 …
         msg.messageId = (MessageId)messageId;
         msg.number = userId;
         incomingMessageBuffer.push_back( msg );
+      }
 …
     i += messageLength;
+  }
   //TODO maybe handle incomingMessage in tick function. else local messages will not be handled if no clients are connected
   for ( std::list<NetworkMessage>::iterator it = incomingMessageBuffer.begin(); it != incomingMessageBuffer.end();  )
 …
     it++;
+  }
   //walk throu message queue and remove acked messages
   for ( std::list<NetworkMessage>::iterator it = messageQueue[userId].messages.begin(); it != messageQueue[userId].messages.end();  )
 …
     it++;
+  }
   //TODO find bether way. maybe with timestamp
   if ( messageQueue[userId].recievedMessages.size() > 1000 )
 …
   if ( messageQueue.find( userId ) == messageQueue.end() )
     return;
   for ( std::list<NetworkMessage>::iterator it = messageQueue[userId].messages.begin(); it != messageQueue[userId].messages.end(); it++ )
+  {
 …
     it->data = NULL;
+  }
   messageQueue[userId].toAck.clear();
   messageQueue.erase( userId );
+}
 …
 /**
  * registers function to handle messages with id messageId. someData is passed to callbackfuntion
  * @param messageId message id to handle
+ * @param messageId message id to handle
  * @param cb function pointer to callback function
  * @param someData this pointer is passed to callback function without modification
 …
+{
   MessageHandler messageHandler;
   messageHandler.cb = cb;
   messageHandler.messageId = messageId;
   messageHandler.someData = someData;
   messageHandlerMap[messageId] = messageHandler;
   return true;
+}
 …
  * @param data pointer to data
  * @param dataLength length of data
  * @param recieverType
  * @param reciever
+ * @param recieverType
+ * @param reciever
  */
 void MessageManager::sendMessage( MessageId messageId, byte * data, int dataLength, RecieverType recieverType, int reciever, MessagePriority messagePriority )
 …
   for ( MessageQueue::iterator it = messageQueue.begin(); it != messageQueue.end(); it++ )
+  {
     if (
+    if (
          recieverType == RT_ALL_ME ||
          recieverType == RT_ALL_NOT_ME ||
          recieverType == RT_USER && it->first == reciever ||
          recieverType == RT_NOT_USER && it->first != reciever ||
          recieverType == RT_SERVER && getNetworkStream()->isUserServer( it->first )
+         recieverType == RT_SERVER && getNetworkStream()->isUserMasterServer( it->first )
+       )
+    {
 …
+    }
+  }
   if ( recieverType == RT_ALL_ME )
+  {

trunk/src/lib/network/netdefs.h

-                      r9246
+                      r9406
+/*
+   orxonox - the future of 3D-vertical-scrollers
+   Copyright (C) 2004 orx
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+### File Specific:
+   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)
+*/
 /*!
  * @file network_manager.h
  *  Main interface for the network module. Manages all the modules
  */
 #ifndef _NETDEFS
 #define _NETDEFS
+#ifndef _NETDEFS_H
+#define _NETDEFS_H
+#ifdef HAVE_SDL_NET_H
+  #include <SDL_net.h>
+#else
+  #include <SDL/SDL_net.h>
+#endif
+#include "nettypes.h"
+#include "netincl.h"
-#define MAX_CONNECTIONS 1000
+//!< the amount of slots used before a proxy server is activated
+#define NET_CONNECTION_SATURATION 0.75
+//!< network polling frequency
 #define NETWORK_FREQUENCY 66
+typedef unsigned char byte;
+//!< orxonox protocol id
+#define _ORXONOX_ID        0xF91337A0
+//!< orxonox network version identifier
+#define _ORXONOX_VERSION   1
 //!< enum indicating the type of the node
 typedef enum {
+  NET_SERVER,
+  NET_CLIENT
+  NET_MASTER_SERVER,
+  NET_PROXY_SERVER_ACTIVE,
+  NET_PROXY_SERVER_PASSIVE,
+  NET_CLIENT,
+  NET_NR_TYPES
 } NodeType;
 …
 } UidType;
 #endif /* _NETWORK_MANAGER */
+#endif /* _NETDEFS_H */

trunk/src/lib/network/network_game_manager.cc

-                      r9235
+                      r9406
 ### File Specific:
+   main-programmer: Benjamin Wuest
+   co-programmer: ...
+   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)
 */
+/* this is for debug output. It just says, that all calls to PRINT() belong to the DEBUG_MODULE_NETWORK module
+   For more information refere to https://www.orxonox.net/cgi-bin/trac.cgi/wiki/DebugOutput
+*/
 #define DEBUG_MODULE_NETWORK
 …
+/* using namespace std is default, this needs to be here */
+using namespace std;
 NetworkGameManager* NetworkGameManager::singletonRef = NULL;
 …
   this->setSynchronized(true);
   MessageManager::getInstance()->registerMessageHandler( MSGID_DELETESYNCHRONIZEABLE, delSynchronizeableHandler, NULL );
   MessageManager::getInstance()->registerMessageHandler( MSGID_PREFEREDTEAM, preferedTeamHandler, NULL );
   MessageManager::getInstance()->registerMessageHandler( MSGID_CHATMESSAGE, chatMessageHandler, NULL );
   this->gameState = 0;
   registerVar( new SynchronizeableInt( &gameState, &gameState, "gameState" ) );
 …
+{
   delete MessageManager::getInstance();
   PlayerStats::deleteAllPlayerStats();
   NetworkGameManager::singletonRef = NULL;
+}
 …
 /**
  * insert new player into game
  * @param userId
  * @return
+ * @param userId
+ * @return
  */
 bool NetworkGameManager::signalNewPlayer( int userId )
+{
   assert( SharedNetworkData::getInstance()->isGameServer() );
+  assert( SharedNetworkData::getInstance()->isMasterServer() ||  SharedNetworkData::getInstance()->isProxyServer());
   assert( State::getGameRules() );
   assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );
   NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));
   int team = rules.getTeamForNewUser();
   ClassID playableClassId = rules.getPlayableClassId( userId, team );
 …
   std::string playableTexture = rules.getPlayableModelFileName( userId, team, playableClassId );
   float       playableScale = rules.getPlayableScale( userId, team, playableClassId );
   BaseObject * bo = Factory::fabricate( playableClassId );
   assert( bo != NULL );
   assert( bo->isA( CL_PLAYABLE ) );
   Playable & playable = *(dynamic_cast<Playable*>(bo));
   playable.loadMD2Texture( playableTexture );
   playable.loadModel( playableModel, 100.0f );
   playable.setOwner( userId );
   playable.setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
   playable.setSynchronized( true );
   PlayerStats * stats = rules.getNewPlayerStats( userId );
   stats->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
   stats->setSynchronized( true );
   stats->setOwner( SharedNetworkData::getInstance()->getHostID() );
   stats->setTeamId( team );
   stats->setPlayableClassId( playableClassId );
   stats->setPlayableUniqueId( playable.getUniqueID() );
   stats->setModelFileName( playableModel );
   if ( userId == 0 )
     stats->setNickName( Preferences::getInstance()->getString( "multiplayer", "nickname", "Server" ) );
   if ( rules.isA( CL_MULTIPLAYER_TEAM_DEATHMATCH ) )
     dynamic_cast<MultiplayerTeamDeathmatch*>(&rules)->respawnPlayable( &playable, team, 0.0f );
   return true;
+}
 …
 /**
  * remove player from game
  * @param userID
  * @return
+ * @param userID
+ * @return
  */
 bool NetworkGameManager::signalLeftPlayer(int userID)
 …
     delete PlayerStats::getStats( userID );
+  }
   return true;
+}
 …
 /**
  * handler for remove synchronizeable messages
  * @param messageId
  * @param data
  * @param dataLength
  * @param someData
  * @param userId
+ * @param messageId
+ * @param data
+ * @param dataLength
+ * @param someData
+ * @param userId
  * @return true on successfull handling else handler will be called again
  */
 bool NetworkGameManager::delSynchronizeableHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+{
   if ( getInstance()->isServer() )
+  if ( SharedNetworkData::getInstance()->isMasterServer() ||  SharedNetworkData::getInstance()->isProxyServer())
+  {
     PRINTF(2)("Recieved DeleteSynchronizeable message from client %d!\n", userId);
     return true;
+  }
   int uniqueId = 0;
   int len = Converter::byteArrayToInt( data, &uniqueId );
   if ( len != dataLength )
+  {
 …
     return true;
+  }
   const std::list<BaseObject*> * list = ClassList::getList( CL_SYNCHRONIZEABLE );
   for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
+  {
 …
         return true;
+      }
       delete dynamic_cast<Synchronizeable*>(*it);
       return true;
+    }
+  }
   return true;
+}
 …
+{
   byte buf[INTSIZE];
   assert( Converter::intToByteArray( uniqueId, buf, INTSIZE ) == INTSIZE );
 …
 /**
  * handler for MSGID_PREFEREDTEAM message
  * @param messageId
  * @param data
  * @param dataLength
  * @param someData
  * @param userId
  * @return
+ * @param messageId
+ * @param data
+ * @param dataLength
+ * @param someData
+ * @param userId
+ * @return
  */
 bool NetworkGameManager::preferedTeamHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+{
   assert( NetworkGameManager::getInstance()->isServer() );
+  assert( SharedNetworkData::getInstance()->isMasterServer() ||  SharedNetworkData::getInstance()->isProxyServer());
   int teamId = 0;
   int len = Converter::byteArrayToInt( data, &teamId );
   if ( len != dataLength )
+  {
 …
     return true;
+  }
   NetworkGameManager::getInstance()->setPreferedTeam( userId, teamId );
   return true;
+}
 …
   if ( !PlayerStats::getStats( userId ) )
     return;
   PlayerStats & stats = *(PlayerStats::getStats( userId ));
   stats.setPreferedTeamId( teamId );
+}
 …
 /**
  * set prefered team for this host
  * @param teamId
+ * @param teamId
  */
 void NetworkGameManager::prefereTeam( int teamId )
+{
   if ( isServer() )
+  if ( SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer())
     setPreferedTeam( SharedNetworkData::getInstance()->getHostID(), teamId );
   else
+  {
     byte buf[INTSIZE];
     assert( Converter::intToByteArray( teamId, buf, INTSIZE) == INTSIZE );
     MessageManager::getInstance()->sendMessage( MSGID_PREFEREDTEAM, buf, INTSIZE, RT_USER, 0, MP_HIGHBANDWIDTH );
+  }
 …
+    {
       const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYABLE );
       if ( list && std::find( list->begin(), list->end(), *it ) != list->end() )
+      {
         PRINTF(0)("Delete unused playable: %s owner: %d\n", (*it)->getClassName(), (*it)->getOwner() );
+      {
+        PRINTF(0)("Delete unused playable: %s owner: %d\n", (*it)->getClassCName(), (*it)->getOwner() );
         std::list<Playable*>::iterator delit = it;
         it++;
 …
+{
   PRINTF(0)("NetworkGameManager::chatMessageHandler %d %d\n", userId, SharedNetworkData::getInstance()->getHostID() );
   if ( NetworkGameManager::getInstance()->isServer() && userId !=  SharedNetworkData::getInstance()->getHostID() )
+  if ( (SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer()) && userId !=  SharedNetworkData::getInstance()->getHostID() )
+  {
     MessageManager::getInstance()->sendMessage( messageId, data, dataLength, RT_ALL_NOT_ME, 0, MP_HIGHBANDWIDTH );
+  }
   assert( State::getGameRules() );
   assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );
   NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));
   if ( dataLength < 3*INTSIZE )
+  {
     PRINTF(2)("got too small chatmessage from client %d\n", userId);
     return true;
+  }
   int messageType = 0;
   Converter::byteArrayToInt( data, &messageType );
 …
   std::string message;
   Converter::byteArrayToString( data+2*INTSIZE, message, dataLength-2*INTSIZE );
   rules.handleChatMessage( senderUserId, message, messageType );
 …
   assert( Converter::intToByteArray( SharedNetworkData::getInstance()->getHostID(), buf+INTSIZE, INTSIZE ) == INTSIZE );
   assert( Converter::stringToByteArray(message, buf+2*INTSIZE, message.length()+INTSIZE) == message.length()+INTSIZE );
   if ( this->isServer() )
+  if ( SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer())
     MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_ME, 0, MP_HIGHBANDWIDTH );
   else
     MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_NOT_ME, 0, MP_HIGHBANDWIDTH );
   delete [] buf;
+}

trunk/src/lib/network/network_game_manager.h

-                      r8708
+                      r9406
   NET_YOU_ARE_ENTITY,
   NET_REQUEST_ENTITY_LIST,
-  NET_REQUEST_PNODE_PATH,
-  NET_SEND_PNODE_PATH,
   NET_NUMBER
 …
 /*!
  * a class that can create and remove entities
+ * a class that can create and remove entities over the network
  */
 class NetworkGameManager: public Synchronizeable
+{
   public:
     virtual ~NetworkGameManager();
     static NetworkGameManager* NetworkGameManager::getInstance()
     { if (!NetworkGameManager::singletonRef) NetworkGameManager::singletonRef = new NetworkGameManager(); return NetworkGameManager::singletonRef; }
 …
     bool signalNewPlayer( int userId );
     bool signalLeftPlayer( int userID );
+    void removeSynchronizeable( int uniqueId );
     void prefereTeam( int teamId );
     inline void setGameState( int gameState ){ this->gameState = gameState; }
     inline int getGameState(){ return this->gameState; }
     void tick( float ds );
+    void removeSynchronizeable( int uniqueId );
     void sendChatMessage( const std::string & message, int messageType );
   private:
     NetworkGameManager();
     static bool delSynchronizeableHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
     static bool preferedTeamHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
     static bool chatMessageHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
     void setPreferedTeam( int userId, int teamId );
+  private:
     static NetworkGameManager*    singletonRef;
     int                           gameState;
     std::list<Playable*>          playablesToDelete;
 };

trunk/src/lib/network/network_manager.cc

-                      r9059
+                      r9406
    ### File Specific:
    main-programmer: Patrick Boenzli
    co-programmer: ...
+   main-programmer: Patrick Boenzli (patrick@orxonox.ethz.ch)
+   co-programmer: Christoph Renner (rennerc@ee.ethz.ch)
 */
 …
 /* using namespace std is default, this needs to be here */
+using namespace std;
 SHELL_COMMAND(debug, NetworkManager, debug);
 …
   this->networkStream = NULL;
   this->elapsedTime = 0.0f;
   int port = Preferences::getInstance()->getInt( "network", "telnetport", 0 );
   if ( port > 0 )
     NetworkLog::getInstance()->listen( port );
 …
     this->networkStream = NULL;
+  }
   NetworkManager::singletonRef = NULL;
+}
 …
+{
+}
+/**
+ *  creates a new NetworkStream of server type
+ * @param port: number of the TCP port
+ */
+int NetworkManager::createMasterServer(unsigned int port)
+{
+  // load the network settings
+  NetworkSettings::getInstance()->loadData();
+  // create the network stream
+  this->networkStream = new NetworkStream(NET_MASTER_SERVER);
+  this->networkStream->createServer( port);
+  // start the network game manager
+  this->networkStream->createNetworkGameManager();
+  PRINTF(0)("Created Network Master Server\n");
+  SDL_Delay(20);
+  return 1;
+}
+/**
+ *  creates a new network stream of proxy server type
+ * @param port: number of the TCP port
+ */
+int NetworkManager::createProxyServer(unsigned int port)
+{
+  // load the network settings
+  NetworkSettings::getInstance()->loadData();
+  // create the network stream
+  this->networkStream = new NetworkStream(NET_PROXY_SERVER_ACTIVE);
+  this->networkStream->createServer( port);
+  // and connect to the master server for synchronization
+//   this->networkStream->connectToMasterServer(NetworkSettings::getInstance()->getMasterAddr());
+  // and to the other proxy servers
+  // start the network game manager
+  this->networkStream->createNetworkGameManager();
+  PRINTF(0)("Created Network Proxy Server\n");
+  SDL_Delay(20);
+  return 1;
+}
 …
  * @param hostName: the name of the destination host
  */
+int NetworkManager::establishConnection(const std::string & name, unsigned int port)
+{
+  this->networkStream = new NetworkStream( name, port );
+  SharedNetworkData::getInstance()->setDefaultSyncStream(this->networkStream);
+int NetworkManager::createClient(const std::string & name, unsigned int port)
+{
+  // load the network settings
+  NetworkSettings::getInstance()->loadData();
+  // create the network stream
+  this->networkStream = new NetworkStream(NET_CLIENT);
+  // connect to the master server, if a redirection should occure, this is handled in the NetworkStream itself
+  this->networkStream->connectToMasterServer( name, port);
+  // and start the handshake
   this->networkStream->startHandshake();
+  PRINTF(0)("Created Network Client");
   return 1;
+}
 …
 /**
+ *  creates a new NetworkStream of server type
+ * @param port: number of the TCP port
+ */
+int NetworkManager::createServer(unsigned int port)
+{
+  SharedNetworkData::getInstance()->setHostID(0);
+  SharedNetworkData::getInstance()->setGameServer(true);
+  this->networkStream = new NetworkStream(port);
+  SharedNetworkData::getInstance()->setDefaultSyncStream(this->networkStream);
+  this->networkStream->createNetworkGameManager();
+  PRINTF(0)("CREATE SERVER\n");
+  SDL_Delay(20);
+  return 1;
+}
+ * connects a synchronizeable to the network stream
+ * @param sync: synchronizeable to connect
+ */
 void NetworkManager::connectSynchronizeable(Synchronizeable& sync)
+{
 …
   if( likely(this->elapsedTime < 1.0f / NETWORK_FREQUENCY))
     return;
   this->elapsedTime = 0.0f;
   if ( networkStream )
+  if ( this->networkStream )
     networkStream->processData();
   NetworkGameManager::getInstance()->tick( this->elapsedTime );
+}

trunk/src/lib/network/network_manager.h

-                      r9059
+                      r9406
     void shutdown();
+    int establishConnection( const std::string & name, unsigned int port);
+    int createServer(unsigned int port);
+    /** Returns the hostID @return The hostID of the object */
+    inline int getHostID() { return SharedNetworkData::getInstance()->getHostID(); }
+    inline bool isGameServer() { return SharedNetworkData::getInstance()->isGameServer(); }
+    int createClient( const std::string & name, unsigned int port);
+    int createMasterServer( unsigned int port);
+    int createProxyServer( unsigned int port);
     void connectSynchronizeable(Synchronizeable& sync);
 …
   private:
     static NetworkManager*           singletonRef;            //!< Pointer to the only instance of this Class
     NetworkStream*                   networkStream;       //!< pointer to network stream
+    NetworkStream*                   networkStream;           //!< pointer to network stream
     float                            elapsedTime;             //!< elapsed time since the last network update

trunk/src/lib/network/network_protocol.cc

r6341	r9406
33	33
34	34	/* using namespace std is default, this needs to be here */
35		using namespace std;
	35
36	36
37	37

trunk/src/lib/network/network_socket.cc

r7954	r9406
33	33	{
34	34	bOk = true;
	35	this->ip.host = 0;
	36	this->ip.port = 0;
35	37	}
36	38

trunk/src/lib/network/network_socket.h

-                      r7954
+                      r9406
      */
     virtual void connectToServer( std::string host, int port ) = 0;
     /**
      * disconnect from server
      */
     virtual void disconnectServer() = 0;
+    /**
+     * reconnecting to another server by terminating old connection and init a new connection
+     */
+    virtual void reconnectToServer( std::string host, int port) = 0;
+    /**
+     * reconnecting to anoter server softly
+     */
+    virtual void reconnectToServerSoft( std::string host, int port) = 0;
     /**
 …
      */
     virtual bool writePacket(byte * data, int length) = 0;
     /**
      * read a packet sent by another NetworkSocket
 …
      */
     inline bool isOk() { return this->bOk; }
+    /** @returns the ip adderess of the destination socket */
+    IPaddress getRemoteAddress() { return ip; }
   protected:
     bool bOk;            //!< check for socket status
+    bool              bOk;            //!< check for socket status
+    IPaddress         ip;             //!< host,port
 };

trunk/src/lib/network/network_stream.cc

-                      r9246
+                      r9406
    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)
 */
 …
 #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"
 …
 #include <algorithm>
+/* include your own header */
 #include "network_stream.h"
+/* probably unnecessary */
+using namespace std;
+#include "converter.h"
 …
+/**
+ * empty constructor
+ */
 NetworkStream::NetworkStream()
     : DataStream()
 …
   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;
+}
 …
   /* 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 );
 …
   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);
+}
 …
+{
   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() );
 …
 /**
  * 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());
+}
 …
   sync.setNetworkStream( this );
   this->bActive = true;
+//   this->bActive = true;
+}
 …
 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();
 …
   cleanUpOldSyncList();
   handleHandshakes();
+  // update the network monitor
+  this->networkMonitor->process();
   // order of up/downstream is important!!!!
 …
 /**
  * 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( )
 …
       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
 …
         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);
+  }
 …
       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++ )
+      {
 …
 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());
 …
+  {
     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() );
+}
 …
     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() );
+            }
 …
             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() != "" )
 …
 /**
+ * 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
  */
 …
     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
 …
         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;
 …
         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;
 …
     // 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
 …
       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;
 …
+      }
       while ( offset + 2*INTSIZE < length )
+      while ( offset + 2 * INTSIZE < length )
+      {
         assert( offset > 0 );
 …
         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 ) )
+          {
 …
+        }
+        // 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() )
+          {
 …
+          }
+          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;
 …
           assert( leafClassId != 0 );
           BaseObject * b = NULL;
           /* These are some small exeptions in creation: Not all objects can/should be created via Factory */
 …
           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;
 …
             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
 …
         int n = sync->setStateDiff( peer->second.userId, buf+offset, syncDataLength, state, fromState );
         offset += n;
-        //NETPRINTF(0)("SSSSSEEEEETTTTT: %s %d\n",sync->getClassName(), n);
+      }
 …
 /**
  * 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 );
+}
 /**

trunk/src/lib/network/network_stream.h

-                      r9246
+                      r9406
 #include "server_socket.h"
 #include "handshake.h"
 #include "connection_monitor.h"
+#include "monitor/connection_monitor.h"
 #include "udp_server_socket.h"
+#include "peer_info.h"
+#include "shared_network_data.h"
 class Synchronizeable;
 …
 class ServerSocket;
 class NetworkGameManager;
+class NetworkMonitor;
-//!< this structure contains informations about the network node
-class PeerInfo
+{
-  public:
-    PeerInfo() { clear(); }
-    void clear() { userId = 0; isServer = false; socket = NULL; handshake = NULL; lastAckedState = 0; lastRecvedState = 0; connectionMonitor = NULL; }
-  public:
-    int                 userId;
-    bool                isServer;
-    NetworkSocket *     socket;
-    Handshake *         handshake;
-    ConnectionMonitor * connectionMonitor;
-    int                 lastAckedState;
-    int                 lastRecvedState;
-};
 typedef std::list<Synchronizeable*>  SynchronizeableList;
 …
   public:
     NetworkStream();
     NetworkStream( std::string host, int port);
     NetworkStream( int port );
+    NetworkStream(int nodeType);
+    virtual ~NetworkStream();
-    virtual ~NetworkStream();
     void init();
+    void connectToMasterServer(std::string host, int port);
+    void connectToProxyServer(std::string host, int port);
+    void createServer(int port);
     void createNetworkGameManager();
     void startHandshake();
+    /* synchronizeable interface */
     void connectSynchronizeable(Synchronizeable& sync);
     void disconnectSynchronizeable(Synchronizeable& sync);
+    inline bool isServer() const { return (this->type == NET_SERVER)? true:false; }
+    inline bool isActive() const { return this->bActive; }
+    inline int getMaxConnections(){ return SharedNetworkData::getInstance()->getMaxPlayer(); }
+    inline int getMaxConnections(){ return MAX_CONNECTIONS; }
+    /* functions for the peerInfo information retreival */
+    inline bool isUserIdActive( int userID ) { return (peers.find(userID) != peers.end()); }
+    inline bool isUserMasterServer( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isMasterServer(); }
+    inline bool isUserProxyServer( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isProxyServer(); }
+    inline bool isUserClient( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isClient(); }
+    /* peering interface */
+    inline PeerInfo & getPeerInfo( int userId ) { return peers[userId]; }
+    inline PeerInfo* getPeerInfo() { return this->pInfo; }
+    inline PeerList getPeerInfoList() { return this->peers; }
+    /* data processing*/
     virtual void processData();
+    /* debugging */
+    void debug();
+  private:
     inline SynchronizeableList::const_iterator getSyncBegin(){ return synchronizeables.begin(); }
     inline SynchronizeableList::const_iterator getSyncEnd(){ return synchronizeables.end(); }
+    void cleanUpOldSyncList();
     int getSyncCount();
-    inline bool isUserIdActive( int userID ) { return (peers.find(userID) != peers.end()); }
-    inline bool isUserServer( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isServer; }
-    void debug();
-    inline PeerInfo & getPeerInfo( int userId ) { return peers[userId]; }
-  private:
     void updateConnectionList();
+    /* handle processes */
     void handleHandshakes();
     void handleUpstream( int tick );
     void handleDownstream(int tick );
+    /* handle events*/
     void handleNewClient( int userId );
     void cleanUpOldSyncList();
+    void handleReconnect( int userId );
     void writeToNewDict( byte * data, int length, bool upstream );
 …
   private:
+    SynchronizeableList        synchronizeables;
+    PeerList                   peers;
+    ServerSocket*              serverSocket;
+    int                        type;
+    bool                       bActive;
+    std::list<int>             freeSocketSlots;
+    PeerList                   peers;                       //!< list of the network node informations
     int                        myHostId;
+    PeerInfo*                  pInfo;                       //!< the info about the local peer node (not in the PeerList)
+    std::list<int>             freeSocketSlots;             //!< list of free sockets (to ensure not to resycle sockets)
     int                        currentState;                //!< current state id
+    NetworkGameManager*        networkGameManager;
+    NetworkMonitor*            networkMonitor;              //!< the network monitor
+    NetworkGameManager*        networkGameManager;          //!< reference to the network game manager
+    ServerSocket*              serverSocket;                //!< the listening socket of the server
     std::map<int,int>          oldSynchronizeables;         //!< used to save recently deleted sync ids to not recreate them
+    SynchronizeableList        synchronizeables;            //!< list of the synchronizeables
     byte                       buf[UDP_PACKET_SIZE];        //!< used by handleUp/Downstream
     byte                       compBuf[UDP_PACKET_SIZE];    //!< used by handleUp/Downstream
     int                        remainingBytesToWriteToDict; //!< if > 0 NetworkStream will write packets to DATA/dicts/newdict
     int dictServer;
     int dictClient;
+    int                        dictServer;                  //!< the zip dict for the server
+    int                        dictClient;                  //!< the zip dict for the client
 };
 #endif /* _NETWORK_STREAM */

trunk/src/lib/network/player_stats.cc

r9235	r9406
23	23	#include "shared_network_data.h"
24	24
	25	#include "converter.h"
	26
25	27	#include "preferences.h"
26	28
…	…
38	40	{
39	41	init();
40
	42
41	43	this->userId = userId;
42	44	}
…	…
62	64	this->nickName = "Player";
63	65	this->oldNickName = "Player";
64
	66
65	67	userId_handle = registerVarId( new SynchronizeableInt( &userId, &userId, "userId" ) );
66	68	teamId_handle = registerVarId( new SynchronizeableInt( &teamId, &teamId, "teamId" ) );
…	…
71	73	modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName" ) );
72	74	nickName_handler = registerVarId( new SynchronizeableString( &nickName, &nickName, "nickName" ) );
73
	75
74	76	MessageManager::getInstance()->registerMessageHandler( MSGID_CHANGENICKNAME, changeNickHandler, NULL );
75
	77
76	78	PRINTF(0)("PlayerStats created\n");
77	79	}
…	…
96	98	{
97	99	this->setPlayableUniqueId( this->playableUniqueId );
98
	100
99	101	PRINTF(0)("uniqueID changed %d %d %d\n", userId, SharedNetworkData::getInstance()->getHostID(), getUniqueID());
100	102	}
101
	103
102	104	if ( std::find( id.begin(), id.end(), nickName_handler ) != id.end() )
103	105	{
…	…
115	117	{
116	118	const std::list<BaseObject> list = ClassList::getList( CL_PLAYER_STATS );
117
	119
118	120	if ( !list )
119	121	{
120	122	return NULL;
121	123	}
122
	124
123	125	for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
124	126	{
…	…
128	130	}
129	131	}
130
	132
131	133	return NULL;
132	134	}
…	…
138	140	{
139	141	const std::list<BaseObject> list = ClassList::getList( CL_PLAYABLE );
140
	142
141	143	if ( !list )
142	144	{
…	…
144	146	return;
145	147	}
146
	148
147	149	this->playable = NULL;
148	150	for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
…	…
156	158	}
157	159	}
158
	160
159	161	if ( this->playable && userId == SharedNetworkData::getInstance()->getHostID() )
160	162	{
161	163	State::getPlayer()->setPlayable( this->playable );
162	164	}
163
	165
164	166	this->playableUniqueId = uniqueId;
165	167	}
…	…
173	175	if ( playable )
174	176	return playable;
175
	177
176	178	assert( playableUniqueId > 0 );
177
	179
178	180	setPlayableUniqueId( playableUniqueId );
179
	181
180	182	assert( playable );
181
	183
182	184	return playable;
183	185	}
…	…
189	191	void PlayerStats::setNickName( std::string nick )
190	192	{
191		if ( SharedNetworkData::getInstance()->is~~Game~~Server() )
	193	if ( SharedNetworkData::getInstance()->isMasterServer() \|\| SharedNetworkData::getInstance()->isProxyServer() )
192	194	{
193	195	this->nickName = nick;
…	…
199	201	{
200	202	byte * data = new byte[nick.length()+INTSIZE];
201
	203
202	204	assert( Converter::stringToByteArray( nick, data, nick.length()+INTSIZE) == nick.length()+INTSIZE );
203
	205
204	206	MessageManager::getInstance()->sendMessage( MSGID_CHANGENICKNAME, data, nick.length()+INTSIZE, RT_SERVER, 0, MP_HIGHBANDWIDTH );
205	207	return;
…	…
211	213	std::string newNick;
212	214	int res = Converter::byteArrayToString( data, newNick, dataLength );
213
	215
214	216	if ( res != dataLength )
215	217	{
…	…
217	219	newNick = "invalid";
218	220	}
219
	221
220	222	if ( PlayerStats::getStats( userId ) )
221	223	PlayerStats::getStats( userId )->setNickName( newNick );
222
	224
223	225	return true;
224	226	}
…	…
228	230	if ( getStats( SharedNetworkData::getInstance()->getHostID() ) )
229	231	getStats( SharedNetworkData::getInstance()->getHostID() )->setNickName( newNick );
230
	232
231	233	Preferences::getInstance()->setString( "multiplayer", "nickname", newNick );
232	234	}
…	…
237	239	{
238	240	const std::list<BaseObject> list;
239
	241
240	242	while ( (list = ClassList::getList( CL_PLAYER_STATS )) != NULL && list->begin() != list->end() )
241	243	delete *list->begin();
…	…
247	249	{
248	250	ScoreList result;
249
	251
250	252	const std::list<BaseObject> list = ClassList::getList( CL_PLAYER_STATS );
251
	253
252	254	if ( !list )
253	255	{
254	256	return result;
255	257	}
256
	258
257	259	for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
258	260	{
259	261	PlayerStats & stats = dynamic_cast<PlayerStats>(*it);
260
	262
261	263	TeamScoreList::iterator it = result[stats.getTeamId()].begin();
262
	264
263	265	while ( it != result[stats.getTeamId()].end() && stats.score > it->score )
264	266	{
265	267	it++;
266	268	}
267
	269
268	270	PlayerScore score;
269	271	score.name = stats.getNickName();
270	272	score.score = stats.getScore();
271
	273
272	274	result[stats.getTeamId()].insert(it, score);
273	275	}
274
	276
275	277	return result;
276	278	}

trunk/src/lib/network/shared_network_data.cc

-                      r9110
+                      r9406
 #include "shared_network_data.h"
 #include "netdefs.h"
+#include "state.h"
+#include "debug.h"
-using namespace std;
 …
   this->setClassID(CL_SHARED_NETWORK_DATA, "SharedNetworkData");
+  this->nodeType = NET_CLIENT;
   this->hostID = -1;
   this->defaultSyncStream = NULL;
+  this->newUniqueID = MAX_CONNECTIONS + 2;
+  this->bGameServer = false;
+  // setUniqueID( maxCon+2 ) because we need one id for every handshake
+  // and one for handshake to reject client maxCon+1
+  this->newUniqueID = 2;
+}

trunk/src/lib/network/shared_network_data.h

-                      r6695
+                      r9406
 #include "base_object.h"
+#include "netdefs.h"
+#include "proxy/network_settings.h"
+//!< maximal connectinons for the server
+#define NET_MAX_CONNECTIONS 2
 class NetworkStream;
 class Synchronizeable;
+template<typename>
+    class tList;
 /* and here is the class itsself*/
 …
     /** @returns the next uniqueID free for an object */
+    inline int getNewUniqueID() { return ( this->bGameServer)?this->newUniqueID++:-1; }
+    inline int getNewUniqueID() { return ( this->nodeType != NET_CLIENT)?this->newUniqueID++:-1; }
+    /** sets the @param newUniqueID: the new offset for the next unique id */
+    inline void setNewUniqueID(int newUniqueID) { this->newUniqueID = newUniqueID; }
+    /** @returns true is this node is a game server */
+    inline bool isGameServer() { return this->bGameServer; }
+    /** @returns true is this node is a master server */
+    inline bool isMasterServer() { return this->nodeType == NET_MASTER_SERVER; }
+    /** @returns true is this node is a proxy server */
+    inline bool isProxyServer() { return this->nodeType == NET_PROXY_SERVER_ACTIVE; }
+    /** @returns true is this node is a client*/
+    inline bool isClient() { return this->nodeType == NET_CLIENT; }
     /** sets the game server flag @param bGameServer true if it is a game server */
+    inline void setGameServer(bool bGameServer) { this->bGameServer = bGameServer; }
+    inline void setNodeType(int nodeType) { this->nodeType = nodeType; }
+    /** @returns the maximum number of players for this server */
+    inline int getMaxPlayer() { return NetworkSettings::getInstance()->getMaxPlayer(); }
     /** @returns the hostID of the node */
 …
   private:
     int                             newUniqueID;             //!< next uniqueID
+    bool                            bGameServer;             //!< true if it is a server
+    int                             nodeType;                //!< saves the node type here
     int                             hostID;                  //!< The Host-ID of the Manager
     NetworkStream*                  defaultSyncStream;       //!< default synchronize NetworkStream

trunk/src/lib/network/synchronizeable.cc

-                      r9110
+                      r9406
 ### File Specific:
    main-programmer: Silvan Nellen
    co-programmer: Benjamin Wuest
+   main-programmer: Christoph Renner (rennerc@ee.ethz.ch)
+   co-programmer: Patrick Boenzli (patrick@orxonox.ethz.ch)
 */
 …
 #include "synchronizeable.h"
+#include "converter.h"
 …
   this->setClassID(CL_SYNCHRONIZEABLE, "Synchronizeable");
   this->owner = 0;
   this->setIsServer(SharedNetworkData::getInstance()->getHostID() == 0);
+//   this->setIsServer(SharedNetworkData::getInstance()->getHostID() == 0);
   this->uniqueID = NET_UID_UNASSIGNED;
   this->networkStream = NULL;
   this->bSynchronize = false;
   if( State::isOnline())
+  {
 …
   assert( syncVarList.size() == 0 );
   mLeafClassId = this->registerVarId( new SynchronizeableInt( (int*)&this->getLeafClassID(), (int*)&this->getLeafClassID(), "leafClassId" ) );
   this->registerVar( new SynchronizeableInt( &this->owner, &this->owner, "owner" ) );
   this->registerVar( new SynchronizeableString( &this->objectName, &this->objectName, "objectName" ) );
 …
+  {
     this->networkStream->disconnectSynchronizeable(*this);
+    if ( this->isServer() && this->beSynchronized() && this->getUniqueID() > 0 && !this->isA( CL_MESSAGE_MANAGER ) )
+    if ( (SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer() )
+           && this->beSynchronized() && this->getUniqueID() > 0 && !this->isA( CL_MESSAGE_MANAGER ) )
       NetworkGameManager::getInstance()->removeSynchronizeable( this->getUniqueID() );
+  }
   for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
 …
+  }
   syncVarList.clear();
   for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
+  {
 …
+  }
   for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
+  {
 …
       delete *it2;
+    }
+  }
+}
+/**
+ * Sets the server flag to a given value
+ * @param isServer: the boolean value which the server flag is to set to
+ */
+void Synchronizeable::setIsServer(bool isServer)
+{
+  if( isServer )
+    this->state = this->state | STATE_SERVER;
+  else
+    this->state = this->state & (~STATE_SERVER);
+}
+/**
+ * Determines if the server flag is set
+ * @return true, if the server flag is true, false else
+ */
+bool Synchronizeable::isServer()
+{
+  return (this->state & STATE_SERVER) >0;
+}
+  }
+}
+/**
+ * creates a diff image from two states
+ * @param userId: the userid of the user where the image will be sent to
+ * @param data: the binary data array to write to
+ * @param maxLength: maximal length of the data written (length of available space in the array)
+ * @param stateId: the state id that this diff will represent
+ * @param priorityTH: the priority threshold: all syncs below this threshold won't be synchronized
+ *
+ * @todo check for permissions
+ */
 int Synchronizeable::getStateDiff( int userId, byte* data, int maxLength, int stateId, int fromStateId, int priorityTH )
+{
 …
         (*it2)->data = NULL;
+      }
       delete *it2;
+    }
 …
   while ( it != sentStates[userId].end() && (*it)->stateId != fromStateId )
     it++;
-//  if ( getLeafClassID() == CL_SPACE_SHIP )
-//  {
-//    PRINTF(0)("getStateDiff:SpaceShip from: %d stateId: %d\n", (it == sentStates[userId].end())?-1:fromStateId, stateId);
-//  }
   if ( it == sentStates[userId].end() )
 …
     stateFrom = initialEntry;
     sentStates[userId].push_back( stateFrom );
+  }
 …
   sentStates[userId].push_back( stateTo );
   stateTo->stateId = stateId;
   stateTo->dataLength = neededSize;
 …
   int i = 0;
   int n;
   bool hasPermission;
+  bool hasPermission = false;
   bool sizeChanged = false;
 …
   for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
+    hasPermission = (
+            this->isServer() && (*it)->checkPermission( PERMISSION_SERVER ) ||
+        this->owner == SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ) ||
+            this->isServer() && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ) ||
+            (*it)->checkPermission( PERMISSION_ALL )
+                    );
+    if ( sizeIter == stateFrom->sizeList.end() || *sizeIter != (*it)->getSize() )
+    // DATA PERMISSIONS
+    // check if this synchronizeable has the permissions to write the data
+    // first check MASTER_SERVER permissions
+    if( SharedNetworkData::getInstance()->isMasterServer() && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
+      hasPermission = true;
+    // now check PROXY_SERVER permissions
+    else if( SharedNetworkData::getInstance()->isProxyServer() && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
+      hasPermission = true;
+    // now check OWNER permissions
+    else if( this->owner == SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // now check ALL permissions
+    else if( (*it)->checkPermission( PERMISSION_ALL ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if i am master server and i am able to overwrite the client stuff
+    else if( SharedNetworkData::getInstance()->isMasterServer() && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if i am proxy server and i am able to overwrite the client stuff
+    else if( SharedNetworkData::getInstance()->isProxyServer()  && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    else
+      hasPermission = false;
+    if ( sizeIter == stateFrom->sizeList.end() || *sizeIter != (*it)->getSize() )
       sizeChanged = true;
     if ( ( hasPermission && (*it)->getPriority() >= priorityTH ) || sizeChanged )
+    {
       n = (*it)->writeToBuf( stateTo->data+i, stateTo->dataLength - i );
       //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
+      //PRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
       stateTo->sizeList.push_back( n );
+      //(*it)->debug();
+      // this is only for very hardcore debug sessions
+      // (*it)->debug();
       i += n;
+    }
 …
   if ( i != neededSize )
+  {
     PRINTF(0)("strange error: (%s) %d != %d\n", this->getClassName(), i, neededSize);
+    PRINTF(0)("strange error: (%s) %d != %d\n", this->getClassCName(), i, neededSize);
     assert(false);
+  }
 …
  * @param fromStateId id of the base state id
  * @return number bytes read
+ *
  * @todo check for permissions
  */
 …
   StateHistoryEntry * stateFrom = NULL;
+  // search the state from wich the diff is made of
   StateHistory::iterator it = recvStates[userId].begin();
   while ( it != recvStates[userId].end() && (*it)->stateId != fromStateId )
     it++;
+//  if ( getLeafClassID() == CL_SPACE_SHIP )
+//  {
+//    PRINTF(0)("setStateDiff:SpaceShip from: %d stateId: %d\n", (it == recvStates[userId].end())?-1:fromStateId, stateId);
+//  }
+  // if this is the first state to receive
   if ( it == recvStates[userId].end() )
+  {
 …
     stateFrom = initialEntry;
     recvStates[userId].push_back( stateFrom );
+  }
   else
     stateFrom = (*it);
+  //apply diff
+  // apply diff
   for ( int i = 0; i<length; i++ )
+  {
 …
     else
       stateTo->data[i] = data[i];
+  }
+  }
   //add state to state history
   recvStates[userId].push_back( stateTo );
   int i = 0;
   int n = 0;
   std::list<int> changes;
+  bool hasPermission = false;
+  // extract the new state for every client
   for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
+    if (
+        (*it)->checkPermission( PERMISSION_SERVER ) && networkStream->isUserServer( userId ) ||
+        (*it)->checkPermission( PERMISSION_OWNER ) && this->owner == userId ||
+        networkStream->isUserServer( userId ) && this->owner != SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ) ||
+        (*it)->checkPermission( PERMISSION_ALL )
+       )
+    // DATA PERMISSIONS
+    // check if this synchronizeable has the permissions to write the data
+    // first check MASTER_SERVER permissions
+    if(  this->networkStream->isUserMasterServer( userId ) && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
+      hasPermission = true;
+    // now check PROXY_SERVER permissions
+    else if( this->networkStream->isUserProxyServer( userId )  && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
+      hasPermission = true;
+    // now check OWNER permissions
+    else if( this->owner == userId && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // now check ALL permissions
+    else if( (*it)->checkPermission( PERMISSION_ALL ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if im sending to a master server that does not own this sync
+    else if( this->networkStream->isUserMasterServer( userId ) && this->owner != SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if im sending to a proxy server that does not own this sync
+    else if( this->networkStream->isUserProxyServer( userId )  && this->owner != SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    else
+      hasPermission = false;
+    // if it has the permission to write do it
+    if( hasPermission)
+    {
       n = (*it)->readFromBuf( stateTo->data + i, stateTo->dataLength - i );
       i += n;
+      //NETPRINTF(0)("%s::setvar %s %d\n", getClassName(), (*it)->getName().c_str(), n);
+      //NETPRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
+      //PRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
       //(*it)->debug();
       if ( (*it)->getHasChanged() )
 …
     else
+    {
 //      PRINTF(0)("DONT SET VAR BECAUSE OF PERMISSION: %s %d %d %d %d %d %d\n", (*it)->getName().c_str(), (*it)->checkPermission( PERMISSION_SERVER ), (*it)->checkPermission( PERMISSION_OWNER ), (*it)->checkPermission( PERMISSION_ALL ), networkStream->isUserServer( userId ), this->owner, userId );
+//      PRINTF(0)("DONT SET VAR BECAUSE OF PERMISSION: %s %d %d %d %d %d %d\n", (*it)->getName().c_str(), (*it)->checkPermission( PERMISSION_MASTER_SERVER ), (*it)->checkPermission( PERMISSION_OWNER ), (*it)->checkPermission( PERMISSION_ALL ), networkStream->isUserServer( userId ), this->owner, userId );
       n = (*it)->getSizeFromBuf( stateTo->data + i, stateTo->dataLength - i );
       //NETPRINTF(0)("%s::setvar %s %d\n", getClassName(), (*it)->getName().c_str(), n);
+      //NETPRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
       //(*it)->debug();
       i += n;
 …
   this->varChangeHandler( changes );
   return i;
+}
 …
         (*it)->data = NULL;
+      }
       delete *it;
+    }
     recvStates[userId].clear();
+  }
   if ( sentStates.size() > userId )
+  {
     for ( std::list<StateHistoryEntry*>::iterator it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
+    {
 …
         (*it)->data = NULL;
+      }
       delete *it;
+    }
 …
 /**
  * this function is called after recieving a state.
  * @param userId
  * @param stateId
  * @param fromStateId
+ * @param userId
+ * @param stateId
+ * @param fromStateId
  */
 void Synchronizeable::handleRecvState( int userId, int stateId, int fromStateId )
 …
   if ( recvStates.size() <= userId )
     recvStates.resize( userId+1 );
   //remove old states
   StateHistory::iterator it = recvStates[userId].begin();
 …
       StateHistory::iterator delIt = it;
       it ++;
       if ( (*delIt)->data )
+      {
 …
       delete *delIt;
       recvStates[userId].erase( delIt );
       continue;
+    }
     it++;
+  }
   StateHistory::iterator fromState = recvStates[userId].end();
   StateHistory::iterator toState = recvStates[userId].end();
   for ( it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
+  {
 …
     if ( (*it)->stateId == fromStateId )
       fromState = it;
     if ( fromState != recvStates[userId].end() && toState != recvStates[userId].end() )
       break;
+  }
   // setStateDiff was not called and i know fromStateId
   if ( fromState != recvStates[userId].end() && toState == recvStates[userId].end() )
+  {
     StateHistoryEntry * entry = new StateHistoryEntry;
     entry->dataLength = (*fromState)->dataLength;
     if ( entry->dataLength > 0 )
+    {
       entry->data = new byte[entry->dataLength];
       assert( (*fromState)->data );
       memcpy( entry->data, (*fromState)->data, entry->dataLength );
 …
     else
       entry->data = NULL;
     entry->sizeList = (*fromState)->sizeList;
     entry->stateId = stateId;
     recvStates[userId].push_back(entry);
+  }
 …
 /**
  * this function is called after sending a state
  * @param userId
  * @param stateId
  * @param fromStateId
+ * @param userId
+ * @param stateId
+ * @param fromStateId
  */
 void Synchronizeable::handleSentState( int userId, int stateId, int fromStateId )
 …
       StateHistory::iterator delIt = it;
       it ++;
       if ( (*delIt)->data )
+      {
 …
       delete *delIt;
       sentStates[userId].erase( delIt );
       continue;
+    }
 …
+  }
   StateHistory::iterator fromState = sentStates[userId].end();
   StateHistory::iterator toState = sentStates[userId].end();
   for ( it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
+  {
 …
     if ( (*it)->stateId == fromStateId )
       fromState = it;
     if ( fromState != sentStates[userId].end() && toState != sentStates[userId].end() )
       break;
+  }
   // getStateDiff was not called and i know fromStateId
   if ( fromState != sentStates[userId].end() && toState == sentStates[userId].end() )
+  {
     StateHistoryEntry * entry = new StateHistoryEntry;
     entry->dataLength = (*fromState)->dataLength;
     if ( entry->dataLength > 0 )
+    {
       entry->data = new byte[entry->dataLength];
       assert( (*fromState)->data );
       memcpy( entry->data, (*fromState)->data, entry->dataLength );
 …
     else
       entry->data = NULL;
     entry->sizeList = (*fromState)->sizeList;
     entry->stateId = stateId;
     sentStates[userId].push_back(entry);
+  }
+}
+}

trunk/src/lib/network/synchronizeable.h

-                      r8708
+                      r9406
 /*!
  * @file synchronizeable.h
     \brief interface for all classes that have to be synchronized
+ * @brief interface for all classes that have to be synchronized
  */
 …
 #include "base_object.h"
+#include "netdefs.h"
+#include "converter.h"
+#include "vector.h"
+#include "quaternion.h"
 #include "synchronizeable_var/synchronizeable_var.h"
 #include "synchronizeable_var/synchronizeable_vector.h"
 …
 #include "synchronizeable_var/synchronizeable_bool.h"
 #include "synchronizeable_var/synchronizeable_uint.h"
+#include "synchronizeable_var/synchronizeable_ip.h"
 #include <vector>
 #include <list>
-//State constants: They have to be of the form 2^n
-#define STATE_SERVER 1
 struct StateHistoryEntry
 …
     virtual ~Synchronizeable();
-    void setIsServer( bool isServer );
-    bool isServer();
     virtual void varChangeHandler( std::list<int> & id );
 …
     virtual void handleSentState( int userId, int stateId, int fromStateId );
     virtual void handleRecvState( int userId, int stateId, int fromStateId );
     void registerVar( SynchronizeableVar * var );
     int registerVarId( SynchronizeableVar * var );
 …
   protected:
     NetworkStream*    networkStream;  //!< reference network stream we are connected to
+    int               state;
   private:

trunk/src/lib/network/synchronizeable_var/synchronizeable_bool.cc

r7954	r9406
16	16
17	17	#include "synchronizeable_bool.h"
	18	#include <cassert>
18	19
19	20
…	…
44	45	{
45	46	assert( maxLength >= 1 );
46
	47
47	48	buf[0] = ( *vPtrIn ) ? 1 : 0;
48
	49
49	50	return 1;
50	51	}
…	…
59	60	{
60	61	assert( maxLength >= 1 );
61
	62
62	63	bool oldVal = *vPtrOut;
63
	64
64	65	*vPtrOut = buf[0] != 0;
65
	66
66	67	setHasChanged( oldVal != *vPtrOut );
67
	68
68	69	return 1;
69	70	}

trunk/src/lib/network/synchronizeable_var/synchronizeable_bool.h

-                      r7954
+                      r9406
  * @file synchronizeable_int.h
  * @brief Definition of SynchronizeableInt
+*/
+#include "synchronizeable_var/synchronizeable_var.h"
+ */
 #ifndef _SYNCHRONIZEABLE_BOOL_H
 #define _SYNCHRONIZEABLE_BOOL_H
+#include "synchronizeable_var.h"
 class SynchronizeableBool : public SynchronizeableVar {
   public:
     SynchronizeableBool( bool * ptrIn, bool * ptrOut, std::string name, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableBool( bool * ptrIn, bool * ptrOut, std::string name, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableBool();
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
     /**
      * check if writeToBuf will return the same size every time
 …
      */
     virtual bool hasStaticSize(){ return true; };
     virtual void debug();
   private:
     bool * vPtrIn;       //!< pointer to data (read)

trunk/src/lib/network/synchronizeable_var/synchronizeable_float.cc

r7954	r9406
17	17	#include "synchronizeable_float.h"
18	18	#include "converter.h"
	19	#include <cassert>
19	20
20	21
…	…
46	47	{
47	48	int res = Converter::floatToByteArray( *vPtrIn, buf, maxLength );
48
	49
49	50	assert( res == FLOATSIZE );
50
	51
51	52	return res;
52	53	}
…	…
61	62	{
62	63	assert( maxLength >= FLOATSIZE );
63
	64
64	65	float oldVal = *vPtrOut;
65
	66
66	67	int res = Converter::byteArrayToFloat( buf, vPtrOut );
67
	68
68	69	setHasChanged( oldVal != *vPtrOut );
69
	70
70	71	assert( res == FLOATSIZE );
71
	72
72	73	return res;
73	74	}

trunk/src/lib/network/synchronizeable_var/synchronizeable_float.h

-                      r7954
+                      r9406
  * @file synchronizeable_float.h
  * @brief Definition of SynchronizeableFloat
 */
+ */
-#include "synchronizeable_var/synchronizeable_var.h"
 #ifndef _SYNCHRONIZEABLE_FLOAT_H
 #define _SYNCHRONIZEABLE_FLOAT_H
+#include "synchronizeable_var.h"
 class SynchronizeableFloat : public SynchronizeableVar {
   public:
     SynchronizeableFloat( float * ptrIn, float * ptrOut, std::string name, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableFloat( float * ptrIn, float * ptrOut, std::string name, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableFloat();
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
     /**
      * check if writeToBuf will return the same size every time
 …
      */
     virtual bool hasStaticSize(){ return true; };
     virtual void debug();
   private:
     float * vPtrIn;       //!< pointer to data (read)

trunk/src/lib/network/synchronizeable_var/synchronizeable_int.cc

r7954	r9406
18	18	#include "converter.h"
19	19
	20	#include <cassert>
20	21
21	22	/**
…	…
46	47	{
47	48	int res = Converter::intToByteArray( *vPtrIn, buf, maxLength );
48
	49
49	50	assert( res == INTSIZE );
50
	51
51	52	return res;
52	53	}
…	…
61	62	{
62	63	assert( maxLength >= INTSIZE );
63
	64
64	65	int oldVal = *vPtrOut;
65
	66
66	67	int res = Converter::byteArrayToInt( buf, vPtrOut );
67
	68
68	69	setHasChanged( oldVal != *vPtrOut );
69
	70
70	71	assert( res == INTSIZE );
71
	72
72	73	return res;
73	74	}

trunk/src/lib/network/synchronizeable_var/synchronizeable_int.h

-                      r7954
+                      r9406
 */
-#include "synchronizeable_var/synchronizeable_var.h"
 #ifndef _SYNCHRONIZEABLE_INT_H
 #define _SYNCHRONIZEABLE_INT_H
+#include "synchronizeable_var.h"
 class SynchronizeableInt : public SynchronizeableVar {
   public:
     SynchronizeableInt( int * ptrIn, int * ptrOut, std::string name, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableInt( int * ptrIn, int * ptrOut, std::string name, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableInt();
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
     /**
      * check if writeToBuf will return the same size every time
 …
      */
     virtual bool hasStaticSize(){ return true; };
     virtual void debug();
   protected:
     int * vPtrIn;       //!< pointer to data (read)

trunk/src/lib/network/synchronizeable_var/synchronizeable_quaternion.cc

-                      r7954
+                      r9406
 #include "synchronizeable_quaternion.h"
 #include "converter.h"
+#include <cassert>
 …
   assert( res > 0 );
   n += res;
   Quaternion oldVal = *vPtrOut;
   *vPtrOut = Quaternion( Vector(x, y, z), w );
   setHasChanged( ! ( oldVal == *vPtrOut ) );

trunk/src/lib/network/synchronizeable_var/synchronizeable_quaternion.h

-                      r7954
+                      r9406
 */
-#include "synchronizeable_var/synchronizeable_var.h"
 #ifndef _SYNCHRONIZEABLE_QUATERNION_H
 #define _SYNCHRONIZEABLE_QUATERNION_H
+#include "synchronizeable_var.h"
 #include "quaternion.h"
 …
   public:
     SynchronizeableQuaternion( Quaternion * ptrIn, Quaternion * ptrOut, std::string name, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableQuaternion( Quaternion * ptrIn, Quaternion * ptrOut, std::string name, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableQuaternion();
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
     /**
      * check if writeToBuf will return the same size every time
 …
      */
     virtual bool hasStaticSize(){ return true; };
     virtual void debug();
   private:
     Quaternion * vPtrIn;       //!< pointer to data (read)

trunk/src/lib/network/synchronizeable_var/synchronizeable_string.cc

r8147	r9406
17	17	#include "synchronizeable_string.h"
18	18	#include "converter.h"
	19	#include <cassert>
19	20
20	21
…	…
46	47	{
47	48	int res = Converter::stringToByteArray( *vPtrIn, buf, maxLength );
48
	49
49	50	assert( res > 0 );
50	51	assert( res == vPtrIn->length()+INTSIZE );
51
	52
52	53	return res;
	54	}
	55
	56	int SynchronizeableString::getSize()
	57	{
	58	return vPtrIn->length()+INTSIZE;
53	59	}
54	60
…	…
62	68	{
63	69	std::string oldVal = *vPtrOut;
64
	70
65	71	int res = Converter::byteArrayToString( buf, *vPtrOut, maxLength );
66
	72
67	73	setHasChanged( oldVal != *vPtrOut );
68
	74
69	75	if ( res < 0 )
70	76	{
…	…
72	78	}
73	79	assert( res > 0 );
74
	80
75	81	return res;
76	82	}
…	…
94	100	{
95	101	std::string t;
96
	102
97	103	int res = Converter::byteArrayToString( buf, t, maxLength );
98
	104
99	105	assert( res > 0 );
100
	106
101	107	return res;
102	108	}

trunk/src/lib/network/synchronizeable_var/synchronizeable_string.h

-                      r7954
+                      r9406
 */
-#include "synchronizeable_var/synchronizeable_var.h"
-#include "converter.h"
 #ifndef _SYNCHRONIZEABLE_STRING_H
 #define _SYNCHRONIZEABLE_STRING_H
+#include "synchronizeable_var.h"
 #include <string>
 …
   public:
     SynchronizeableString( std::string * ptrIn, std::string * ptrOut, std::string name, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableString( std::string * ptrIn, std::string * ptrOut, std::string name, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableString();
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
     /**
      * check if writeToBuf will return the same size every time
 …
      */
     virtual bool hasStaticSize(){ return false; };
     virtual int getSize(){ return vPtrIn->length()+INTSIZE; }
+    virtual int getSize();
     virtual int getSizeFromBuf( byte * buf, int maxLength );
     virtual void debug();
   private:
     std::string * vPtrIn;       //!< pointer to data (read)

trunk/src/lib/network/synchronizeable_var/synchronizeable_uint.h

-                      r7954
+                      r9406
 */
-#include "synchronizeable_var/synchronizeable_int.h"
 #ifndef _SYNCHRONIZEABLE_UINT_H
 #define _SYNCHRONIZEABLE_UINT_H
+#include "synchronizeable_int.h"
 class SynchronizeableUInt : public SynchronizeableInt {
   public:
     SynchronizeableUInt( unsigned int * ptrIn, unsigned int * ptrOut, std::string name, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableUInt( unsigned int * ptrIn, unsigned int * ptrOut, std::string name, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableUInt();
     virtual void debug();

trunk/src/lib/network/synchronizeable_var/synchronizeable_var.cc

-                      r7954
+                      r9406
 #include "synchronizeable_var.h"
+#include "netdefs.h"
+#include <cassert>

trunk/src/lib/network/synchronizeable_var/synchronizeable_var.h

-                      r7954
+                      r9406
 #define _SYNCHRONIZEABLE_VAR_H
+#include "nettypes.h"
 #include <string>
-#include "netdefs.h"
-#include <assert.h>
 enum {
+  PERMISSION_SERVER = 1,
+  PERMISSION_OWNER  = 2,
+  PERMISSION_ALL    = 4
+  PERMISSION_MASTER_SERVER = 1,
+  PERMISSION_PROXY_SERVER  = 2,
+  PERMISSION_OWNER         = 4,
+  PERMISSION_ALL           = 8
 };
 …
   public:
     SynchronizeableVar( void * ptrIn, void * ptrOut, std::string name, int length, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableVar( void * ptrIn, void * ptrOut, std::string name, int length, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableVar();
 …
      */
     inline bool beWatched(){ return this->bWatched; }
     /**
+    /**
      * set flag if synchronizeable wants to be informed on changes
      */
 …
      */
     inline void resetPriority() { this->priority = this->realPriority; }
     /**
      * reads actual size from buffer. this is used when size is not constant
 …
      */
     virtual inline int getSizeFromBuf( byte * buf, int maxLength ){ return this->getSize(); }
     /**
      * set variable id
 …
      */
     inline void setVarId( int id ){ this->varId = id; }
     /**
+    /**
      * get variable id
      * @return variable id
      */
     inline int getVarId(){ return varId; }
     /**
      * set hasChanged
 …
      */
     inline void setHasChanged( bool changed ){ this->changed = changed; }
     /**
+    /**
      * get hasChanged
      * @return variable id
      */
     inline bool getHasChanged(){ return changed; }
     /**
      * print out variable value
 …
   private:
     bool bWatched;      //!< true if synchronizeable wants to be informed on changes
     int permission;     //!< who is allowed to change this var
     int priority;       //!< priority assigned to var
     int realPriority;   //!< priority assigned to var, increased every time not sent
     int varId;          //!< id to identify varables
     bool changed;       //!< true if last readFromBuf changed anything

trunk/src/lib/network/synchronizeable_var/synchronizeable_vector.cc

-                      r7954
+                      r9406
 #include "synchronizeable_vector.h"
 #include "converter.h"
+#include <cassert>
 …
   int res;
   int n = 0;
   Vector oldVec = *vPtrOut;
 …
   *vPtrOut = Vector( x, y, z );
   setHasChanged( !(*vPtrOut == oldVec) );

trunk/src/lib/network/synchronizeable_var/synchronizeable_vector.h

-                      r7954
+                      r9406
 */
-#include "synchronizeable_var/synchronizeable_var.h"
 #ifndef _SYNCHRONIZEABLE_VECTOR_H
 #define _SYNCHRONIZEABLE_VECTOR_H
+#include "synchronizeable_var.h"
 #include "vector.h"
 …
   public:
     SynchronizeableVector( Vector * ptrIn, Vector * ptrOut, std::string name, int permission = PERMISSION_SERVER, int priority = 0 );
+    SynchronizeableVector( Vector * ptrIn, Vector * ptrOut, std::string name, int permission = PERMISSION_MASTER_SERVER, int priority = 0 );
     virtual ~SynchronizeableVector();
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
     /**
      * check if writeToBuf will return the same size every time
 …
      */
     virtual bool hasStaticSize(){ return true; }
     virtual void debug();
   private:
     Vector * vPtrIn;       //!< pointer to data (read)

trunk/src/lib/network/tcp_server_socket.cc

r7954	r9406
136	136	_isListening = false;
137	137	}
	138

trunk/src/lib/network/tcp_server_socket.h

-                      r7954
+                      r9406
     virtual void close();
     virtual void update() {};
   private:
     TCPsocket listenSocket;
 …
     void init();
 };

trunk/src/lib/network/tcp_socket.h

-                      r7954
+                      r9406
 /*!
  * @file network_socket.h
   *  Main interface for the network module. Manages all the modules
+ * @file tcp_socket.h
+  *  tcp socket network interface
 */
 …
 #define _INCOMING_BUFFER_SIZE 2024000
 #define _OUTGOING_BUFFER_SIZE 2024000
 #define _LOCAL_BUFFER_SIZE 1024
+#define _LOCAL_BUFFER_SIZE 2048
 //sleep if incoming buffer is full
 #define _MSECONDS_SLEEP_FULL_BUFFER 10
 …
     virtual void connectToServer( std::string host, int port );
     virtual void disconnectServer();
+    virtual void reconnectToServer( std::string host, int port);
+    virtual void reconnectToServerSoft( std::string host, int port);
     virtual bool writePacket(byte * data, int length);

trunk/src/lib/network/udp_socket.cc

-                      r8802
+                      r9406
+{
   this->init();
+  this->ip = ip;
   this->serverSocket = serverSocket;
   this->userId = userId;
 …
   assert( serverSocket == NULL );
-  IPaddress ip;
   this->randomByte = generateNewRandomByte();
   PRINTF(0)("connect to server %s on port %d\n", host.c_str(), port);
   if ( SDLNet_ResolveHost( &ip, host.c_str(), port ) != 0 )
+  if ( SDLNet_ResolveHost( &this->ip, host.c_str(), port ) != 0 )
+  {
     PRINTF(1)("SDLNet_ResolveHost: %s\n", SDLNet_GetError() );
 …
+  }
   int channel = SDLNet_UDP_Bind(socket, 1, &ip);
+  int channel = SDLNet_UDP_Bind(socket, 1, &this->ip);
   if ( channel == -1 )
+  {
 …
   bOk = false;
   socket = NULL;
+}
+  this->ip.host = 0;
+  this->ip.port = 0;
+}
+/**
+ * reconnects to
+ * @param host new server address
+ * @param port new port number
+ *
+ * this terminates the current connection and starts a new connection to the new server
+ */
+void UdpSocket::reconnectToServer( std::string host, int port)
+{
+  // first disconnect the old server
+  this->disconnectServer();
+  // now connect to the new
+  this->connectToServer( host, port);
+}
+/**
+ * reconnects to
+ * @param host new server address
+ * @param port new port number
+ *
+ * this terminates the current connection and starts a new connection to the new server
+ */
+void UdpSocket::reconnectToServerSoft( std::string host, int port)
+{}
 /**
 …
     byte udpCmd = 0;
     if ( networkPacket.length > 0 )
+    {
 …
     else
       return 0;
     if ( !checkRandomByte( networkPacket.data[0] ) )
       return 0;
 …
       networkPacket.data = NULL;
+    }
     if ( !checkUdpCmd( udpCmd ) )
       return 0;
 …
+  {
     int numrecv = SDLNet_UDP_Recv( socket, packet);
     byte udpCmd = 0;
 …
       else
         return 0;
       if ( !checkRandomByte( packet->data[0] ) )
         return 0;
       if ( !checkUdpCmd( udpCmd ) )
         return 0;
 …
     return false;
+  }
   if ( !this->serverSocket && ( udpCmd & UDPCMD_INVALIDRNDBYTE ) )
+  {
 …
     return false;
+  }
   return true;
+}
 …
   srand( SDL_GetTicks() );
   byte res = ( rand() & 0xFC );
   PRINTF(0)("generated random byte: %x\n", res);
   return res;
+}

trunk/src/lib/network/udp_socket.h

-                      r8802
+                      r9406
     virtual void connectToServer( std::string host, int port );
     virtual void disconnectServer();
+    virtual void reconnectToServer( std::string host, int port);
+    virtual void reconnectToServerSoft( std::string host, int port);
     virtual bool writePacket(byte * data, int length );
+    virtual int readPacket(byte * data, int maxLength);
+    virtual int readPacket(byte * data, int maxLength);
   private:
     UdpServerSocket * serverSocket;   //!< will get packets here
     int               userId;         //!< user id used by serverSocket
-    IPaddress         ip;             //!< host,port
     UDPsocket         socket;         //!< socket used to send/recieve
     UDPpacket *       packet;
     byte              randomByte;     //!< contains random bytes & 0xFC
     bool writeRawPacket( byte * data, int length );
     bool checkUdpCmd( byte udpCmd );
     bool checkRandomByte( byte rndByte );
     byte generateNewRandomByte();
     void init();

Context Navigation

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

Legend:

Download in other formats: