source: orxonox.OLD/branches/network/src/lib/network/network_socket.cc @ 5628

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

### File Specific:
   main-programmer: Christoph Renner, David Hasenfratz
   co-programmer:
*/



/* this is for debug output. It just says, that all calls to PRINT() belong to the DEBUG_MODULE_NETWORK module
   For more information refere to https://www.orxonox.net/cgi-bin/trac.cgi/wiki/DebugOutput
*/
#define DEBUG_MODULE_NETWORK


/* include your own header */
#include "network_socket.h"

/* header for debug output */
#include "debug.h"


/**
 * Default constructor
 */
NetworkSocket::NetworkSocket()
{
  /* set the class id for the base object */
  this->setClassID(CL_NETWORK_SOCKET, "NetworkSocket");

  tcpSocket = NULL;
  bufferlength = 0;

  mutex = 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
 */
NetworkSocket::~ NetworkSocket( )
{
  /* Quit SDL_net */
  // NOTE: what if other instances of NetworkSocket running?
  SDLNet_Quit();
  PRINTF(5)("SDL_net shutdown\n");

  SDL_DestroyMutex(mutex);
  SDL_DestroyMutex(socketmutex);
}

/**
 * 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. */
  tcpSocket = SDLNet_TCP_Open(&ip);
  if(!tcpSocket)
  {
    PRINTF(1)("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
    return;
  }

  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);
}

/**
 * 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)
{
  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;
}

/**
 * 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 (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);

  SDL_mutexP(self->socketmutex);
  SDLNet_TCP_Close(self->tcpSocket);
  self->tcpSocket = NULL;

  if (!tempsocket)
  {
    PRINTF(1)("SDLNet_TCP_Accept: %s\n", SDLNet_GetError());
    SDL_mutexV(self->socketmutex);
    return -1;
  }

  self->tcpSocket = tempsocket;

  SDL_mutexV(self->socketmutex);

  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);

    //if buffer is full
    if (nbytestoread<=0)
    {
      SDL_Delay(_MSECONDS_SLEEP_FULL_BUFFER);
      continue;
    }

    nbytesread = SDLNet_TCP_Recv(self->tcpSocket, buffer, nbytestoread);

    SDL_mutexP(self->mutex);

    if (nbytesread<=0)
    {
      PRINTF(1)("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->mutex);
      return -1;
    }

    memcpy(self->buf+self->bufferlength, buffer, nbytesread);
    self->bufferlength += nbytesread;

    SDL_mutexV(self->mutex);
  }

  return 0;
}