Changeset 5809 in orxonox.OLD for branches

Timestamp:

Nov 28, 2005, 10:14:48 PM (19 years ago)

Author:

patrick

Message:

The NetworkSocket now uses a real network protocol: packet size is read out dynamicaly: therefore the NetworkStream now has an internal state that
checks if its reading header or body data

Location:

branches/network/src/lib/network

Files:

• network_protocol.cc (modified) (5 diffs)
• network_protocol.h (modified) (1 diff)
• network_stream.cc (modified) (3 diffs)
• network_stream.h (modified) (4 diffs)

branches/network/src/lib/network/network_protocol.cc

@@ -41 +41 @@
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_PROTOCOL, "NetworkProtocol");
-  this->headerLength = HEADER_LENGTH;
+  this->headerLength = sizeof(Header);
 }
 
@@ -65 +65 @@
   printf("NetworkProtocol: create header length = %i, bufferLength = %i\n", length, bufferLength);
   //If there isn't enough space for the header return -1
-  if (length + headerLength > bufferLength)
+  if (length + this->headerLength > bufferLength)
     return -1;
 
@@ -71 +71 @@
 //     printf("send byte[%i]=%u\n", i, data[i]);
 
+
   //Create space for the header
   for( int i = length - 1; i >= 0; i--)
-    data[i + headerLength] = data[i];
+    data[i + this->headerLength] = data[i];
 
-  //Include header
+  //Now create the header
+  /* protocol identifier */
   data[0] = 255;
-  return length + headerLength;
+  /* version number */
+  data[1] = 0;
+  /* sender ID: FIXME: there will be a better ID (for example unique:D)*/
+  data[2] = (byte)source.getClassID();
+  /* receiver ID */
+  data[3] = remoteID;
+  /* data length*/
+  data[4] = length;
+
+
+  return length + this->headerLength;
 }
 
@@ -100 +112 @@
   //Extract header
   Header h;
+  //&h = data;
+
   h.protocol = data[0];
+  /* version number */
+  h.version = data[1];
+  /* sender ID: FIXME: there will be a better ID (for example unique:D)*/
+  h.senderID = data[2];
+  /* receiver ID */
+  h.receiverID = data[3];
+  /* data length*/
+  h.length = data[4];
 
-  h.length = length - headerLength;
-  h.data = data;
 
 //   for(int i = 0; i < length; i++)
@@ -109 +129 @@
 
   //Remove header
-  for (int i = headerLength; i < length; i++)
-    data[i - headerLength] = data[i];
+//   for (int i = headerLength; i < length; i++)
+//     data[i - headerLength] = data[i];
 
   return h;

branches/network/src/lib/network/network_protocol.h

@@ -20 +20 @@
   byte receiverID;
   byte length;
-  byte* data;
 };
 

branches/network/src/lib/network/network_stream.cc

@@ -78 +78 @@
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_STREAM, "NetworkStream");
+  this->state = NET_REC_HEADER;
 }
 
@@ -95 +96 @@
 void NetworkStream::processData()
 {
-  int ret = 0;
+  int dataLength = 0;
 
   /* DOWNSTREAM */
@@ -101 +102 @@
   PRINT(0)("============= DOWNSTREAM:===============\n");
   /* first of all read the synchronizeable's data: */
-  ret = this->synchronizeables->readBytes((byte*)downBuffer);
+  dataLength = this->synchronizeables->readBytes((byte*)downBuffer);
 
   /* send the received data to connectionMonitor */
-  this->connectionMonitor->processPacket((byte*)downBuffer, ret);
+  this->connectionMonitor->processPacket((byte*)downBuffer, dataLength);
 
-  ret = this->networkProtocol->createHeader((byte*)downBuffer, ret, DATA_STREAM_BUFFER_SIZE,
-                                            *(this->synchronizeables), 12);
+  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 */
-  ret = this->networkSocket->writeBytes((byte*)downBuffer, ret);
+  dataLength = this->networkSocket->writeBytes((byte*)downBuffer, dataLength);
   /* check if there was an error */
-  if( ret == -1) { PRINTF(0)("Error in writing data to the NetworkSocket\n");}
+  if( dataLength == -1) { PRINTF(0)("Error in writing data to the NetworkSocket\n");}
 
 
 
   /* UPSTREAM */
-  ret = 0;
+  dataLength = 0;
   PRINT(0)("============== UPSTREAM:================\n");
-  /* first of all read  data from networkSocket*/
-  ret = this->networkSocket->readBlock((byte*)upBuffer, 11/* this is very bad: hard coded packet sizes! */);
-  /* error checking: data read? */
-  if( ret != 11 /*PACKAGE_SIZE + sizeof(Header)*/) { PRINTF(0)("Error while reading data from the NetworkSocket. Skipping further work\n");}
-  else
+  /* first of all read the next Orxonox Network Header */
+
+  switch( this->state)
   {
-    /* send the received data to connectionMonitor */
-    this->connectionMonitor->processPacket((byte*)upBuffer, ret);
 
-    /* extract Header */
-    Header header = this->networkProtocol->extractHeader((byte*) upBuffer , ret);
+    case 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*/
 
-    /* now pass the data to the sync object */
-    this->synchronizeables->writeBytes((byte*)upBuffer, header.length);
+        this->state = NET_REC_DATA;
+      }
+      break;
+
+    case 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: \n");
+        /* send the received data to connectionMonitor */
+        this->connectionMonitor->processPacket((byte*)upBuffer, this->packetHeader.length);
+        /* now pass the data to the sync object */
+        this->synchronizeables->writeBytes((byte*)upBuffer, this->packetHeader.length);
+
+        this->state = NET_REC_HEADER;
+      }
+      break;
+
+    default:
+      break;
   }
 
+
 }

branches/network/src/lib/network/network_stream.h

@@ -8 +8 @@
 
 #include "data_stream.h"
+#include "network_protocol.h"
 
 class Synchronizeable;
@@ -13 +14 @@
 class ConnectionMonitor;
 class NetworkProtocol;
+
+
+//<! The state of the NetworkStream
+typedef enum NetStat {
+  NET_REC_HEADER = 0,                          //!< Waiting for header
+  NET_REC_DATA,                                //!< Waiting for data
+
+  NUM_STATES                                   //!< Number of states
+};
+
 
 class NetworkStream : public DataStream
@@ -21 +32 @@
   NetworkStream(IPaddress& address, Synchronizeable& sync, NodeType type);
   NetworkStream(Synchronizeable& sync, unsigned int port, NodeType type);
-
   ~NetworkStream();
 
@@ -37 +47 @@
    NetworkSocket* networkSocket;
    int                    type;
+   int                    state;
+   Header                 packetHeader;
 };
 #endif /* _NETWORK_STREAM */