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

Timestamp:

Dec 16, 2005, 6:45:32 PM (18 years ago)

Author:

patrick

Message:

trunk: merged branche network with trunk using command: svn merge -r5999:HEAD, conflicts resolved in favor of the trunk bla

File:

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

trunk/src/lib/network/network_stream.cc

@@ -26 +26 @@
 #include "connection_monitor.h"
 #include "synchronizeable.h"
+#include "network_manager.h"
 #include "list.h"
 #include "debug.h"
+#include "class_list.h"
 
 /* include your own header */
@@ -45 +47 @@
   /* initialize the references */
   this->type = NET_CLIENT;
-  this->networkSocket = new NetworkSocket();
   this->networkProtocol = new NetworkProtocol();
-  this->synchronizeables = NULL;
   this->connectionMonitor = new ConnectionMonitor();
 }
 
-NetworkStream::NetworkStream(IPaddress& address, NodeType type)
-{
-  this->type = type;
+NetworkStream::NetworkStream(IPaddress& address)
+{
+  this->type = NET_CLIENT;
   this->init();
-  this->networkSocket = new NetworkSocket(address);
+  this->networkSockets.push_back(new NetworkSocket(address));
   this->networkProtocol = new NetworkProtocol();
-  this->synchronizeables = NULL;
   this->connectionMonitor = new ConnectionMonitor();
-}
-
-
-NetworkStream::NetworkStream(unsigned int port, NodeType type)
-{
-  this->type = type;
+
+  Handshake* hs = new Handshake(false);
+  hs->setUniqueID( 0 );
+  this->handshakes.push_back(hs);
+  this->connectSynchronizeable(*hs);
+  PRINTF(0)("NetworkStream: %s\n", hs->getName());
+}
+
+
+NetworkStream::NetworkStream(unsigned int port)
+{
+  this->type = NET_SERVER;
   this->init();
-  this->networkSocket = new NetworkSocket();
-//  this->networkSocket->listen(port);
+  this->serverSocket = new ServerSocket(port);
   this->networkProtocol = new NetworkProtocol();
-  this->synchronizeables = NULL;
   this->connectionMonitor = new ConnectionMonitor();
-}
-
-
-NetworkStream::NetworkStream(IPaddress& address, Synchronizeable& sync, NodeType type)
-    : DataStream()
-{
-  this->type = type;
-  this->init();
-  this->networkSocket = new NetworkSocket(address);
-  this->networkProtocol = new NetworkProtocol();
-  this->synchronizeables = &sync;
-  this->connectionMonitor = new ConnectionMonitor();
+  this->networkSockets.push_back( NULL );
+  this->handshakes.push_back( NULL );
   this->bActive = true;
-}
-
-
-NetworkStream::NetworkStream(unsigned int port, Synchronizeable& sync, NodeType type)
-    : DataStream()
-{
-  this->type = type;
-  this->init();
-  this->networkSocket = new NetworkSocket();
-//  this->networkSocket->listen(port);
-  this->networkProtocol = new NetworkProtocol();
-  this->synchronizeables = &sync;
-  this->connectionMonitor = new ConnectionMonitor();
-  this->bActive = true;
+
+  this->setMaxConnections( 10 );
 }
 
@@ -105 +86 @@
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_STREAM, "NetworkStream");
-  this->state = NET_REC_HEADER;
   this->bActive = false;
+  this->serverSocket = NULL;
+  myHostId = 0;
 }
 
@@ -112 +94 @@
 NetworkStream::~NetworkStream()
 {
-
-  networkSocket->disconnectServer();
-
-  if( this->networkSocket)
-    delete networkSocket;
+  if ( this->serverSocket )
+  {
+    serverSocket->close();
+    delete serverSocket;
+  }
+
+  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;
@@ -125 +124 @@
 void NetworkStream::connectSynchronizeable(Synchronizeable& sync)
 {
-  this->synchronizeables = &sync;
-  if( this->networkSocket != NULL)
+  this->synchronizeables.push_back(&sync);
+  sync.setNetworkStream( this );
+
+  if( this->networkSockets.size()>0 )
     this->bActive = true;
 }
 
+void NetworkStream::disconnectSynchronizeable(Synchronizeable& sync)
+{
+  this->synchronizeables.remove(&sync);
+
+  if( this->networkSockets.size()<=0 )
+    this->bActive = false;
+}
+
 
 void NetworkStream::processData()
 {
-  int dataLength = 0;
+  if ( this->type == NET_SERVER )
+    this->updateConnectionList();
+  else
+  {
+    if ( networkSockets[0] && !networkSockets[0]->isOk() )
+    {
+      PRINTF(1)("lost connection to server\n");
+
+      //delete networkSockets[i];
+      networkSockets[0]->disconnectServer();
+      networkSockets[0]->destroy();
+      networkSockets[0] = NULL;
+      //TODO: delete handshake from synchronizeable list so i can delete it
+      if ( handshakes[0] )
+        delete handshakes[0];
+      handshakes[0] = NULL;
+    }
+  }
+
+  for (int i = 0; i<handshakes.size(); i++)
+  {
+    if ( handshakes[i] )
+    {
+      if ( handshakes[i]->completed() )
+      {
+        if ( handshakes[i]->ok() )
+        {
+          if ( type != NET_SERVER )
+          {
+            NetworkManager::getInstance()->setHostID( handshakes[i]->getHostId() );
+            myHostId = NetworkManager::getInstance()->getHostID();
+          }
+          PRINT(0)("handshake finished\n");
+          delete handshakes[i];
+          handshakes[i] = NULL;
+          //TODO: replace handshake by entitymanager
+        }
+        else
+        {
+          PRINT(1)("handshake failed!\n");
+          networkSockets[i]->disconnectServer();
+          delete handshakes[i];
+          handshakes[i] = NULL;
+          //TODO: handle error
+        }
+      }
+    }
+  }
+
 
   /* DOWNSTREAM */
-  printf("\nSynchronizeable: %s\n", this->synchronizeables->getName());
-  PRINT(0)("============= DOWNSTREAM:===============\n");
-  /* first of all read the synchronizeable's data: */
-  if( this->isServer())
-    dataLength = this->synchronizeables->readBytes((byte*)downBuffer);
-
-  if( dataLength > 0)
-  {
-    /* send the received data to connectionMonitor */
-    this->connectionMonitor->processPacket((byte*)downBuffer, dataLength);
-
-    dataLength = this->networkProtocol->createHeader((byte*)downBuffer, dataLength, DATA_STREAM_BUFFER_SIZE,
-                 *(this->synchronizeables), 12/* some random number (no real id)*/);
-
-    /* pass the data to the network socket */
- //   dataLength = this->networkSocket->writeBytes((byte*)downBuffer, dataLength);
-    /* check if there was an error */
-    if( dataLength == -1)
-    {
-      PRINTF(0)("Error in writing data to the NetworkSocket\n");
-    }
-  }
-
+
+  int dataLength;
+  int reciever;
+  Header header;
+  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
+  {
+    //TODO: remove items from synchronizeables if they dont exist
+    if ( (*it)!=NULL && (*it)->getOwner() == myHostId )
+    {
+      do {
+        reciever = 0;
+        dataLength = (*it)->readBytes(downBuffer, DATA_STREAM_BUFFER_SIZE, &reciever);
+
+
+        if ( dataLength<=0 ){
+          reciever = 0;
+          continue;
+        }
+
+        dataLength = networkProtocol->createHeader((byte*)downBuffer, dataLength, DATA_STREAM_BUFFER_SIZE, static_cast<const Synchronizeable&>(*(*it)));
+
+        //FIXME: this is a hack, find a better way
+        Header* header = (Header*)downBuffer;
+        if ( header->synchronizeableID<100 )
+          header->synchronizeableID = 0;
+
+        if ( dataLength<=0 )
+          continue;
+
+        if ( reciever!=0 )
+        {
+          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, reciever);
+              networkSockets[i]->writePacket(downBuffer, dataLength);
+            }
+          }
+        }
+
+      } while( reciever!=0 );
+    }
+    else
+    {
+      PRINTF(0)("synchronizeables == NULL");
+    }
+  }
 
   /* UPSTREAM */
-  dataLength = 0;
-  PRINT(0)("============== UPSTREAM:================\n");
-  /* first of all read the next Orxonox Network Header */
-
-  if( this->state == NET_REC_HEADER)
-  {
-//    dataLength = this->networkSocket->readBlock((byte*)upBuffer, sizeof(Header));
-    if( dataLength == sizeof(Header))
-    {
-      this->packetHeader = this->networkProtocol->extractHeader((byte*) upBuffer , dataLength);
-      printf("NetworkStream::processData() - Got Header: Protocol %u, Version: %u, Sender: %u, Receiver: %u, Length: %u\n",
-             this->packetHeader.protocol, this->packetHeader.version, this->packetHeader.senderID,
-             this->packetHeader.receiverID, this->packetHeader.length);
-      /* FIXME: what if it was no this->packetHeader? catch? eg: the protocol identifier, receiver id*/
-
-      this->state = NET_REC_DATA;
-    }
-  }
-  if( this->state == NET_REC_DATA)
-  {
-    /* now read the data */
-//    dataLength = this->networkSocket->readBlock((byte*)upBuffer, this->packetHeader.length);
-    /* check if the data is available and process it if so */
-    if( dataLength == this->packetHeader.length)
-    {
-      printf("NetworkStream::processData() - Got Data: %i bytes\n", dataLength);
-      /* send the received data to connectionMonitor */
-      this->connectionMonitor->processPacket((byte*)upBuffer, this->packetHeader.length);
-      /* now pass the data to the sync object */
-      if( !this->isServer())
-        this->synchronizeables->writeBytes((byte*)upBuffer, this->packetHeader.length);
-
-      this->state = NET_REC_HEADER;
-    }
-  }
-
-
-}
+
+  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;
+
+        PRINTF(5)("read %d bytes from socket\n", dataLength);
+        header = networkProtocol->extractHeader(upBuffer, dataLength);
+        dataLength -= sizeof(header);
+
+        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 )
+            (*it)->writeBytes(upBuffer+sizeof(header), dataLength);
+        }
+
+      } 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);
+      handshakes[clientId]->setUniqueID(clientId);
+    } else
+    {
+      clientId = networkSockets.size();
+      networkSockets.push_back(tempNetworkSocket);
+      Handshake* tHs = new Handshake(true, clientId);
+      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;
+      //TODO: delete handshake from synchronizeable list so i can delete it
+      if ( handshakes[i] )
+        delete handshakes[i];
+      handshakes[i] = NULL;
+
+      if ( i == networkSockets.size()-1 )
+      {
+        networkSockets.pop_back();
+        handshakes.pop_back();
+      }
+      else
+      {
+        freeSocketSlots.push_back(i);
+      }
+    }
+  }
+
+
+}
+
+void NetworkStream::setMaxConnections( int n )
+{
+  if ( !this->isServer() )
+  {
+    PRINTF(1)("Cannot set maxConnections because I am no server.\n");
+  }
+  if ( this->networkSockets.size() > 1 )
+  {
+    PRINTF(1)("Cannot set maxConnections because there are already %d connections.\n", this->networkSockets.size());
+    return;
+  }
+  this->maxConnections = n;
+}
+
+