Changeset 5624 in orxonox.OLD for branches/network/src/lib/network/network_socket.cc

Timestamp:

Nov 17, 2005, 9:06:47 AM (18 years ago)

Author:

rennerc

Message:

network_unit_test.cc: added simple test for network_socket
network_socket: should compile and could work
netdefs.h: changed #ifndef/#define _NETWORK_MANAGER to #ifndef/define _NETDEFS

File:

• branches/network/src/lib/network/network_socket.cc (modified) (5 diffs)

branches/network/src/lib/network/network_socket.cc

@@ -37 +37 @@
   this->setClassID(CL_NETWORK_SOCKET, "NetworkSocket");
 
+  tcpSocket = NULL;
+  bufferlength = 0;
+
+  mutex = SDL_CreateMutex();
+  terminateThread = false;
+
   /* Init SDL_net */
+  //NOTE: do we need to call SDLNet_Init for all instances?
   if(SDLNet_Init()==-1)
   {
@@ -55 +62 @@
 NetworkSocket::~ NetworkSocket( )
 {
+  SDL_DestroyMutex(mutex);
 
   /* Quit SDL_net */
+  // NOTE: what if other instances of NetworkSocket running?
   SDLNet_Quit();
   PRINTF(5)("SDL_net shutdown\n");
@@ -62 +71 @@
 
 /**
-  * 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.
-  */
+ * 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
+ * @param port
+ */
 void NetworkSocket::connectToServer(IPaddress ip, unsigned int port)
 {
+  //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. */
@@ -76 +92 @@
   }
 
-}
-
-/**
-  * Tells the NetworkSocket to listen on a specific port for incoming connections.
-  * NetworkSocket::writeBytes(...) will have no effect until there is a valuable connection.
-  */
-void listen(unsigned int port)
-{
+  SDL_CreateThread(thread_read, (void*)this);
+}
+
+/**
+ * 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
+ */
+void NetworkSocket::listen(unsigned int port)
+{
+  //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()!\n");
+    return;
+  }
+
+  IPaddress ip;
+
+  if (SDLNet_ResolveHost(&ip, NULL, port)==-1)
+  {
+    PRINTF(1)("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
+    return;
+  }
+
+  tcpSocket = SDLNet_TCP_Open(&ip);
+
+  if (!tcpSocket)
+  {
+    PRINTF(1)("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
+    return;
+  }
+
+  SDL_CreateThread(thread_listen, (void*)this);
 }
 
@@ -91 +133 @@
 void NetworkSocket::disconnectServer( )
 {
-
+  terminateThread = true;
   /* Close the connection */
   SDLNet_TCP_Close(tcpSocket);
-
-}
-
-/**
-  * 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
-  */
-int NetworkSocket::writeBytes(byte* data, int length)
-{
-}
-
- /**
-  * 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.
-  */
+  tcpSocket = NULL;
+
+}
+
+
+/**
+ * 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)
+{
+  if (!tcpSocket || data==NULL)
+    return 0;
+
+  int res = SDLNet_TCP_Send(tcpSocket, data, length);
+
+  if (res<length)
+  {
+    PRINTF(1)("SDLNet_TCP_Send: %s\n", SDLNet_GetError());
+    return res;
+  }
+}
+
+/**
+ * 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)
 {
-}
+  if (!tcpSocket || data==NULL)
+    return 0;
+
+  int nbytes = (length<bufferlength) ? length : bufferlength;
+
+  // just in case ...
+  if (nbytes<0)
+    return -1;
+
+  if (nbytes==0)
+      return 0;
+
+  SDL_mutexP(mutex);
+
+  memcpy(data, buf, nbytes);
+
+  //important: use memmove because the memory areas may overlap
+  memmove(buf, buf+nbytes, bufferlength-nbytes);
+  bufferlength -= nbytes;
+
+  SDL_mutexV(mutex);
+
+  return nbytes;
+}
+
+/**
+ * used to create a thread to listen
+ * will call thrad_read when established connection
+ * @param data: pointer to NetwortSocket
+ */
+int NetworkSocket::thread_listen( void * data )
+{
+  NetworkSocket * self = (NetworkSocket*)data;
+  TCPsocket tempsocket;
+
+  tempsocket = SDLNet_TCP_Accept(self->tcpSocket);
+
+  SDLNet_TCP_Close(self->tcpSocket);
+  self->tcpSocket = NULL;
+
+  if (!tempsocket)
+  {
+    PRINTF(1)("SDLNet_TCP_Accept: %s\n", SDLNet_GetError());
+    return -1;
+  }
+
+  self->tcpSocket = tempsocket;
+
+  return thread_read(data);
+}
+
+/**
+ * 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;
+
+  while (!self->terminateThread)
+  {
+#define min(a,b) (a<b)?a:b
+    nbytestoread = min(_INCOMING_BUFFER_SIZE - self->bufferlength, _LOCAL_BUFFER_SIZE);
+
+    nbytesread = SDLNet_TCP_Recv(self->tcpSocket, buffer, nbytestoread);
+
+    SDL_mutexP(self->mutex);
+
+    if (nbytesread<=0)
+    {
+      PRINTF(1)("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
+      SDLNet_TCP_Close(self->tcpSocket);
+      self->tcpSocket = NULL;
+      SDL_mutexV(self->mutex);
+      return -1;
+    }
+
+    memcpy(self->buf+self->bufferlength, buffer, nbytesread);
+    self->bufferlength += nbytesread;
+
+    SDL_mutexV(self->mutex);
+  }
+
+  return 0;
+}
+
+