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

trunk/src/lib/network/Makefile.am

-                      r7026
+                      r7954
                       network_protocol.cc \
                       server_socket.cc \
+                      tcp_server_socket.cc \
+                      tcp_socket.cc \
+                      udp_server_socket.cc \
+                      udp_socket.cc \
                       handshake.cc \
                       network_game_manager.cc \
+                      converter.cc
+                      converter.cc \
+                      message_manager.cc \
+                      network_log.cc \
+                      zip.cc \
+                      \
+                      synchronizeable_var/synchronizeable_var.cc \
+                      synchronizeable_var/synchronizeable_vector.cc \
+                      synchronizeable_var/synchronizeable_int.cc \
+                      synchronizeable_var/synchronizeable_quaternion.cc \
+                      synchronizeable_var/synchronizeable_string.cc \
+                      synchronizeable_var/synchronizeable_float.cc \
+                      synchronizeable_var/synchronizeable_bool.cc \
+                      synchronizeable_var/synchronizeable_uint.cc
 …
                  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
+                 netdefs.h \
+                 message_manager.h \
+                 network_log.h \
+                 zip.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

trunk/src/lib/network/connection_monitor.cc

-                      r5822
+                      r7954
 ### File Specific:
    main-programmer: Silvan Nellen
+   main-programmer: Christoph Renner
    co-programmer: ...
 */
 #include "connection_monitor.h"
+#include "network_log.h"
 #include <debug.h>
 #include <SDL/SDL.h>
 …
 using namespace std;
+ConnectionMonitor::ConnectionMonitor()
+{
+/**
+ * constructor
+ * @param userId user's id
+ */
+ConnectionMonitor::ConnectionMonitor( int userId )
+{
   /* set the class id for the base object and add ist to class list*/
   this->setClassID(CL_CONNECTION_MONITOR, "ConnectionMonitor");
+  /*initialize variables*/
+  /*Data of the lifetime of the ConnectionMonitor Object*/
+  packetToAverage = 100;
+  protocollType = "default(TCP)";
+  startTime= SDL_GetTicks();
+  totalReceivedPackets=0;
+  averageDatarate=0;
+  totalLostPackets=0;
+  totalPacketloss=0;
+  /*Data of the current packet*/
+  currentPacketID=0;
+  currentPacketTick=0;
+  lastPacketID=0;
+  lastPacketTick=0;
+  currentDelay=0;
+  /*Data of the last n packets (n is specified by paxketsToAverage)*/
+  sizeOfLastFewPackets=0;
+  currentDatarate=0;
+  lastFewDelays = new unsigned int [packetToAverage];
+  lastFewPackets = new byte* [packetToAverage];
+  packetCounter=0;
+}
+ConnectionMonitor::~ConnectionMonitor()
+{
+}
+void ConnectionMonitor::processPacket(byte* currentPacket, unsigned int packetLength)
+{
+  /*Process the current Packet*/
+  currentPacketTick = SDL_GetTicks();
+  currentDelay = currentPacketTick - lastPacketTick;
+  /*Do whats needed for Averaging*/
+  if(packetCounter == packetToAverage)
+    {
+      computeCurrentDatarate();
+      displayStatistic();
+      packetCounter = 0;
+      sizeOfLastFewPackets = 0;
+    }
+  lastFewDelays[packetCounter] = currentDelay;
+  lastFewPackets[packetCounter] = currentPacket;
+  sizeOfLastFewPackets += packetLength;
+  /*Update the lifetime Variables*/
+  totalReceivedPackets ++;
+  float timeDiff = this->currentPacketTick - this->startTime;
+  if( timeDiff != 0.0f )
+    averageDatarate = totalReceivedPackets/timeDiff;
+  /*Preparefor the next Packet*/
+  lastPacketTick = currentPacketTick;
+  packetCounter++;
+}
+/* Compute the value of current Datarate*/
+void ConnectionMonitor::computeCurrentDatarate()
+{
+  int timeForLastFewPackets=0;
+  for(int i=0;i < packetToAverage;i++)
+    timeForLastFewPackets += lastFewDelays[i];
+  if( timeForLastFewPackets != 0)
+    currentDatarate = sizeOfLastFewPackets/timeForLastFewPackets;
+}
+void doUDPRelatedStuff()
+{
+  /*  Do protocol related stuff
+  Only for Udp:
+  "currentPacketID = getID from package";
+  if(currentPacketID - lastPacketID > 1)
+  this->userId = userId;
+  this->ping = 0;
+  this->incomingUnzippedBandWidth = 0;
+  this->outgoingUnzippedBandWidth = 0;
+  this->incomingZippedBandWidth = 0;
+  this->outgoingZippedBandWidth = 0;
+  this->nIncomingPackets = 0;
+  this->nOutgoingPackets = 0;
+  this->nZIncomingPackets = 0;
+  this->nZOutgoingPackets = 0;
+  this->lastPacketTick = 0;
+  this->lastPrintTick = 0;
+}
+/**
+ * deconstructor
+ */
+ConnectionMonitor::~ConnectionMonitor( )
+{
+}
+/**
+ * process unzipped outgoing packet
+ * @param data pointer to packet data
+ * @param length length of packet
+ * @param stateId packet's state id
+ */
+void ConnectionMonitor::processUnzippedOutgoingPacket( byte * data, int length, int stateId )
+{
+  int tick = SDL_GetTicks();
+  nOutgoingPackets++;
+  // for ping calculation
+  sentStateTicks[stateId] = tick;
+  // calculate bandwidth
+  outgoingUnzippedPacketHistory[tick] = length;
+  outgoingUnzippedBandWidth = calculateBandWidth( outgoingUnzippedPacketHistory, tick );
+  //NETPRINTF(n)("UNZIPPED UPSTREAM: user: %d bandwidth %f\n", userId, outgoingUnzippedBandWidth );
+  // count zero bytes
+  int nZeroBytes = 0;
+  for ( int i = 0; i < length; i++ )
+    if ( data[i] == '\0' )
+      nZeroBytes++;
+  //NETPRINTF(n)( "ZEROBYTES: %d (%f%%)\n", nZeroBytes, ((float)100)*nZeroBytes/length );
+}
+/**
+ * process unzipped incoming packet
+ * @param data pointer to packet data
+ * @param length length of packet
+ * @param stateId packet's state id
+ * @param ackedState state which was acked by this packet
+ */
+void ConnectionMonitor::processUnzippedIncomingPacket( byte * data, int length, int stateId, int ackedState )
+{
+  int tick = SDL_GetTicks();
+  nIncomingPackets++;
+  lastPacketTick = tick;
+  // calculate ping
+  if ( sentStateTicks.find( ackedState ) != sentStateTicks.end() )
+  {
+  totalLostPackets += currentPacketID - lastPacketID;
+}
+  totalPacketloss = (totalLostPackets/totalReceivedPackets)*100 ;
+  */
+}
+/* Display connectoin statistic*/
+void ConnectionMonitor::displayStatistic()
+{
+//   PRINT(0)("============================================\n");
+//   PRINT(0)("Connection Monitor Network Statistics:\n");
+//   PRINT(0)("Total received packets:",totalReceivedPackets);
+//   PRINT(0)("Average datarate :\n",averageDatarate);
+//   PRINT(0)("Total lost packets:",totalLostPackets);
+//   PRINT(0)("Packetloss [%] :\n",totalPacketloss);
+//
+//   PRINT(0)("Current datarate :\n",currentDatarate);
+//   PRINT(0)("Delays of the last few packets :\n");
+//   for(int i=1 ;i <= packetToAverage-1;i++)
+//     PRINT(0)("%i ",lastFewDelays[i]);
+//
+//   PRINT(0)("============================================\n");
+}
+    ackDelay.push_back( tick - sentStateTicks[ackedState] );
+  }
+  while ( sentStateTicks.begin() != sentStateTicks.end() && sentStateTicks.begin()->first <= ackedState )
+    sentStateTicks.erase( sentStateTicks.begin() );
+  while ( ackDelay.size() > N_PACKETS_FOR_PING )
+    ackDelay.erase( ackDelay.begin() );
+  ping = 0;
+  for ( std::list<int>::iterator it = ackDelay.begin(); it != ackDelay.end(); it++ )
+    ping += *it;
+  if ( ackDelay.size() == 0 )
+    ping = -1;
+  else
+    ping /= ackDelay.size();
+  //NETPRINTF(n)("PING: user: %d ping: %d\n", userId, ping );
+  // calculate bandwidth
+  incomingUnzippedPacketHistory[tick] = length;
+  incomingUnzippedBandWidth = calculateBandWidth( incomingUnzippedPacketHistory, tick );
+  //NETPRINTF(n)("UNZIPPED DOWNSTREAM: user: %d bandwidth %f\n", userId, incomingUnzippedBandWidth );
+}
+/**
+ * calculate bandwidth out of packethistory
+ * @param packetHistory packet history
+ * @param tick current tick from SDL_GetTicks
+ * @return bandwidth in bytes/sec
+ */
+float ConnectionMonitor::calculateBandWidth( std::map< int, int > packetHistory, int tick )
+{
+  // delete old packets
+  while ( packetHistory.begin()->first < tick - MSECS_TO_CALC_BWIDTH )
+    packetHistory.erase( packetHistory.begin() );
+  float res = 0.0f;
+  for ( std::map<int,int>::iterator it = packetHistory.begin(); it != packetHistory.end(); it++ )
+  {
+    res += it->second;
+  }
+  if ( packetHistory.size() <= 1 || tick - packetHistory.begin()->first == 0 )
+    res = 0.0f;
+  else
+    res /= (float)((tick - packetHistory.begin()->first)*( 1 + 1/((float)(packetHistory.size()-1)) ));
+  res *= 1000.0f;
+  return res;
+}
+/**
+ * process zipped outgoing packet
+ * @param data pointer to packet data
+ * @param length length of packet
+ * @param stateId packet's state id
+ */
+void ConnectionMonitor::processZippedOutgoingPacket( byte * data, int length, int stateId )
+{
+  int tick = SDL_GetTicks();
+  nZOutgoingPackets++;
+  // calculate bandwidth
+  outgoingZippedPacketHistory[tick] = length;
+  outgoingZippedBandWidth = calculateBandWidth( outgoingZippedPacketHistory, tick );
+  //NETPRINTF(n)("UPSTREAM: user: %d bandwidth %f nOutgoingPackets %d\n", userId, outgoingZippedBandWidth, nOutgoingPackets );
+  if ( lastPrintTick < tick-1000 )
+  {
+    printStatis();
+    lastPrintTick = tick;
+  }
+}
+/**
+ * process zipped incoming packet
+ * @param data pointer to packet data
+ * @param length length of packet
+ * @param stateId packet's state id
+ * @param ackedState state which was acked by this packet
+ */
+void ConnectionMonitor::processZippedIncomingPacket( byte * data, int length, int stateId, int ackedState )
+{
+  int tick = SDL_GetTicks();
+  nZIncomingPackets++;
+  // calculate bandwidth
+  incomingZippedPacketHistory[tick] = length;
+  incomingZippedBandWidth = calculateBandWidth( incomingZippedPacketHistory, tick );
+  //NETPRINTF(n)("DOWNSTREAM: user: %d bandwidth %f nIncomingPackets %d\n", userId, incomingZippedBandWidth, nIncomingPackets );
+}
+/**
+ * check if client sent no packets for SECS_TO_TIMEOUT
+ * @return true if last packet recieved \< NOW() - SECS_TO_TIMEOUT
+ */
+bool ConnectionMonitor::hasTimedOut( )
+{
+  if ( lastPacketTick + SECS_TO_TIMEOUT*1000 < SDL_GetTicks() && nIncomingPackets > 0 )
+    return true;
+  if ( nIncomingPackets == 0 && nOutgoingPackets >= NETWORK_FREQUENCY*SECS_TO_TIMEOUT )
+    return true;
+  return false;
+}
+/**
+ * prints bandwith usage, ping and other important things to telnet-console
+ */
+void ConnectionMonitor::printStatis( )
+{
+  NETPRINT(n)("=========NETWORKSTATS FOR USER %d=========\n", userId);
+  NETPRINT(n)("PING = %d\n", ping);
+  NETPRINT(n)("BANDWIDTH: UP: %f (%f) DOWN %f (%f)\n", outgoingZippedBandWidth, outgoingUnzippedBandWidth, incomingZippedBandWidth, incomingUnzippedBandWidth);
+  NETPRINT(n)("==========================================");
+}

trunk/src/lib/network/connection_monitor.h

-                      r6981
+                      r7954
 #include "netdefs.h"
+#include <map>
+#define N_PACKETS_FOR_PING 20
+#define MSECS_TO_CALC_BWIDTH 1000
+#define SECS_TO_TIMEOUT 10
 class ConnectionMonitor : virtual public BaseObject
+  {
+{
   public:
     ConnectionMonitor();
+    ConnectionMonitor( int userId );
     virtual ~ConnectionMonitor();
+    void                processPacket(byte* packet, unsigned int packetLength);
+    void processUnzippedOutgoingPacket( byte * data, int length, int stateId );
+    void processUnzippedIncomingPacket( byte * data, int length, int stateId, int ackedState );
+    void processZippedOutgoingPacket( byte * data, int length, int stateId );
+    void processZippedIncomingPacket( byte * data, int length, int stateId, int ackedState );
+    void calculatePing();
+    bool hasTimedOut();
+    void printStatis();
+  private:
+    float calculateBandWidth( std::map<int,int> packetHistory, int tick );
+    int userId;       //!< user's id
+    std::map<int,int>   sentStateTicks;
+    std::map<int,int>   incomingUnzippedPacketHistory;
+    std::map<int,int>   outgoingUnzippedPacketHistory;
+    std::map<int,int>   incomingZippedPacketHistory;
+    std::map<int,int>   outgoingZippedPacketHistory;
+    std::list<int>      ackDelay;
+    int                 ping;
+  private:
+    void                displayStatistic();
+    void                computeCurrentDatarate();
+    void                doUDPRelatedStuff();
+    /*Data of the lifetime of the ConnectionMonitor Object*/
+    unsigned int        packetToAverage;
+    char*               protocollType;
+    unsigned int        totalReceivedPackets;
+    float               averageDatarate;
+    unsigned int        totalLostPackets;
+    float               totalPacketloss;
+    unsigned int        startTime;
+    /*Data of the current packet*/
+    unsigned int        currentPacketID;
+    unsigned int        currentPacketTick;
+    unsigned int        lastPacketID;
+    unsigned int        lastPacketTick;
+    unsigned int        currentDelay;
+    /*Data of the last n packets (n is specified by paxketsToAverage)*/
+    unsigned int        sizeOfLastFewPackets;
+    unsigned int        currentDatarate;
+    byte**              lastFewPackets;
+    unsigned int*       lastFewDelays;
+    unsigned int        packetCounter;
+    float               incomingUnzippedBandWidth;
+    float               outgoingUnzippedBandWidth;
+    float               incomingZippedBandWidth;
+    float               outgoingZippedBandWidth;
+    int                 nIncomingPackets;
+    int                 nOutgoingPackets;
+    int                 nZIncomingPackets;
+    int                 nZOutgoingPackets;
+    int                 lastPacketTick;
+    int                 lastPrintTick;
   };

trunk/src/lib/network/converter.cc

-                      r7230
+                      r7954
+  {
     PRINTF(1)("something went wrong length > remaining bytes in buffer\n" );
+    //TODO remove this
+    for ( int i = -1000; i < 1001; i++ )
+    {
+      if ( ( a[i] > 'a' && a[i] < 'z' ) || ( a[i] > 'A' && a[i] < 'Z' ) )
+        printf("%c", a[i]);
+      else
+        printf(".");
+    }
+    printf("\n");
     s = "";
     return -1;
+  }
   s[0] = '\0';
+  s = "";
   s.append( (char*)a+n, length );

trunk/src/lib/network/data_stream.cc

r5822	r7954
16	16	/* include Data_stream Header */
17	17	#include "data_stream.h"
18
19
20	18
21	19

trunk/src/lib/network/handshake.cc

-                      r6815
+                      r7954
 #include <cassert>
 Handshake::Handshake( bool server, int clientId, int networkGameManagerId )
+Handshake::Handshake( bool server, int clientId, int networkGameManagerId, int messageManagerId )
   : Synchronizeable()
+{
 …
   this->setIsServer(server);
+  this->clientId = clientId;
+  this->networkGameManagerId = networkGameManagerId;
+  this->state = 0;
+  this->isOk = false;
+  this->setOwner(0);
+  orxId_handler = registerVarId( new SynchronizeableInt( &localState.orxId, &remoteState.orxId, "orxonoxId", PERMISSION_ALL ) );
+  version_handler = registerVarId( new SynchronizeableInt( &localState.version, &remoteState.version, "version", PERMISSION_ALL ) );
+  netManId_handler = registerVarId( new SynchronizeableInt( &localState.networkManagerId, &remoteState.networkManagerId, "networkManagerId", PERMISSION_ALL ) );
+  msgManId_handler = registerVarId( new SynchronizeableInt( &localState.messageManagerId, &remoteState.messageManagerId, "messageManagerId", PERMISSION_ALL ) );
+  hostId_handler = registerVarId( new SynchronizeableInt( &localState.hostId, &remoteState.hostId, "hostId", PERMISSION_ALL ) );
+  completed_handler = registerVarId( new SynchronizeableInt( &localState.completed, &remoteState.completed, "completed", PERMISSION_ALL ) );
+  error_handler = registerVarId( new SynchronizeableInt( &localState.error, &remoteState.error, "error", PERMISSION_ALL ) );
+  errorString_handler = registerVarId( new SynchronizeableString( &localState.errorString, &remoteState.errorString, "errorString", PERMISSION_ALL ) );
+  candel_id = registerVarId( new SynchronizeableInt( &localState.canDel, &remoteState.canDel, "canDel", PERMISSION_ALL ) );
+  localState.completed = 0;
+  localState.error = 0;
+  localState.errorString = "";
+  localState.hostId = clientId;
+  localState.networkManagerId = networkGameManagerId;
+  this->localState.messageManagerId = messageManagerId;
+  localState.orxId = _ORXONOX_ID;
+  localState.version = _ORXONOX_VERSION;
+  localState.canDel = 0;
+  remoteState.completed = 0;
+  remoteState.error = 0;
+  remoteState.errorString = "";
+  remoteState.hostId = -1;
+  remoteState.networkManagerId = -1;
+  remoteState.messageManagerId = -1;
+  remoteState.orxId = 0;
+  remoteState.version = 0;
+  remoteState.canDel = 0;
   this->setSynchronized(true);
   PRINTF(5)("Handshake created clientId = %d\n", clientId);
+  PRINTF(0)("Handshake created clientId = %d\n", clientId);
+}
+int Handshake::writeBytes( const byte * data, int length, int sender)
+/**
+ * handler for changes in synced vars
+ * @param id id's which have changed
+ */
+void Handshake::varChangeHandler( std::list< int > & id )
+{
+  PRINTF(5)("Handshake::writeBytes states = %d %d %d %d (%d)\n", hasState( HS_RECVD_INIT ), hasState( HS_RECVD_VER ), hasState( HS_RECVD_HID ), hasState( HS_COMPLETED ), state);
+  for ( std::list<int>::iterator it = id.begin(); it != id.end(); it++ )
+  {
+    if ( *it == orxId_handler )
+    {
+      if ( remoteState.orxId != _ORXONOX_ID )
+      {
+        localState.error = 1;
+        localState.completed = 1;
+        localState.errorString = "Seems not to be orxonox!";
+        continue;
+      }
+  SYNCHELP_READ_BEGIN();
+    }
+    if ( *it == version_handler )
+    {
+      if ( remoteState.version != _ORXONOX_VERSION )
+      {
+        localState.error = 2;
+        localState.completed = 1;
+        localState.errorString = "Versions of server and client do not match!";
+        continue;
+      }
+  if ( hasState( HS_COMPLETED ) )
+       return 0;
+  if ( !hasState( HS_RECVD_INIT ) )
+  {
+    if ( length != _INITIAL_DATA_LENGTH )
+    }
+    if ( *it == candel_id )
+    {
+      PRINTF(0)("initial packet has wrong size %d instead of %d\n", length, _INITIAL_DATA_LENGTH);
+      setState( HS_COMPLETED );
+      return 0;
+      PRINTF(0)("handshake finished candel changed\n");
+    }
+    if ( strncmp((char*)data, _INITIAL_DATA, length) )
+    {
+      PRINTF(0)("initial packed does not match\n");
+      setState( HS_COMPLETED );
+      return length;
+    }
+    setState( HS_RECVD_INIT );
+    PRINTF(0)("got valid initial packet from client %d\n", clientId);
+    return length;
+  }
+  if ( hasState( HS_RECVD_INIT ) && !hasState( HS_RECVD_VER ) )
+  {
+    if ( length != _ORXONOX_VERSION_LENGTH )
+    {
+      PRINTF(0)("version number packet has wrong size %d instead of %d\n", length, _ORXONOX_VERSION_LENGTH);
+      setState( HS_COMPLETED );
+      return 0;
+    }
+    if ( strncmp((char*)data, _ORXONOX_VERSION, length) )
+    {
+      PRINTF(0)("versions do not match\n");
+      setState( HS_COMPLETED );
+      return length;
+    }
+    setState( HS_RECVD_VER );
+    PRINTF(0)("client %d's version does match\n", clientId);
+    return length;
+  }
+  if ( !isServer() && hasState( HS_RECVD_VER ) && !hasState( HS_RECVD_HID ) )
+  {
+    /*if ( length != INTSIZE+INTSIZE )
+    {
+      PRINTF(0)("hostID packet has wrong size %d instead of %d\n", length, INTSIZE+INTSIZE);
+      setState( HS_COMPLETED );
+      return 0;
+  }*/
+    setState( HS_COMPLETED );
+    setState( HS_RECVD_HID );
+    this->isOk = true;
+    SYNCHELP_READ_INT( this->newHostId, NWT_HS_HOST_ID );
+    SYNCHELP_READ_INT( this->newNetworkGameManagerId, NWT_HS_NGM_ID );
+    if ( newHostId == 0 )
+    {
+      setState( HS_WAS_REJECT );
+      isOk = false;
+      PRINTF(0)("Server did not accept handshake!\n");
+    }
+    else
+    {
+      PRINTF(0)("got my hostID: %d and networkGameManagerId: %d\n", newHostId, newNetworkGameManagerId);
+    }
+    return SYNCHELP_READ_N;
+  }
+  if (
+      remoteState.orxId == _ORXONOX_ID &&
+      remoteState.version == _ORXONOX_VERSION
+     )
+    localState.completed = 1;
+}
-int Handshake::readBytes( byte * data, int maxLength, int * reciever )
+{
-  PRINTF(5)("Handshake::readBytes states = %d %d %d %d (%d)\n", hasState( HS_SENT_INIT ), hasState( HS_SENT_VER ), hasState( HS_SENT_HID ), hasState( HS_COMPLETED ), state);
-  SYNCHELP_WRITE_BEGIN();
-  if ( hasState( HS_COMPLETED ) )
-    return 0;
-  if ( !hasState( HS_SENT_INIT ) )
+  {
-    if ( maxLength < _INITIAL_DATA_LENGTH )
+    {
-      PRINTF(0)("buffer too small for _INITIAL_DATA");
-      setState( HS_COMPLETED );
-      return 0;
+    }
-    setState( HS_SENT_INIT );
-    memcpy(data, _INITIAL_DATA, _INITIAL_DATA_LENGTH);
-    if ( this->isServer() )
-      *reciever = clientId;
-    return _INITIAL_DATA_LENGTH;
+  }
-  if ( hasState( HS_RECVD_INIT ) && hasState( HS_SENT_INIT ) && !hasState( HS_SENT_VER ) )
+  {
-    if ( maxLength < _ORXONOX_VERSION_LENGTH )
+    {
-      PRINTF(0)("buffer too small for version number");
-      setState( HS_COMPLETED );
-      return 0;
+    }
-    setState( HS_SENT_VER );
-    memcpy(data, _ORXONOX_VERSION, _ORXONOX_VERSION_LENGTH);
-    if ( this->isServer() )
-      *reciever = clientId;
-    return _ORXONOX_VERSION_LENGTH;
+  }
-  if ( isServer() && hasState( HS_RECVD_VER) && hasState( HS_SENT_VER ) && !hasState( HS_SENT_HID ) )
+  {
-    if ( maxLength < 2 )
+    {
-      PRINTF(0)("buffer too small for ID");
-      setState( HS_COMPLETED );
-      return 0;
+    }
-    setState( HS_SENT_HID );
-    setState( HS_COMPLETED );
-    if ( hasState( HS_DO_REJECT ) )
+    {
-      isOk = false;
-      //memcpy(data, (byte*)0, 4);
-      SYNCHELP_WRITE_INT( 0, NWT_HS_HOST_ID);
-      SYNCHELP_WRITE_INT( 0, NWT_HS_NGM_ID);
+    }
-    else
+    {
-      isOk = true;
-      //memcpy(data, &clientId, 4);
-      SYNCHELP_WRITE_INT( clientId, NWT_HS_HOST_ID );
-      SYNCHELP_WRITE_INT( networkGameManagerId, NWT_HS_NGM_ID );
+    }
-    *reciever = clientId;
-    return SYNCHELP_WRITE_N;
+  }
-  return 0;
+}
-void Handshake::writeDebug( ) const
+{
+}
-void Handshake::readDebug( ) const
+{
+}

trunk/src/lib/network/handshake.h

-                      r6341
+                      r7954
 #include "synchronizeable.h"
+#define _INITIAL_DATA "orxonox"
+#define _INITIAL_DATA_LENGTH 7
+#define _ORXONOX_ID 0xF91337A0
+#define _ORXONOX_VERSION "\x00\x00\x00\x01"
+#define _ORXONOX_VERSION_LENGTH 4
+#define _ORXONOX_VERSION 1
+typedef enum HandshakeState {
+  HS_SENT_INIT  = 0x00000001,
+  HS_RECVD_INIT = 0x00000002,
+  HS_SENT_VER   = 0x00000004,
+  HS_RECVD_VER  = 0x00000008,
+  HS_SENT_HID   = 0x00000010,
+  HS_RECVD_HID  = 0x00000020,
+  HS_COMPLETED  = 0x00000040,
+  HS_DO_REJECT  = 0x00010000,
+  HS_WAS_REJECT = 0x00020000,
+  NUM_STATES
+struct HandshakeState {
+  int orxId;
+  int version;
+  int networkManagerId;
+  int messageManagerId;
+  int hostId;
+  int completed;
+  int canDel;
+  int error;
+  std::string errorString;
 };
 …
+{
   public:
     Handshake(bool server, int clientId = 0, int networkGameManagerId = 0);
     inline bool       completed(){ return hasState( HS_COMPLETED ); }
     inline bool       ok(){ return isOk; }
     inline int        getHostId(){ return newHostId; }
     inline int        getNetworkGameManagerId(){ return newNetworkGameManagerId; }
     inline void       doReject(){ setState(HS_DO_REJECT); }
     virtual int       writeBytes(const byte* data, int length, int sender);
     virtual int       readBytes(byte* data, int maxLength, int * reciever);
     virtual void      writeDebug() const;
     virtual void      readDebug() const;
+    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; }
+    virtual void varChangeHandler( std::list<int> & id );
   private:
+    int               state;
+    int               clientId;
+    int               networkGameManagerId;
+    int               newHostId;
+    int               newNetworkGameManagerId;
+    bool              isOk;
+    inline bool       hasState( int a ){ return (state & a) == a; }
+    inline void       setState( int a ){ state = state | a; }
+    inline void       unsetState( int a ){ state = state & (~a); }
+    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;
 };

trunk/src/lib/network/netdefs.h

-                      r6695
+                      r7954
 #define MAX_CONNECTIONS 1000
+#define NETWORK_FREQUENCY 33
 typedef unsigned char byte;
 …
 } NodeType;
+typedef enum ConnectionType {
+  NET_UDP = 0,
+  NET_TCP
+};
 typedef enum {

trunk/src/lib/network/network_game_manager.cc

-                      r7354
+                      r7954
 #include "shared_network_data.h"
 #include "converter.h"
+#include "message_manager.h"
 #include "playable.h"
 …
   this->setClassID(CL_NETWORK_GAME_MANAGER, "NetworkGameManager");
-  hasRequestedWorld = false;
   this->setSynchronized(true);
+  MessageManager::getInstance()->registerMessageHandler( MSGID_YOU_ARE, youAreHandler, NULL );
+}
 …
 NetworkGameManager::~NetworkGameManager()
+{
+#if 0
   for ( int i = 0; i<outBuffer.size(); i++)
+  {
 …
       delete outBuffer[i].buffer;
+  }
+}
+#endif
+}
+#if 0
 int NetworkGameManager::writeBytes(const byte* data, int length, int sender)
+{
 …
+    {
       sendEntityList( sender );
-      continue;
+    }
-    else if ( b == NET_REQUEST_SYNC )
+    {
-      if ( !handleRequestSync( i, data, length, sender ) )
-        return i;
       continue;
+    }
 …
   return i;
+}
+#endif
+#if 0
 int NetworkGameManager::readBytes(byte* data, int maxLength, int * reciever)
+{
 …
   return 0;
+}
+#endif
+#if 0
 void NetworkGameManager::writeDebug() const
+{
 …
+{
+}
+#endif
 …
   if ( this->isServer())
+  {
+    if ( SharedNetworkData::getInstance()->getNewUniqueID() < 0 )
+    int res = this->executeCreateEntity( classID, SharedNetworkData::getInstance()->getNewUniqueID(), owner );
+    if ( res < 0 )
+    {
       PRINTF(1)("Cannot create entity! There are no more uniqueIDs left!\n");
       return -1;
+    }
+    return this->executeCreateEntity( classID, SharedNetworkData::getInstance()->getNewUniqueID(), owner );
+    return res;
+  }
   else
+  {
+#if 0
     this->requestCreateEntity( classID );
+#endif
     return -1;
+  }
 …
   else
+  {
+#if 0
     this->requestRemoveEntity( uniqueID );
+  }
+}
+#endif
+  }
+}
+#if 0
 /*!
  * Creates the needed entity on the server if possible
 …
+  }
+}
+#endif
+#if 0
 /*!
  * Removes the specified entity on the server
 …
+  }
+}
+#endif
 /*!
 …
 int NetworkGameManager::executeCreateEntity(ClassID classID, int uniqueID, int owner)
+{
+#if 0
   for ( int i = 0; i<outBuffer.size(); i++)
+  {
 …
       return -1;
+  }
+#endif
   PRINTF(0)("ExecuteCreateEntity: server side: classID: %x, uniqueID: %i, owner: %i\n", classID, uniqueID, owner);
   doCreateEntity( classID, uniqueID, owner );
 …
 void NetworkGameManager::executeRemoveEntity(int uniqueID)
+{
+#if 0
   for ( int i = 0; i<outBuffer.size(); i++)
+  {
 …
       return;
+  }
+#endif
   doRemoveEntity(uniqueID);
 …
+}
+#if 0
 /*!
  * Sends the Entities to the new connected client
 …
   signalNewPlayer( userID );
+}
+#endif
 …
 bool NetworkGameManager::signalNewPlayer(int userId)
+{
-  if ( userId >= outBuffer.size() )
-    resizeBufferVector( userId );
   /* create new playable for Player*/
   PRINTF(0)("Request for creation: %i\n", userId);
 …
   PRINTF(0)("Request for creation: userid: %i, uniqueid: %i\n", userId, uniqueId);
   this->sendYouAre(uniqueId, userId);
+}
 …
+{
   const std::list<BaseObject*>* playableList = ClassList::getList(CL_PLAYABLE);
+  if ( !playableList )
+    return false;
   std::list<BaseObject*>::const_iterator it = playableList->begin();
 …
+}
+#if 0
 /**
  * Creates a buffer for user n
 …
+  }
+}
+#endif
 /**
 …
     s->setSynchronized(true);
     //this->networkStream->connectSynchronizeable( *s );
+    if ( !isServer() )
+      s->setIsOutOfSync( true );
     PRINTF(0)("Fabricated %s with id %d\n", s->getClassName(), s->getUniqueID());
 …
+}
+/**
+ * Tell the synchronizeable that a user's synchronizeable is out of sync
+ * @param uniqueID: unique ID assigned with the entity which is out of sync
+ * @param userID: user ID who's synchronizeable is out of sync
+ */
+void NetworkGameManager::doRequestSync( int uniqueID, int userID )
+{
+  SynchronizeableList::const_iterator it,e;
+  it = this->networkStream->getSyncBegin();
+  e = this->networkStream->getSyncEnd();
+  while ( it != e )
+  {
+    if ( (*it)->getUniqueID() == uniqueID )
+    {
+      (*it)->requestSync( userID );
+      break;
+    }
+    it++;
+  }
+}
+#if 0
 /**
  * Copies length bytes to the clientBuffer with error checking
 …
   return true;
+}
+#endif
+#if 0
 /**
  * Reads data from clientBuffer with error checking
 …
   return true;
+}
+#endif
 /**
 …
       } else
+      {
         PRINTF(1)("UniqueID is not a Playable\n");
+        PRINTF(1)("UniqueID %d is not a Playable\n", uniqueID);
+      }
+    }
 …
   assert(player != NULL);
-  s->setIsOutOfSync( true );
   PRINTF(0)("uniqueID = %d\n", s->getUniqueID());
 …
   if ( !isServer() )
     return;
+  if ( userID != 0 )
+  {
+    if ( !writeToClientBuffer( outBuffer[userID], (byte)NET_YOU_ARE_ENTITY ) )
+      return;
+    if ( !writeToClientBuffer( outBuffer[userID], uniqueID ) )
+      return;
+  }
+  else
+  {
+    doYouAre(uniqueID);
+  }
+  byte buf[INTSIZE];
+  Converter::intToByteArray( uniqueID, buf, INTSIZE );
+  MessageManager::getInstance()->sendMessage( MSGID_YOU_ARE, buf, INTSIZE, RT_USER, userID, MP_HIGHBANDWIDTH);
+}
 …
   return true;
+}
-bool NetworkGameManager::handleRequestSync( int & i, const byte * data, int length, int sender )
+{
-  if ( INTSIZE > length-i )
+  {
-    PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
-    return false;
+  }
-  int uniqueID;
-  i += Converter::byteArrayToInt( &data[i], &uniqueID );
-  PRINTF(0)("handleRequestSync %d %d\n", uniqueID, sender);
-  doRequestSync( uniqueID, sender );
-  return true;
+}
 /**
 …
+}
+bool NetworkGameManager::youAreHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+{
+  assert( dataLength == INTSIZE );
+  int uniqueId;
+  Converter::byteArrayToInt( data, &uniqueId );
+  SynchronizeableList::const_iterator it = NetworkGameManager::getInstance()->networkStream->getSyncBegin();
+  Playable *p = NULL;
+  Synchronizeable *s = NULL;
+  for ( ; it !=NetworkGameManager::getInstance()->networkStream->getSyncEnd(); it++ )
+  {
+    if ( (*it)->getUniqueID()==uniqueId )
+    {
+      break;
+    }
+  }
+  if ( it == NetworkGameManager::getInstance()->networkStream->getSyncEnd() )
+    return false;
+  NetworkGameManager::getInstance()->doYouAre( uniqueId );
+  return true;
+}
+#if 0
 bool NetworkGameManager::writeToClientBuffer( clientBuffer & cb, byte b )
+{
 …
   return true;
+}
 bool NetworkGameManager::writeToClientBuffer( clientBuffer & cb, int i )
 …
   return true;
+}
+void NetworkGameManager::sync( int uniqueID, int owner )
+{
+  /*if ( owner==this->getHostID() )
+  return;*/
+  if ( !isServer() )
+    executeRequestSync( uniqueID, 0 );
+  else
+    executeRequestSync( uniqueID, owner );
+}
+void NetworkGameManager::executeRequestSync( int uniqueID, int user )
+{
+  PRINTF(0)("executeRequestSync %d %d\n", uniqueID, user);
+  if ( user >= outBuffer.size() )
+    resizeBufferVector( user );
+  if ( !writeToClientBuffer( outBuffer[user], (byte)NET_REQUEST_SYNC ) )
+    return;
+  if ( !writeToClientBuffer( outBuffer[user], uniqueID ) )
+    return;
+}
+#endif

trunk/src/lib/network/network_game_manager.h

-                      r6981
+                      r7954
 /* include base_object.h since all classes are derived from this one */
 #include "synchronizeable.h"
+#include "message_manager.h"
 class TiXmlElement;
 class PNode;
-/**
- * protocol definition
+ *
- *  CREATE_ENTITY:       >> CLASS_ID, UNIQUE_ID, OWNER
- *  REMOVE_ENTITY:       >> UNIQUE_ID
+ *
- *  CREATE_ENTITY_LIST:  >> NUMBER, [CLASS_ID, UNIQUE_ID, OWNER][0..NUMBER]
- *  REMOVE_ENTITY_LIST:  >> NUMBER, [UNIQUE_ID][0..NUMBER]
+ *
- *  REQUEST_CREATE:      >> CLASS_ID
- *                       << [Sync Info]
- *  REQUEST_REMOVE:      >> UNIQUE_ID
- *                       << [Sync Info]
+ *
- *  //REQUEST_CREATE_LIST: NUMBER, [CLASS_ID][0..NUMBER]
- *  //REQUEST_CREATE_LIST: NUMBER, [UNIQUE_ID][0..NUMBER]
+ *
- *  REQUEST_ENTITY_LIST: //request the whole world :D
- *  REQUEST_SYNC:        >> UNIQUE_ID
- *                       << [Sync Info]
- *  //REQUEST_SYNC_LIST:   NUMBER, [UNIQUE_ID][0..NUMBER]
+ *
- *  YOU_ARE_ENTITY:      >> UNIQUE_ID
+ *
- *  REQUEST_PNODE_PATH   >> UNIQUE_ID_START   UNIQUE_ID_STOP
- *                       << UNIQUE_ID_1   UNIQUE_ID_2   UNIQUE_ID_3 ...   UNIQUE_ID_N
+ *
- *  SEND_PNODE_PATH      >> UNIQUE_ID_START   UNIQUE_ID_STOP NUMBER [UNIQUE_ID][0..NUMBER]
- */
 typedef enum NetworkGameManagerProtocol {
 …
   NET_REQUEST_CREATE,
   NET_REQUEST_REMOVE,
-  NET_REQUEST_SYNC,
   NET_YOU_ARE_ENTITY,
   NET_REQUEST_ENTITY_LIST,
 …
     { if (!NetworkGameManager::singletonRef) NetworkGameManager::singletonRef = new NetworkGameManager(); return NetworkGameManager::singletonRef; }
+#if 0
     virtual int writeBytes(const byte* data, int length, int sender);
     virtual int readBytes(byte* data, int maxLength, int * reciever);
     virtual void writeDebug() const;
     virtual void readDebug() const;
+#endif
     int createEntity( ClassID classID, int owner = 0 );
 …
     void sendYouAre( int uniqueID, int userID );
+    void sync(int uniqueID, int owner);
+#if 0
     void sendEntityList(int userID);
+#endif
     bool signalNewPlayer(int userId);
 …
   private:
     NetworkGameManager();
+    static bool youAreHandler(MessageId messageId, byte * data, int dataLength, void * someData, int userId );
 …
     bool handleRemoveEntityList( int& i, const byte* data, int length, int sender );
     bool handleYouAreEntity( int& i, const byte* data, int length, int sender );
-    bool handleRequestSync( int& i, const byte* data, int length, int sender );
     bool handleRequestPNodePath(int& i, const byte* data, int length, int sender);
     bool handleSendPNodePath(int& i, const byte* data, int length, int sender);
 …
     /* some network handlers helper functions */
     void requestCreateEntity(ClassID classID);
+//    void requestCreateEntity(ClassID classID);
     int executeCreateEntity(ClassID classID, int uniqueID = 0, int owner = 0);
     BaseObject* doCreateEntity(ClassID classID, int uniqueID, int owner);
     void requestRemoveEntity(int uniqueID);
+//    void requestRemoveEntity(int uniqueID);
     void executeRemoveEntity(int uniqueID);
     void doRemoveEntity(int uniqueID);
-    void executeRequestSync( int uniqueID, int user );
-    void doRequestSync(int uniqueID, int userID);
     void doYouAre( int uniqueID );
     void requestPNodePath(const PNode* node1, const PNode* node2);
+//    void requestPNodePath(const PNode* node1, const PNode* node2);
     void executeRequestPNodePath(const PNode* node2, const PNode* node2);
     void doRequestPNodePath(const PNode* node1, const PNode* node2);
     bool canCreateEntity(ClassID classID);
+#if 0
+    void resizeBufferVector(int n);
-    void resizeBufferVector(int n);
     bool writeToClientBuffer( clientBuffer &cb, byte*data, int length );
 …
     bool writeToClientBuffer( clientBuffer &cb, int i );
     bool readFromClientBuffer( clientBuffer &cb, byte*data, int length );
+#endif
   private:
+#if 0
     std::vector<clientBuffer>     outBuffer;
     //clientBuffer                  allOutBuffer;
+#endif
     static NetworkGameManager*    singletonRef;
-    bool                          hasRequestedWorld;
 };

trunk/src/lib/network/network_manager.cc

-                      r7256
+                      r7954
 #include "shared_network_data.h"
 #include "network_stream.h"
+#include "preferences.h"
+#include "network_log.h"
 …
   this->defaultSyncStream = NULL;
   this->sharedNetworkData = SharedNetworkData::getInstance();
+  this->elapsedTime = 0.0f;
+  int port = Preferences::getInstance()->getInt( "network", "telnetport", 0 );
+  if ( port > 0 )
+    NetworkLog::getInstance()->listen( port );
   PRINTF(0)("NetworkManager created\n");
 …
   this->netStreamList = ClassList::getList(CL_SYNCHRONIZEABLE);
   PRINTF(0)("NetworkManager initzalized\n");
+}
 …
 int NetworkManager::establishConnection(const std::string & name, unsigned int port)
+{
+  IPaddress ipAddress;
+  int error = SDLNet_ResolveHost(&ipAddress, name.c_str(), port);
+  if( error == -1) {
+    printf("\n\nerror on address resolution, program inconsistency\n\n");
+    return -1;
+  }
+  this->defaultSyncStream = new NetworkStream(ipAddress);
+  this->defaultSyncStream = new NetworkStream( name, port );
   this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
   this->defaultSyncStream->startHandshake();
 …
 /**
  *  sync the network
+ *  @param dtS: the seceonds elapsed since the last synchronize call
  */
 void NetworkManager::synchronize()
+void NetworkManager::synchronize( float dtS)
+{
+  this->elapsedTime += dtS;
+  if( likely(this->elapsedTime < 1.0f / NETWORK_FREQUENCY))
+    return;
+  this->elapsedTime = 0.0f;
   if (this->netStreamList != NULL || (this->netStreamList = ClassList::getList(CL_NETWORK_STREAM)) != NULL)
+  {

trunk/src/lib/network/network_manager.h

-                      r7256
+                      r7954
     void connectSynchronizeable(Synchronizeable& sync);
     void synchronize();
+    void synchronize(float dtS);
     void debug();
 …
     SharedNetworkData*               sharedNetworkData;       //!< reference to the shared data
+    float                            elapsedTime;             //!< elapsed time since the last network update
 };

trunk/src/lib/network/network_socket.cc

-                      r7440
+                      r7954
 #define DEBUG_MODULE_NETWORK
-#include "converter.h"
 /* include your own header */
 #include "network_socket.h"
 …
 NetworkSocket::NetworkSocket()
+{
   this->init();
+  bOk = true;
+}
+/**
+ * Constructor to connect directly
+ */
+NetworkSocket::NetworkSocket(IPaddress ip)
+NetworkSocket::~ NetworkSocket( )
+{
-  this->init();
-  connectToServer(ip);
+}
-NetworkSocket::NetworkSocket( TCPsocket sock )
+{
-  this->init();
-  this->tcpSocket = sock;
-  readThread = SDL_CreateThread(thread_read, (void*)this);
-  writeThread = SDL_CreateThread(thread_write, (void*)this);
+}
-void NetworkSocket::init()
+{
-  /* set the class id for the base object */
-  this->setClassID(CL_NETWORK_SOCKET, "NetworkSocket");
-  tcpSocket = NULL;
-  incomingBufferLength = 0;
-  outgoingBufferLength = 0;
-  readThread = NULL;
-  writeThread = NULL;
-  thread_write_running = false;
-  thread_read_running = false;
-  incomingBufferMutex = SDL_CreateMutex();
-  outgoingBufferMutex = SDL_CreateMutex();
-  socketMutex = SDL_CreateMutex();
-  terminateThread = false;
-  /* Init SDL_net */
-  //NOTE: do we need to call SDLNet_Init for all instances?
-  if(SDLNet_Init()==-1)
+  {
-    PRINTF(1)("SDLNet_Init: %s\n", SDLNet_GetError());
-    return;
+  }
-  else
-    PRINTF(5)("SDL_net initialized\n");
-  PRINTF(0)("NetworkSocket created\n");
+}
-/**
- * Default destructor
- * dont use this from outside: use destroy() instead!!
- */
-NetworkSocket::~NetworkSocket( )
+{
-  this->terminateThread = true;
-  /* Quit SDL_net */
-  // NOTE: what if other instances of NetworkSocket running?
-  SDLNet_Quit();
-  PRINTF(5)("SDL_net shutdown\n");
-  SDL_DestroyMutex(incomingBufferMutex);
-  SDL_DestroyMutex(outgoingBufferMutex);
-  SDL_DestroyMutex(socketMutex);
-  SDL_DestroyMutex(threadTerminationMutex);
+}
-/**
- * This function establishes a TCP/UDP connection to a given server (function argument).
- * It is called by the NetworkStream. It creates a TCP/UDP socket for the connection.
- * @param ip
- */
-void NetworkSocket::connectToServer(IPaddress ip)
+{
-  //HACK this will cause segfault
-#warning remove this
-  int * a;
-  *a = 99;
-  //check if not already connected or listening
-  if (tcpSocket)
+  {
-    PRINTF(1)("NetworkSocket::listen: tcpSocket!=NULL! maybe you already called listen or connectToServer or did not call disconnectServer()!");
+  }
-  /* Connect to the host and port contained in ip using a TCP connection. */
-  tcpSocket = SDLNet_TCP_Open(&ip);
-  if(!tcpSocket)
+  {
-    PRINTF(1)("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
-    return;
+  }
-  readThread = SDL_CreateThread(thread_read, (void*)this);
-  writeThread = SDL_CreateThread(thread_write, (void*)this);
+}
-/**
- * DTears down a TCP/UDP connection.
- */
-void NetworkSocket::disconnectServer( )
+{
-  terminateThread = true;
-  /* Close the connection */
-  SDL_mutexP(socketMutex);
-  SDLNet_TCP_Close(tcpSocket);
-  tcpSocket = NULL;
-  SDL_mutexV(socketMutex);
+}
-/**
- * This function writes some bytes (data) to the network connection (if the connection is already
- * estabilhed) otherwise it just does nothing (silently discarding the data). And writes some
- * warnings
- * @param data: pointer to the data to send
- * @param length: n bytes to send
- * @return the number successfully written bytes
- */
-int NetworkSocket::writeBytes(byte * data, int length)
+{
-  PRINTF(5)("NetworkSocket::writeBytes()\n");
-#ifdef _USE_OUTGOING_BUFFER
-#define min(a,b) (a<b)?a:b
-  int nbytes = min(_OUTGOING_BUFFER_SIZE - outgoingBufferLength, length);
-#undef min
-  if (!tcpSocket || data==NULL || nbytes<=0)
+  {
-    assert(_OUTGOING_BUFFER_SIZE - outgoingBufferLength > 0);
-    return 0;
+  }
-  SDL_mutexP(outgoingBufferMutex);
-  memcpy(outgoingBuffer + outgoingBufferLength, data, nbytes);
-  outgoingBufferLength += nbytes;
-  SDL_mutexV(outgoingBufferMutex);
-  return nbytes;
-#else
-  SDL_mutexP(socketMutex);
-  if (!tcpSocket || data==NULL)
-    return 0;
-  int res = SDLNet_TCP_Send(tcpSocket, data, length);
-  SDL_mutexV(socketMutex);
-  if (res<length)
-    PRINTF(1)("SDLNet_TCP_Send: %s\n", SDLNet_GetError());
-  return res;
-#endif
+}
-/**
- * Reads in the bytes from the network interface and passes it to the NetworkStream.
- * This function must internaly be implemented/connected as a thread, since the read
- * functions of many network libraries are blocking an would therefore block the whole
- * program.
- * From outside, the thread shouldn't be accessible at all.
- * @param data: pointer to memory, big enough to store length bytes
- * @param length: n bytes to read
- * @return the number successfully read bytes. -1 on error. may be less than length!
- */
-int NetworkSocket::readBytes(byte * data, int length)
+{
-  PRINTF(5)("NetworkSocket::readBytes()\n");
-  if (data==NULL)
-    return 0;
-  int nbytes = (length<incomingBufferLength) ? length : incomingBufferLength;
-  //printf("readBytes: nbytes = %d; length=%d; incomingBufferLength=%d\n", nbytes, length, incomingBufferLength);
-  // just in case ...
-  if (nbytes<0)
-    return -1;
-  if (nbytes==0)
-      return 0;
-  SDL_mutexP(incomingBufferMutex);
-  memcpy(data, incomingBuffer, nbytes);
-  //important: use memmove because the memory areas may overlap
-  memmove(incomingBuffer, incomingBuffer+nbytes, incomingBufferLength-nbytes);
-  incomingBufferLength -= nbytes;
-  SDL_mutexV(incomingBufferMutex);
-  return nbytes;
+}
-/**
- * Reads in the bytes form the network interface and passes it to the NetworkStream.
- * It only reads the bytes if there are enough bytes in our buffer.
- * @param data: pointer to memory, big enough to store length bytes
- * @param length: n bytes to read
- * @return the number successfully read bytes. -1 on error. 0 if there are not enough bytes in our buffer.
- */
-int NetworkSocket::readBlock(byte * data, int length)
+{
-  printf("NetworkSocket: got %i bytes, NetworkStream requested %i bytes\n", this->incomingBufferLength, length);
-  if (incomingBufferLength >= length)
-    return readBytes(data, length);
-  else return 0;
+}
-/**
- * used to create a thread to read from socket
- * @param data: pointer to NetworkSocket
- */
-int NetworkSocket::thread_read( void * data )
+{
-  int nbytesread = 0;
-  int nbytestoread = 0;
-  char buffer[_LOCAL_BUFFER_SIZE];
-  NetworkSocket * self = (NetworkSocket*)data;
-  self->thread_read_running = true;
-  while (!self->terminateThread)
+  {
-#define min(a,b) (a<b)?a:b
-    nbytestoread = min(_INCOMING_BUFFER_SIZE - self->incomingBufferLength, _LOCAL_BUFFER_SIZE);
-#undef min
-    //if buffer is full
-    if (nbytestoread<=0 || !self->tcpSocket)
+    {
-      SDL_Delay(_MSECONDS_SLEEP_FULL_BUFFER);
-      continue;
+    }
-    nbytesread = SDLNet_TCP_Recv(self->tcpSocket, buffer, nbytestoread);
-    SDL_mutexP(self->incomingBufferMutex);
-    if (nbytesread<=0)
+    {
-      if (nbytesread<0)
-        printf("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
-      SDL_mutexP(self->socketMutex);
-      SDLNet_TCP_Close(self->tcpSocket);
-      self->tcpSocket = NULL;
-      SDL_mutexV(self->socketMutex);
-      SDL_mutexV(self->incomingBufferMutex);
-      continue;
+    }
-    //printf("thread_read: nbytesread=%d\n", nbytesread);
-    memcpy(self->incomingBuffer+self->incomingBufferLength, buffer, nbytesread);
-    self->incomingBufferLength += nbytesread;
-    SDL_mutexV(self->incomingBufferMutex);
+  }
-  SDL_mutexP(self->threadTerminationMutex);
-  self->thread_read_running = false;
-  if ( !self->thread_write_running )
+  {
-    //delete self;
-    SDL_mutexV(self->threadTerminationMutex);
+  }
-  else
+  {
-    SDL_mutexV(self->threadTerminationMutex);
+  }
-#ifdef DONTEXITTHREADS
-  while ( true )
+  {
-    SDL_Delay(1000);
+  }
-#endif
-  PRINTF(0)("QUIT READ THREAD\n");
-  return 0;
+}
-int NetworkSocket::thread_write( void * data )
+{
-  int nbyteswrite = 0;
-  int nbytestowrite = 0;
-  char buffer[_LOCAL_BUFFER_SIZE];
-  NetworkSocket * self = (NetworkSocket*)data;
-  self->thread_write_running = true;
-  while (!self->terminateThread)
+  {
-#define min(a,b) (a<b)?a:b
-    nbytestowrite = min(self->outgoingBufferLength, _LOCAL_BUFFER_SIZE);
-#undef min
-//     printf("thread_write nbytes=%d listening=%d\n", nbytestowrite, (int)self->_isListening);
-    //if buffer is full
-    if (nbytestowrite<=0 || !self->tcpSocket)
+    {
-      SDL_Delay(_MSECONDS_SLEEP_EMPTY_BUFFER);
-      continue;
+    }
-    SDL_mutexP(self->outgoingBufferMutex);
-    //printf("a\n");
-    memcpy(buffer, self->outgoingBuffer, nbytestowrite);
-    self->outgoingBufferLength -= nbytestowrite;
-    memmove(self->outgoingBuffer, self->outgoingBuffer+nbytestowrite, self->outgoingBufferLength);
-    SDL_mutexV(self->outgoingBufferMutex);
-    nbyteswrite = SDLNet_TCP_Send(self->tcpSocket, buffer, nbytestowrite);
-    if (nbyteswrite<=0)
+    {
-      printf("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
-      SDL_mutexP(self->socketMutex);
-      SDLNet_TCP_Close(self->tcpSocket);
-      self->tcpSocket = NULL;
-      SDL_mutexV(self->socketMutex);
-      continue;
+    }
+  }
-  SDL_mutexP(self->threadTerminationMutex);
-  self->thread_write_running = false;
-  if ( !self->thread_read_running )
+  {
-    //delete self;
-    SDL_mutexV(self->threadTerminationMutex);
+  }
-  else
+  {
-    SDL_mutexV(self->threadTerminationMutex);
+  }
-#ifdef DONTEXITTHREADS
-  while ( true )
+  {
-  SDL_Delay(1000);
+  }
-#endif
-  PRINTF(0)("QUIT WRITE THREAD\n");
-  return 0;
+}
-bool NetworkSocket::writePacket( byte * data, int length )
+{
-  PRINTF(5)("NetworkSocket::writePacket() size=%d\n", length);
-  if ( length > 1024 )
-  PRINTF(2)("WARNING SENDING BIG PACKET SIZE = %d\n", length);
-  byte blen[INTSIZE];
-  Converter::intToByteArray( length, blen, INTSIZE );
-  writeBytes(blen, INTSIZE);
-  writeBytes(data, length);
+}
-int NetworkSocket::readPacket( byte * data, int maxLength )
+{
-  PRINTF(5)("NetworkSocket::readPacket()\n");
-  if (incomingBufferLength<INTSIZE)
+  {
-    return 0;
+  }
-  int blen;
-  Converter::byteArrayToInt( incomingBuffer, &blen );
-  if (blen>maxLength)
+  {
-    PRINTF(1)("Buffersize is too small (%d) for packet (%d).\n", maxLength, blen);
-    assert(false);
-    return 0;
+  }
-  if (blen>incomingBufferLength)
+  {
-    return 0;
+  }
-  byte t[INTSIZE];
-  readBytes(t, INTSIZE);
-  int res = readBytes(data, blen);
-  if (res!=blen)
-    return -1;
-  else
-    return blen;
+}

trunk/src/lib/network/network_socket.h

-                      r6994
+                      r7954
 #define _NETWORK_SOCKET
-//TODO HACK else gdb will not work on server
-#define DONTEXITTHREADS
-//if you want to use outgoing buffer define _USE_OUTGOING_BUFFER
-#define _USE_OUTGOING_BUFFER
-#define _INCOMING_BUFFER_SIZE 2024000
-#define _OUTGOING_BUFFER_SIZE 2024000
-#define _LOCAL_BUFFER_SIZE 1024
-//sleep if incoming buffer is full
-#define _MSECONDS_SLEEP_FULL_BUFFER 10
-//sleep if outgoing buffer is empty
-#define _MSECONDS_SLEEP_EMPTY_BUFFER 10
-/* contains memmove and memcpy */
-#include <string.h>
-#ifdef HAVE_SDL_H
- #include <SDL_thread.h>
-#else
- #include <SDL/SDL_thread.h>
-#endif
 /* include this file, it contains some default definitions */
 #include "netdefs.h"
 …
 #include "base_object.h"
-/* using namespace std is default, this needs to be here */
-using namespace std;
 class NetworkSocket : public BaseObject
+{
+  public:
+    NetworkSocket();
+    virtual ~NetworkSocket();
+private:
+//  IPaddress serverAddress;
+//  unsigned int port;
+  TCPsocket tcpSocket;
+//  UDPsocket udpSocket;
+    /**
+     * connect to server on host with port port
+     * @param host hostname might be xxx.xxx.xxx.xxx or localhost ...
+     * @param port port to connect to
+     */
+    virtual void connectToServer( std::string host, int port ) = 0;
+    /**
+     * disconnect from server
+     */
+    virtual void disconnectServer() = 0;
+  byte incomingBuffer[_INCOMING_BUFFER_SIZE];
+#ifdef _USE_OUTGOING_BUFFER
+  byte outgoingBuffer[_OUTGOING_BUFFER_SIZE];
+#endif
+  int incomingBufferLength;
+#ifdef _USE_OUTGOING_BUFFER
+  int outgoingBufferLength;
+#endif
+    /**
+     * send packet to connected socket. will be recieved as whole packet
+     * @param data pointer to data to send
+     * @param length lengt of packet to send
+     * @return true on success
+     */
+    virtual bool writePacket(byte * data, int length) = 0;
+    /**
+     * read a packet sent by another NetworkSocket
+     * @param data data will be copied here
+     * @param maxLength readPacket will not read more than maxLength
+     * @return bytes read. on error less than zero
+     */
+    virtual int readPacket(byte * data, int maxLength) = 0;
+  SDL_mutex * incomingBufferMutex;
+#ifdef _USE_OUTGOING_BUFFER
+  SDL_mutex * outgoingBufferMutex;
+#endif
+  SDL_mutex * socketMutex;
+  bool terminateThread;
+  SDL_mutex* threadTerminationMutex;
+  static int thread_read(void * data);
+  bool thread_read_running;
+  bool thread_write_running;
+  SDL_Thread*            readThread;
+  SDL_Thread*            writeThread;
+#ifdef _USE_OUTGOING_BUFFER
+  static int thread_write(void * data);
+#endif
+  int writeBytes(byte * data, int length);
+  int readBytes(byte * data, int length);
+  int readBlock(byte * data, int length);
+  void init();
+public:
+  NetworkSocket();
+  virtual ~NetworkSocket();
+  NetworkSocket(IPaddress ip);
+  NetworkSocket(TCPsocket sock);
+  void destroy() { terminateThread = true; };
+  void connectToServer(IPaddress ip);
+  void disconnectServer();
+  bool writePacket(byte * data, int length);
+  int readPacket(byte * data, int maxLength);
+  inline bool isOk() { return tcpSocket!=NULL; }
+    /**
+     * check if socket is ok
+     * @return true if socket is ok
+     */
+    inline bool isOk() { return this->bOk; }
+  protected:
+    bool bOk;            //!< check for socket status
 };

trunk/src/lib/network/network_stream.cc

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

trunk/src/lib/network/network_stream.h

-                      r6981
+                      r7954
 #include <vector>
 #include <list>
+#include <map>
 #include "data_stream.h"
-#include "network_protocol.h"
 #include "server_socket.h"
 #include "handshake.h"
+#include "connection_monitor.h"
+#include "udp_server_socket.h"
 class Synchronizeable;
 class NetworkSocket;
 class ServerSocket;
-class ConnectionMonitor;
-class NetworkProtocol;
 class NetworkGameManager;
+class PeerInfo
+{
+  public:
+    PeerInfo() { clear(); }
+    void clear() { userId = 0; isServer = false; socket = NULL; handshake = NULL; lastAckedState = 0; lastRecvedState = 0; connectionMonitor = NULL; }
+    int                 userId;
+    bool                isServer;
+    NetworkSocket *     socket;
+    Handshake *         handshake;
+    ConnectionMonitor * connectionMonitor;
+    int                 lastAckedState;
+    int                 lastRecvedState;
+};
 typedef std::list<Synchronizeable*>  SynchronizeableList;
+typedef std::vector<NetworkSocket*>  NetworkSocketVector;
+typedef std::vector<Handshake*>      HandshakeVector;
+typedef std::map<int,PeerInfo>       PeerList;
 …
   public:
     NetworkStream();
     NetworkStream(IPaddress& address);
     NetworkStream(unsigned int port);
+    NetworkStream( std::string host, int port);
+    NetworkStream( int port );
     virtual ~NetworkStream();
 …
     inline bool isActive() const { return this->bActive; }
+    inline int getMaxConnections(){ return maxConnections; }
+    void setMaxConnections( int n );
+    inline int getMaxConnections(){ return MAX_CONNECTIONS; }
     virtual void processData();
 …
     int getSyncCount();
+    inline bool isUserIdActive( int userID ) { if (userID>=networkSockets.size()) return false; else return networkSockets[userID]!=NULL; }
+    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();
+    void handleHandshakes();
+    void handleUpstream();
+    void handleDownstream();
+    void handleNewClient( int userId );
+    void cleanUpOldSyncList();
+    void writeToNewDict( byte * data, int length );
   private:
-    NetworkProtocol*           networkProtocol;
-    ConnectionMonitor*         connectionMonitor;
     SynchronizeableList        synchronizeables;
+    NetworkSocketVector        networkSockets;
+    HandshakeVector            handshakes;
+    PeerList                   peers;
     ServerSocket*              serverSocket;
     int                        type;
-    Header                     packetHeader;
     bool                       bActive;
     std::list<int>             freeSocketSlots;
     int                        myHostId;
+    int                        maxConnections;
+    int                        currentState;                //!< current state id
     NetworkGameManager*        networkGameManager;
+    std::map<int,int>          oldSynchronizeables;         //!< used to save recently deleted sync ids to not recreate them
+    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
 };
 #endif /* _NETWORK_STREAM */

trunk/src/lib/network/server_socket.cc

-                      r6139
+                      r7954
 #include "debug.h"
+ServerSocket::ServerSocket(  )
+/**
+ * constructor
+ * @param port port to assign to socket
+ */
+ServerSocket::ServerSocket( int port )
+{
   init();
+  bOk = true;
+}
 ServerSocket::ServerSocket( unsigned int port )
+ServerSocket::~ ServerSocket( )
+{
-  init();
-  listen(port);
+}
-/**
- * Default destructor
- */
-ServerSocket::~ServerSocket( )
+{
-  /* Quit SDL_net */
-  // NOTE: what if other instances of NetworkSocket running?
-  SDLNet_Quit();
-  PRINTF(5)("SDL_net shutdown\n");
-  _isListening = false;
+}
-void ServerSocket::init( )
+{
-  /* set the class id for the base object */
-  this->setClassID(CL_SERVER_SOCKET, "ServerSocket");
-  terminateThread = false;
-  listenSocket = NULL;
-  _isListening = false;
-  if(SDLNet_Init()==-1)
+  {
-    PRINTF(1)("SDLNet_Init: %s\n", SDLNet_GetError());
-    return;
+  }
-  else
-    PRINTF(5)("SDL_net initialized\n");
-  PRINTF(0)("ServerSocket created\n");
+}
-/**
- * Tells the NetworkSocket to listen on a specific port for incoming connections.
- * NetworkSocket::writeBytes(...) will have no effect until there is a valuable connection.
- * @param port
- */
-bool ServerSocket::listen(unsigned int port)
+{
-  PRINTF(0)("ServerSocket::listen()\n");
-  _isListening = true;
-  //check if not already connected or listening
-  if (listenSocket)
+  {
-    PRINTF(1)("ServerSocket::listen: tcpSocket!=NULL! maybe you already called listen or did not call close()!\n");
-    _isListening = false;
-    return false;
+  }
-  IPaddress ip;
-  if (SDLNet_ResolveHost(&ip, NULL, port)==-1)
+  {
-    PRINTF(1)("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
-    _isListening = false;
-    return false;
+  }
-  listenSocket = SDLNet_TCP_Open(&ip);
-  if (!listenSocket)
+  {
-    PRINTF(1)("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
-    _isListening = false;
-    return false;
+  }
-  return true;
+}
-NetworkSocket* ServerSocket::getNewSocket( )
+{
-  if ( !listenSocket )
+  {
-    PRINTF(1)("listenSocket == NULL! Maybe you forgot to call listen()\n");
-    close();
-    return NULL;
+  }
-  TCPsocket sock = SDLNet_TCP_Accept(listenSocket);
-  if ( !sock )
+  {
-    return NULL;
+  }
-  else
+  {
-    return new NetworkSocket(sock);
+  }
+}
-void ServerSocket::close( )
+{
-  if ( listenSocket )
+  {
-    SDLNet_TCP_Close( listenSocket );
-    listenSocket = NULL;
+  }
-  _isListening = false;
+}

trunk/src/lib/network/server_socket.h

-                      r6981
+                      r7954
 #define _SERVER_SOCKET
-#ifdef HAVE_SDL_H
-#include <SDL_thread.h>
-#else
-#include <SDL/SDL_thread.h>
-#endif
 /* include this file, it contains some default definitions */
 #include "netdefs.h"
 …
 #include "network_socket.h"
-//sleep when waiting for connections
-#define _MSECONDS_SLEEP_LISTEN 100
 class ServerSocket : public BaseObject
+{
+  private:
+    TCPsocket listenSocket;
+    bool terminateThread;
+  public:
+    ServerSocket( int port);
     bool _isListening;
+    virtual ~ServerSocket();
+    void init();
+    virtual bool listen( unsigned int port ) = 0;
+    virtual NetworkSocket* getNewSocket( void ) = 0;
+    virtual void close() = 0;
+    virtual void update() = 0;
+    virtual bool isOk() { return this->bOk; };
+  public:
+    ServerSocket();
+    ServerSocket( unsigned int port );
+    virtual ~ServerSocket();
+    bool listen( unsigned int port );
+    NetworkSocket* getNewSocket( void );
+    void close();
+    inline bool isOk(){ return listenSocket!=NULL; }
+  protected:
+    bool bOk;
 };

trunk/src/lib/network/synchronizeable.cc

-                      r6753
+                      r7954
 #include "network_stream.h"
 #include "netdefs.h"
+#include "network_log.h"
 #include "state.h"
 …
   this->setClassID(CL_SYNCHRONIZEABLE, "Synchronizeable");
   this->owner = -1;
-  this->state = 0;
   this->hostID = SharedNetworkData::getInstance()->getHostID();
   this->setIsServer(this->hostID == 0);
   this->uniqueID = NET_UID_UNASSIGNED;
   this->networkStream = NULL;
-  this->setRequestedSync( false );
-  this->setIsOutOfSync( !(this->isServer()) );
   this->bSynchronize = false;
   if( State::isOnline())
+  {
 …
     this->setUniqueID(SharedNetworkData::getInstance()->getNewUniqueID());
+  }
+  /* make sure loadClassId is first synced var because this is read by networkStream */
+  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);
+}
-/**
- *  write data to NetworkStream
- */
-int Synchronizeable::writeBytes(const byte* data, int length, int sender)
+{
-  PRINTF(5)("Synchronizeable::writeBytes was called\n");
+}
-/**
- *  read data from NetworkStream
- */
-int Synchronizeable::readBytes(byte* data, int maxLength, int * reciever)
+{
-  PRINTF(5)("Synchronizeable::readBytes was called\n");
+}
-void Synchronizeable::writeDebug() const
-{}
-void Synchronizeable::readDebug() const
-{}
 /**
 …
 /**
- * Sets the outofsync flag to a given value
- * @param outOfSync: the boolean value which the outofsync flag is to set to
- */
-void Synchronizeable::setIsOutOfSync(bool outOfSync)
+{
-  if( outOfSync )
-    this->state = this->state | STATE_OUTOFSYNC;
-  else
-    this->state = this->state & (~STATE_OUTOFSYNC);
-  //PRINTF(0)("isoutofsync %s %d\n", this->getClassName(), state);
+}
-/**
  * Determines if the server flag is set
  * @return true, if the server flag is true, false else
 …
+/**
+ * Determines if the outofsync flag is set
+ * @return true, if the outofsync flag is true, false else
+ */
+bool Synchronizeable::isOutOfSync()
+{
+  return (this->state & STATE_OUTOFSYNC) >0;
+}
+/**
+ * Determines if the requestedSync flag is set
+ * @return true, if the requestedSync flag is true, false else
+ */
+bool Synchronizeable::requestedSync()
+{
+  return (this->state & STATE_REQUESTEDSYNC) >0;
+}
+/**
+ * Sets the requestedsync flag to a given value
+ * @param requestedSync: the boolean value which the requestedsync flag is to set to
+ */
+void Synchronizeable::setRequestedSync( bool requestedSync )
+{
+  if( requestedSync )
+    this->state = this->state | STATE_REQUESTEDSYNC;
+int Synchronizeable::getStateDiff( int userId, byte* data, int maxLength, int stateId, int fromStateId, int priorityTH )
+{
+  //make sure this user has his history
+  if ( sentStates.size() <= userId )
+    sentStates.resize( userId+1 );
+  //calculate needed memory
+  int neededSize = 0;
+  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+    neededSize += (*it)->getSize();
+  if ( !( neededSize <= maxLength ) )
+  {
+    PRINTF(0)( "%d > %d\n", neededSize, maxLength );
+    assert(false);
+  }
+  //remove older states from history than fromStateId
+  StateHistory::iterator it = sentStates[userId].begin();
+  while ( it != sentStates[userId].end() && (*it)->stateId < fromStateId )
+    it++;
+  if ( it != sentStates[userId].begin() )
+  {
+    for ( StateHistory::iterator it2 = sentStates[userId].begin(); it2 != it; it2++ )
+    {
+      if ( (*it2)->data != NULL )
+      {
+        delete [] (*it2)->data;
+        (*it2)->data = NULL;
+      }
+    }
+    sentStates[userId].erase( sentStates[userId].begin(), it );
+  }
+  //find state to create diff from
+  StateHistoryEntry * stateFrom = NULL;
+  it = sentStates[userId].begin();
+  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() )
+  {
+    StateHistoryEntry * initialEntry = new StateHistoryEntry();
+    initialEntry->stateId = fromStateId;
+    initialEntry->dataLength = 0;
+    initialEntry->data = NULL;
+    stateFrom = initialEntry;
+  }
   else
+    this->state = this->state & (~STATE_REQUESTEDSYNC);
+}
+    stateFrom = (*it);
+  StateHistoryEntry * stateTo = new StateHistoryEntry();
+  stateTo->stateId = stateId;
+  stateTo->dataLength = neededSize;
+  stateTo->data = new byte[ neededSize ];
+  std::list<int>::iterator sizeIter = stateFrom->sizeList.begin();
+  int i = 0;
+  int n;
+  bool hasPermission;
+  // now do the actual synchronization: kick all variables to write into a common buffer
+  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
+    hasPermission = (
+            this->isServer() && (*it)->checkPermission( PERMISSION_SERVER ) ||
+            this->owner == this->hostID && (*it)->checkPermission( PERMISSION_OWNER ) ||
+            (*it)->checkPermission( PERMISSION_ALL )
+                    );
+    if ( ( hasPermission && (*it)->getPriority() >= priorityTH ) || sizeIter == stateFrom->sizeList.end() )
+    {
+      n = (*it)->writeToBuf( stateTo->data+i, stateTo->dataLength - i );
+      //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
+      stateTo->sizeList.push_back( n );
+      //(*it)->debug();
+      i += n;
+    }
+    else
+    {
+      for ( int j = 0; j<(*sizeIter); j++ )
+      {
+        assert( i < stateFrom->dataLength );
+        stateTo->data[i] = stateFrom->data[i];
+        i++;
+      }
+      //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), *sizeIter);
+      stateTo->sizeList.push_back( (*sizeIter) );
+    }
+    if ( sizeIter != stateFrom->sizeList.end() )
+      sizeIter++;
+  }
+  sentStates[userId].push_back( stateTo );
+  assert( i == neededSize );
+  //write diff to data
+  for ( i = 0; i<neededSize; i++ )
+  {
+    if ( i < stateFrom->dataLength )
+      data[i] = stateTo->data[i] - stateFrom->data[i];
+    else
+      data[i] = stateTo->data[i];
+  }
+  return neededSize;
+}
+/**
+ * sets a new state out of a diff created on another host
+ * @param userId hostId of user who send me that diff
+ * @param data pointer to diff
+ * @param length length of diff
+ * @param stateId id of current state
+ * @param fromStateId id of the base state id
+ * @return number bytes read
+ * @todo check for permissions
+ */
+int Synchronizeable::setStateDiff( int userId, byte* data, int length, int stateId, int fromStateId )
+{
+  //make sure this user has his history
+  if ( recvStates.size() <= userId )
+    recvStates.resize( userId+1 );
+  //create new state
+  StateHistoryEntry * stateTo = new StateHistoryEntry();
+  stateTo->stateId = stateId;
+  stateTo->dataLength = length;
+  stateTo->data = new byte[ length ];
+  //find state to apply diff to
+  StateHistoryEntry * stateFrom = NULL;
+  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 ( it == recvStates[userId].end() )
+  {
+    StateHistoryEntry * initialEntry = new StateHistoryEntry();
+    initialEntry->stateId = fromStateId;
+    initialEntry->dataLength = 0;
+    initialEntry->data = NULL;
+    stateFrom = initialEntry;
+  }
+  else
+    stateFrom = (*it);
+  //apply diff
+  for ( int i = 0; i<length; i++ )
+  {
+    if ( i < stateFrom->dataLength )
+      stateTo->data[i] = stateFrom->data[i] + data[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;
+  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 ||
+        (*it)->checkPermission( PERMISSION_ALL )
+       )
+    {
+      n = (*it)->readFromBuf( stateTo->data + i, stateTo->dataLength - i );
+      i += n;
+      //NETPRINTF(0)("%s::setvar %s %d\n", getClassName(), (*it)->getName().c_str(), n);
+      //(*it)->debug();
+      if ( (*it)->getHasChanged() )
+      {
+        changes.push_back( (*it)->getVarId() );
+      }
+    }
+    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 );
+      n = (*it)->getSizeFromBuf( stateTo->data + i, stateTo->dataLength - i );
+      //NETPRINTF(0)("%s::setvar %s %d\n", getClassName(), (*it)->getName().c_str(), n);
+      //(*it)->debug();
+      i += n;
+    }
+  }
+  this->varChangeHandler( changes );
+  return i;
+}
+ /**
+ * override this function to be notified on change
+ * of your registred variables.
+ * @param id id's which have changed
+ */
+void Synchronizeable::varChangeHandler( std::list<int> & id )
+{
+}
+/**
+ * registers a varable to be synchronized over network
+ * @param var see src/lib/network/synchronizeable_var/ for available classes
+ */
+void Synchronizeable::registerVar( SynchronizeableVar * var )
+{
+  PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
+  syncVarList.push_back( var );
+}
+/**
+ * registers a varable to be synchronized over network
+ * return value is passed to varChangeHandler on change
+ * @param var see src/lib/network/synchronizeable_var/ for available classes
+ * @return handle passed to varChangeHandler on changes
+ */
+int Synchronizeable::registerVarId( SynchronizeableVar * var )
+{
+  PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
+  syncVarList.push_back( var );
+  var->setWatched( true );
+  var->setVarId( syncVarList.size()-1 );
+  return syncVarList.size()-1;
+}
+/**
+ * removed user's states from memory
+ * @param userId user to clean
+ */
+void Synchronizeable::cleanUpUser( int userId )
+{
+  for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
+  {
+    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
+    {
+      if ( (*it2)->data )
+        delete [] (*it2)->data;
+      (*it2)->data = NULL;
+      delete *it2;
+    }
+  }
+  sentStates.clear();
+  for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
+  {
+    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
+    {
+      if ( (*it2)->data )
+        delete [] (*it2)->data;
+      (*it2)->data = NULL;
+      delete *it2;
+    }
+  }
+  recvStates.clear();
+}
+/**
+ * this function is called after recieving a state.
+ * @param userId
+ * @param stateId
+ * @param fromStateId
+ */
+void Synchronizeable::handleRecvState( int userId, int stateId, int fromStateId )
+{
+   //make sure this user has his history
+  if ( recvStates.size() <= userId )
+    recvStates.resize( userId+1 );
+  //remove old states
+  StateHistory::iterator it = recvStates[userId].begin();
+#if 0
+  while ( it != recvStates[userId].end() && (*it)->stateId < fromStateId )
+    it++;
+  if ( it != recvStates[userId].begin() )
+  {
+    for ( StateHistory::iterator it2 = recvStates[userId].begin(); it2 != it; it2++ )
+    {
+      if ( (*it2)->data != NULL )
+      {
+        delete [] (*it2)->data;
+        (*it2)->data = NULL;
+      }
+    }
+    recvStates[userId].erase( recvStates[userId].begin(), it );
+  }
+#endif
+  for ( it = recvStates[userId].begin(); it != recvStates[userId].end();  )
+  {
+    if ( (*it)->stateId < fromStateId )
+    {
+      StateHistory::iterator delIt = it;
+      it ++;
+      if ( (*delIt)->data )
+        delete [] (*delIt)->data;
+      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 == stateId )
+      toState = 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
+ */
+void Synchronizeable::handleSentState( int userId, int stateId, int fromStateId )
+{
+   //make sure this user has his history
+  if ( sentStates.size() <= userId )
+    sentStates.resize( userId+1 );
+   //remove old states
+  StateHistory::iterator it = sentStates[userId].begin();
+  for ( it = sentStates[userId].begin(); it != sentStates[userId].end();  )
+  {
+    if ( (*it)->stateId < fromStateId )
+    {
+      StateHistory::iterator delIt = it;
+      it ++;
+      if ( (*delIt)->data )
+        delete [] (*delIt)->data;
+      sentStates[userId].erase( delIt );
+      continue;
+    }
+    it++;
+  }
+  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 == stateId )
+      toState = 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

-                      r7230
+                      r7954
 /*!
  * @file connection_monitor.h
+ * @file synchronizeable.h
     \brief interface for all classes that have to be synchronized
  */
 …
 #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_quaternion.h"
+#include "synchronizeable_var/synchronizeable_string.h"
+#include "synchronizeable_var/synchronizeable_int.h"
+#include "synchronizeable_var/synchronizeable_float.h"
+#include "synchronizeable_var/synchronizeable_bool.h"
+#include "synchronizeable_var/synchronizeable_uint.h"
 …
 //State constants: They have to be of the form 2^n
 #define STATE_SERVER 1
-#define STATE_OUTOFSYNC 2
-#define STATE_REQUESTEDSYNC 4
+enum {
+  NWT_SS_WE_STATE = 1000000,
+  NWT_SS_B,
+  NWT_SS_FLAGS,
+  NWT_SS_MOUSEDIRX,
+  NWT_SS_MOUSEDIRY,
+  NWT_SS_MOUSEDIRZ,
+  NWT_SS_MOUSEDIRW,
+  NWT_SS_PN_SYNC,
+  NWT_SS_VELX,
+  NWT_SS_VELY,
+  NWT_SS_VELZ,
+  NWT_SS_PL_SYNC,
+  NWT_SS_CO_N,
+  NWT_SS_CO_CLID,
+  NWT_HS_HOST_ID,
+  NWT_HS_NGM_ID,
+  NWT_PL_B,
+  NWT_PL_FLAGS,
+  NWT_PL_SCORE,
+  NWT_PN_BO_WRITESTATE,
+  NWT_PN_PARENTMODE,
+  NWT_PN_COORX,
+  NWT_PN_COORY,
+  NWT_PN_COORZ,
+  NWT_PN_ROTX,
+  NWT_PN_ROTY,
+  NWT_PN_ROTZ,
+  NWT_PN_ROTV,
+  NWT_PN_FLAGS,
+  NWT_PN_SCOORX,
+  NWT_PN_SCOORY,
+  NWT_PN_SCOORZ,
+  NWT_PN_SROTX,
+  NWT_PN_SROTY,
+  NWT_PN_SROTZ,
+  NWT_PN_SROTV,
+  NWT_BO_NAME,
+  NWT_WE_PN_WRITESTATE,
+  NWT_WE_PN_MODELFILENAME,
+  NWT_WE_PN_SCALING,
+  NWT_GT_WE_STATE,
+  NWT_SB_WE_STATE,
+  NWT_SB_SIZE,
+  NWT_SB_TEXTURENAME,
+  NWT_TER_WE_STATE,
+  NWT_PU_WE_STATE,
+  NWT_TPU_WE_STATE,
+  NWT_LPU_WE_STATE,
+  NWT_WPU_WE_STATE,
+  NWT_PPU_WE_STATE,
+  NWT_PPU_TYPE,
+  NWT_PPU_VALUE,
+  NWT_PPU_MINVALUE,
+  NWT_PPU_MAXVALUE,
+  NWT_WAT_STATE,
+  NWT_WAT_WE_STATE,
+  NWT_WAT_SIZEX,
+  NWT_WAT_SIZEY,
+  NWT_WAT_RESX,
+  NWT_WAT_RESY,
+  NWT_WAT_HEIGHT
+struct StateHistoryEntry
+{
+  int             stateId;
+  byte *          data;
+  int             dataLength;
+  std::list<int>  sizeList;
 };
+typedef std::list<StateHistoryEntry*> StateHistory;
+//macros to help writing data in byte buffer
+/*
+ * Important: these macros must be used in
+ *     SYNCHELP_READ_*:  virtual void      writeBytes(const byte* data, int length, int sender);
+ *     SYNCHELP_WRITE_*: virtual int       readBytes(byte* data, int maxLength, int * reciever);
+ * with the same argument names!
+ *
+ * id is one int out of that enum on top of this comment it is used to identify
+ * read/write. when you read a value you have to use exactly the same as you used
+ * to write or you will see an assertion failing.
+ *
+ * SYNCHELP_WRITE_BEGIN()
+ * SYNCHELP_WRITE_INT(i,id)
+ * SYNCHELP_WRITE_FLOAT(f,id)
+ * SYNCHELP_WRITE_BYTE(b,id)
+ * SYNCHELP_WRITE_STRING(s,id)
+ * SYNCHELP_WRITE_N
+ *
+ * SYNCHELP_READ_BEGIN()
+ * SYNCHELP_READ_INT(i,id)
+ * SYNCHELP_READ_FLOAT(f,id)
+ * SYNCHELP_READ_STRING(s,l,id) l = size of buffer s
+ * SYNCHELP_READ_STRINGM(s,id)  allocates memory for string! you have to delete this later
+ * SYNCHELP_READ_BYTE(b,id)
+ * SYNCHELP_READ_REMAINING() returns the remaining buffer size
+ * SYNCHELP_READ_NEXTBYTE()  reads the next byte but it is not removed from the buffer
+ * SYNCHELP_READ_N
+ *
+ *
+ *
+ * Example 1:
+ *  SYNCHELP_READ_BEGIN();
+ *  SYNCHELP_READ_FLOAT(size);
+ *  SYNCHELP_READ_STRING( textureName, 1024 ); //1024 is the length of textureName
+ *  delete[] textureName;
+ *  textureName = NULL;
+ *  SYNCHELP_READ_STRINGM( texturename );      //this will call new char[strlen()+1]
+ *
+ * Example 2:
+ *  SYNCHELP_WRITE_BEGIN();
+ *  SYNCHELP_WRITE_FLOAT(this->size);
+ *  SYNCHELP_WRITE_STRING(this->textureName);
+ *  return SYNCHELP_WRITE_N;
+ *
+ */
+typedef std::vector<StateHistory> UserStateHistory;
+#define SYNCHELP_WRITE_DEBUG(n) {\
+  __synchelp_write_n = Converter::intToByteArray( n, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
+  assert( __synchelp_write_n == INTSIZE ); \
+  __synchelp_write_i += __synchelp_write_n; \
+}
+#define SYNCHELP_READ_DEBUG(n) {  \
+  int nn; \
+  __synchelp_read_n = Converter::byteArrayToInt( data+__synchelp_read_i, &nn );  \
+  assert( __synchelp_read_n == INTSIZE ); \
+  if ( n != nn ) { \
+    PRINTF(1)("Check your code! read/writes not in right order! read %d instead of %d\n", nn, n); \
+    assert( false ); \
+  } \
+  __synchelp_read_i += __synchelp_read_n; \
+}
+#define SYNCHELP_WRITE_BEGIN()    int __synchelp_write_i = 0; \
+                                  int __synchelp_write_n
+#define SYNCHELP_WRITE_INT(i,n) { SYNCHELP_WRITE_DEBUG(n); \
+                                __synchelp_write_n = \
+                                Converter::intToByteArray( i, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
+                                assert( __synchelp_write_n == INTSIZE ); \
+                                if ( __synchelp_write_n <= 0) \
+{ \
+                                  PRINTF(1)("Buffer is too small to store a int\n"); \
+                                  return 0; \
+} \
+                                __synchelp_write_i += __synchelp_write_n; \
+}
+#define SYNCHELP_WRITE_FLOAT(f,n) { SYNCHELP_WRITE_DEBUG(n); \
+                                __synchelp_write_n = \
+                                Converter::floatToByteArray( f, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
+                                assert( __synchelp_write_n == FLOATSIZE ); \
+                                if ( __synchelp_write_n <= 0) \
+{ \
+                                  PRINTF(1)("Buffer is too small to store a float\n"); \
+                                  return 0; \
+} \
+                                __synchelp_write_i += __synchelp_write_n; \
+}
+#define SYNCHELP_WRITE_BYTE(b,n) { SYNCHELP_WRITE_DEBUG(n); \
+                                \
+                                if (maxLength - __synchelp_write_i < 1) \
+{ \
+                                  PRINTF(1)("Buffer is too small to store string\n"); \
+                                  return 0; \
+} \
+                                data[__synchelp_write_i] = b; \
+                                __synchelp_write_i++; \
+}
+#define SYNCHELP_WRITE_STRING(s,n) { SYNCHELP_WRITE_DEBUG(n); \
+                                __synchelp_write_n = \
+                                Converter::stringToByteArray( s, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
+                                assert( __synchelp_write_n == ((std::string)s).length()+INTSIZE ); \
+                                if ( __synchelp_write_n <= 0) \
+{ \
+                                  PRINTF(1)("Buffer is too small to store string\n"); \
+                                  return 0; \
+} \
+                                __synchelp_write_i += __synchelp_write_n; \
+}
+#define SYNCHELP_WRITE_N        __synchelp_write_i
+#define SYNCHELP_WRITE_FKT(f,n)   { SYNCHELP_WRITE_DEBUG(n); \
+                                  PRINTF(0)("calling %s with %d left\n", #f, maxLength - __synchelp_write_i);  \
+                                  byte * spos = data+__synchelp_write_i;  \
+                                  if (maxLength - __synchelp_write_i < INTSIZE) \
+{ \
+                                    PRINTF(1)("Buffer is too small to store more data\n"); \
+                                    return 0; \
+} \
+                                  __synchelp_write_i += INTSIZE; \
+                                  __synchelp_write_n = \
+                                  f( data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
+                                  __synchelp_write_i += __synchelp_write_n;  \
+                                  Converter::intToByteArray( __synchelp_write_n, spos, INTSIZE ); \
+                                }
+#define SYNCHELP_READ_BEGIN()     int __synchelp_read_i = 0; \
+                                  int __synchelp_read_n
+#define SYNCHELP_READ_INT(i,n)       { SYNCHELP_READ_DEBUG(n); \
+                                    if ( length-__synchelp_read_i < INTSIZE ) \
+{ \
+                                      PRINTF(1)("There is not enough data to read an int\n");  \
+                                      return 0; \
+} \
+                                    __synchelp_read_n = Converter::byteArrayToInt( data+__synchelp_read_i, &i );  \
+                                    assert( __synchelp_read_n == INTSIZE ); \
+                                    __synchelp_read_i += __synchelp_read_n; \
+}
+#define SYNCHELP_READ_FLOAT(f,n)    { SYNCHELP_READ_DEBUG(n); \
+                                    if ( length-__synchelp_read_i < FLOATSIZE ) \
+{ \
+                                      PRINTF(1)("There is not enough data to read a flaot\n");  \
+                                      return 0; \
+} \
+                                    __synchelp_read_n = Converter::byteArrayToFloat( data+__synchelp_read_i, &f );  \
+                                    assert( __synchelp_read_n == FLOATSIZE ) ;\
+                                    __synchelp_read_i += __synchelp_read_n; \
+}
+#define SYNCHELP_READ_STRING(s,n)    {SYNCHELP_READ_DEBUG(n); \
+                                    __synchelp_read_n = Converter::byteArrayToString( data+__synchelp_read_i, s, length-__synchelp_read_i );  \
+                                    assert( __synchelp_read_n == s.length()+INTSIZE ) ;\
+                                    if ( __synchelp_read_n <0 )  \
+{ \
+                                      PRINTF(1)("There is not enough data to read string\n");  \
+                                      return 0; \
+} \
+                                    __synchelp_read_i += __synchelp_read_n; \
+}
+#if 0 //not needed any more
+#define SYNCHELP_READ_STRINGM(s,n)    { SYNCHELP_READ_DEBUG(n); \
+                                    __synchelp_read_n = Converter::byteArrayToStringM( data+__synchelp_read_i, s );  \
+                                    assert( __synchelp_read_n == strlen(s)+INTSIZE ) ;\
+                                    if ( __synchelp_read_n <0 )  \
+{ \
+                                      PRINTF(1)("There is not enough data to read string\n");  \
+                                      return 0; \
+} \
+                                    __synchelp_read_i += __synchelp_read_n; \
+}
+#endif
+#define SYNCHELP_READ_BYTE(b,n)      { SYNCHELP_READ_DEBUG(n); \
+                                    if ( length-__synchelp_read_i < 1 ) \
+{ \
+                                      PRINTF(1)("There is not enough data to read a byte\n");  \
+                                      return 0; \
+} \
+                                    b = data[__synchelp_read_i]; \
+                                    __synchelp_read_i ++;  \
+}
+#define SYNCHELP_READ_FKT(f,n)   { SYNCHELP_READ_DEBUG(n); \
+                                  int s; \
+                                  if ( length-__synchelp_read_i < INTSIZE ) \
+{ \
+                                      PRINTF(1)("There is not enough data to read an int\n");  \
+                                      return 0; \
+} \
+                                    __synchelp_read_n = Converter::byteArrayToInt( data+__synchelp_read_i, &s );  \
+                                    assert( __synchelp_read_n == INTSIZE ); \
+                                    __synchelp_read_i += __synchelp_read_n; \
+                                  __synchelp_read_i += \
+                                  f( data+__synchelp_read_i, s, sender); \
+                                  }
+#define SYNCHELP_READ_REMAINING() ( length-__synchelp_read_i )
+#define SYNCHELP_READ_NEXTBYTE() ( data[__synchelp_read_i] )
+#define SYNCHELP_READ_N           __synchelp_read_i
+typedef std::vector<SynchronizeableVar*> SyncVarList;
 class NetworkStream;
 class Synchronizeable : virtual public BaseObject
 …
     virtual ~Synchronizeable();
+    virtual int       writeBytes(const byte* data, int length, int sender);
+    virtual int       readBytes(byte* data, int maxLength, int * reciever);
+    virtual void      writeDebug() const;
+    virtual void      readDebug() const;
+    void setIsServer( bool isServer );
+    bool isServer();
+    void setIsServer( bool isServer );
+    void setIsOutOfSync( bool outOfSync );
+    void setRequestedSync( bool requestedSync );
+    bool isServer();
+    bool isOutOfSync();
+    bool requestedSync();
+    virtual void varChangeHandler( std::list<int> & id );
+    virtual int getStateDiff( int userId, byte* data, int maxLength, int stateId, int fromStateId, int priorityTH );
+    virtual int setStateDiff( int userId, byte* data, int length, int stateId, int fromStateId );
+    virtual void cleanUpUser( int userId );
+    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 );
     inline void setUniqueID( int id ){ uniqueID = id; }
 …
     inline void setOwner(int owner){ this->owner = owner; }
     /** @returns true if this Synchronizeable has to be synchronized over network */
+    /** @returns true if this Synchronizeable wants to be synchronized over network */
     inline bool beSynchronized() { return this->bSynchronize; }
     /** @param bSynchronize sets the Synchronizeable to be sunchronized or not */
     inline void setSynchronized(bool bSynchronize) { this->bSynchronize = bSynchronize; }
-    inline void requestSync( int hostID ){ this->synchronizeRequests.push_back( hostID ); }
-    inline int getRequestSync( void ){ if ( this->synchronizeRequests.size()>0 ){ int n = *(synchronizeRequests.begin()); synchronizeRequests.pop_front(); return n; } else { return -1; } };
     inline void setNetworkStream(NetworkStream* stream) { this->networkStream = stream; }
 …
   protected:
     NetworkStream*    networkStream;
+    NetworkStream*    networkStream;  //!< reference network stream we are connected to
     int               state;
+  private:
+    int               uniqueID;       //!< unique id assigned to synchronizeable
+    int               mLeafClassId;   //!< store leafClassId to send via states
+    int               owner;          //!< hostId of owner ( 0 if none / server )
+    int               hostID;         //!< my own host id
+    bool              bSynchronize;   //!< do we need beeing synchronized?
+  private:
+    int               uniqueID;
+    int               owner;
+    int               hostID;
+    bool              bSynchronize;
+    SyncVarList       syncVarList;    //!< list containing variables to synchronize
+    std::list<int>    synchronizeRequests;
+    UserStateHistory  sentStates;     //!< store already sent states to create diffs from, offset corresponds to the user id
+    UserStateHistory  recvStates;     //!< store recieved states to apply diffs, offset corresponds to the user id
 };

Context Navigation

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

Legend:

trunk/src/lib/network/Makefile.am

trunk/src/lib/network/connection_monitor.cc

trunk/src/lib/network/connection_monitor.h

trunk/src/lib/network/converter.cc

trunk/src/lib/network/data_stream.cc

trunk/src/lib/network/handshake.cc

trunk/src/lib/network/handshake.h

trunk/src/lib/network/netdefs.h

trunk/src/lib/network/network_game_manager.cc

trunk/src/lib/network/network_game_manager.h

trunk/src/lib/network/network_manager.cc

trunk/src/lib/network/network_manager.h

trunk/src/lib/network/network_socket.cc

trunk/src/lib/network/network_socket.h

trunk/src/lib/network/network_stream.cc

trunk/src/lib/network/network_stream.h

trunk/src/lib/network/server_socket.cc

trunk/src/lib/network/server_socket.h

trunk/src/lib/network/synchronizeable.cc

trunk/src/lib/network/synchronizeable.h

Download in other formats: