vpNetwork.cpp

/****************************************************************************
 *
 * $Id: vpNetwork.cpp 3842 2012-07-13 22:21:42Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2012 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * TCP Network
 *
 * Authors:
 * Aurelien Yol
 *
 *****************************************************************************/

#include <visp/vpNetwork.h>

vpNetwork::vpNetwork()
{
  separator = "[*@*]";
  beginning = "[*start*]";
  end = "[*end*]";
  param_sep = "[*|*]";
  max_size_message = 999999;
  
  tv_sec = 0;
  tv_usec = 10;
  
  verboseMode = false;

#ifdef WIN32
  //Enable the sockets to be used
  //Note that: if we were using "winsock.h" instead of "winsock2.h" we would had to use:
  //WSAStartup(MAKEWORD(1,0), &WSAData);
  WSADATA WSAData;
  WSAStartup(MAKEWORD(2,0), &WSAData);
#endif
}

vpNetwork::~vpNetwork()
{
#ifdef WIN32
  WSACleanup();
#endif
}

void vpNetwork::addDecodingRequest(vpRequest *req)
{
  bool alreadyHas = false;
  
  for(unsigned int i = 0 ; i < request_list.size() ; i++)
    if(request_list[i]->getId() == req->getId()){
      alreadyHas = true;
      break;
    }
  
  if(alreadyHas)
    std::cout << "Server already has one request with the similar ID. Request hasn't been added." << std::endl;
  else
    request_list.push_back(req);
}

void vpNetwork::removeDecodingRequest(const char *id)
{
  for(unsigned int i = 0 ; i < request_list.size() ; i++)
  {
    if(request_list[i]->getId() == id)
    {
      request_list.erase(request_list.begin()+i);
      break;
    }
  }
}

void vpNetwork::print(const char *id)
{
  for(unsigned int i = 0 ; i < receptor_list.size() ; i++)
  {
    std::cout << id << i << " : " << inet_ntoa(receptor_list[i].receptorAddress.sin_addr) << std::endl;
  }
}

int vpNetwork::getReceptorIndex(const char *name)
{
  struct hostent *server = gethostbyname(name);
  
  if ( server == NULL )
  {
    std::string noSuchHostMessage( "ERROR, " );
    noSuchHostMessage.append( name );
    noSuchHostMessage.append( ": no such host\n" );
    vpERROR_TRACE( noSuchHostMessage.c_str(), "vpClient::getReceptorIndex()" );
  }
  
  std::string ip = inet_ntoa(*(in_addr *)server->h_addr);
  
  for(unsigned int i = 0 ; i < receptor_list.size() ; i++)
  {
    if(receptor_list[i].receptorIP == ip)
      return i;
  }
  
  return -1;
}

int vpNetwork::sendRequest(vpRequest &req)
{
  return sendRequestTo(req,0);
}

int vpNetwork::sendRequestTo(vpRequest &req, const int &dest)
{
  if(receptor_list.size() == 0 || dest > (int)receptor_list.size()-1)
  {
    if(verboseMode)
      vpTRACE( "Cannot Send Request! Bad Index" );
    return 0;
  }
  
  std::string message = beginning + req.getId() + separator;
  
  if(req.size() != 0){
    message += req[0];
    
    for(unsigned int i = 1 ; i < req.size() ; i++){
        message += param_sep + req[i];
    }
  }
  
  message += end;
  
  int flags = 0;
#if ! defined(APPLE) && ! defined(WIN32)
  flags = MSG_NOSIGNAL; // Only for Linux
#endif

  int value = sendto(receptor_list[dest].socketFileDescriptorReceptor, message.c_str(), message.size(), flags,
                     (sockaddr*) &receptor_list[dest].receptorAddress,receptor_list[dest].receptorAddressSize);
  
  return value;
}

int vpNetwork::sendAndEncodeRequest(vpRequest &req)
{
  req.encode();
  return sendRequest(req);
}

int vpNetwork::sendAndEncodeRequestTo(vpRequest &req, const int &dest)
{
  req.encode();
  return sendRequestTo(req,dest);
}

std::vector<int> vpNetwork::receiveRequest()
{
  _receiveRequest();
  return _handleRequests();
}

std::vector<int> vpNetwork::receiveRequestFrom(const int &receptorEmitting)
{
  _receiveRequestFrom(receptorEmitting);
  return _handleRequests();
}

int vpNetwork::receiveRequestOnce()
{
  _receiveRequestOnce();
  return _handleFirstRequest();
}

int vpNetwork::receiveRequestOnceFrom(const int &receptorEmitting)
{
  _receiveRequestOnceFrom(receptorEmitting);
  return _handleFirstRequest();
}

std::vector<int> vpNetwork::receiveAndDecodeRequest()
{
  std::vector<int> res = receiveRequest();
  for(unsigned int i = 0 ; i < res.size() ; i++)
    if(res[i] != -1)
      request_list[res[i]]->decode();
    
  return res;
}

std::vector<int> vpNetwork::receiveAndDecodeRequestFrom(const int &receptorEmitting)
{
  std::vector<int> res = receiveRequestFrom(receptorEmitting);
  for(unsigned int i = 0 ; i < res.size() ; i++)
    if(res[i] != -1)
      request_list[res[i]]->decode();
  
    return res;
}

int vpNetwork::receiveAndDecodeRequestOnce()
{
  int res = receiveRequestOnce();
  if(res != -1)
    request_list[res]->decode();
  
  return res;
}

int vpNetwork::receiveAndDecodeRequestOnceFrom(const int &receptorEmitting)
{
  int res = receiveRequestOnceFrom(receptorEmitting);
  if(res != -1)
    request_list[res]->decode();
  
  return res;
}
  

//######## Definition of Template Functions ########
//#                                                #
//##################################################


std::vector<int> vpNetwork::_handleRequests()
{
  std::vector<int> resIndex;
  int index = _handleFirstRequest();
  
  while(index != -1)
  {
    resIndex.push_back(index);
    index = _handleFirstRequest();
  }
  
  return resIndex;
}

int vpNetwork::_handleFirstRequest()
{
  int indStart = currentMessageReceived.find(beginning);
  int indSep = currentMessageReceived.find(separator);
  int indEnd = currentMessageReceived.find(end);
  
  if (indStart == -1 && indSep == -1 && indEnd == -1)
  {
    if(currentMessageReceived.size() != 0)
      currentMessageReceived.clear();
    
    if(verboseMode)
      vpTRACE("Incorrect message");
    
    return -1;
  }
  
  if(indStart == -1 || indSep == -1 || indEnd == -1)
    return -1;
  
  if(indEnd < indStart)
  {
    if(verboseMode)
      vpTRACE("Incorrect message");
    currentMessageReceived.erase(indStart,indEnd+end.size());
    return -1;
  }
  
  int indStart2 = currentMessageReceived.find(beginning,indStart+1);
  if(indStart2 != -1 && indStart2 < indEnd)
  {
    if(verboseMode)
      vpTRACE("Incorrect message");
    currentMessageReceived.erase(indStart,indStart2);
    return -1;
  }
  
  int deb = indStart + beginning.size();
  std::string id = currentMessageReceived.substr(deb, indSep - deb);
  
  deb = indSep+separator.size();
  std::string params = currentMessageReceived.substr(deb, indEnd - deb);
  
//   std::cout << "Handling : " << currentMessageReceived.substr(indStart, indEnd+end.size() - indStart) << std::endl;
   
  int indRequest;
  bool hasBeenFound = false;
  for(unsigned int i = 0 ; i < request_list.size() ; i++)
  {
    if(id == request_list[i]->getId()){
        hasBeenFound = true;
        request_list[i]->clear();
        indRequest = i;
        break;
    }
  }
  
  if(!hasBeenFound){
    //currentMessageReceived.erase(indStart,indEnd+end.size());
    if(verboseMode)
      vpTRACE("No request corresponds to the received message");
    return -1;
  }
  
  int indDebParam = indSep + separator.size();
  int indEndParam = currentMessageReceived.find(param_sep,indDebParam);
  
  std::string param;
  while(indEndParam != -1)
  {
    param = currentMessageReceived.substr(indDebParam, indEndParam - indDebParam);
    request_list[indRequest]->addParameter(param);
    indDebParam = indEndParam+param_sep.size();
    indEndParam = currentMessageReceived.find(param_sep,indDebParam);
  }
  
  param = currentMessageReceived.substr(indDebParam, indEnd - indDebParam);
  request_list[indRequest]->addParameter(param);
  currentMessageReceived.erase(indStart,indEnd+end.size());
  
  return indRequest;
}

void vpNetwork::_receiveRequest()
{
  while(_receiveRequestOnce() > 0) {};
}

void vpNetwork::_receiveRequestFrom(const int &receptorEmitting)
{
  while(_receiveRequestOnceFrom(receptorEmitting) > 0) {};
}

int vpNetwork::_receiveRequestOnce()
{
  if(receptor_list.size() == 0)
  {
    if(verboseMode)
      vpTRACE( "No Receptor!" );
    return -1;
  }
  
  tv.tv_sec = tv_sec;
  tv.tv_usec = tv_usec;
  
  FD_ZERO(&readFileDescriptor);        
  
  for(unsigned int i=0; i<receptor_list.size(); i++){ 
    if(i == 0)
      socketMax = receptor_list[i].socketFileDescriptorReceptor;
    
    FD_SET(receptor_list[i].socketFileDescriptorReceptor,&readFileDescriptor); 
    if(socketMax < receptor_list[i].socketFileDescriptorReceptor) socketMax = receptor_list[i].socketFileDescriptorReceptor; 
  }

  int value = select(socketMax+1,&readFileDescriptor,NULL,NULL,&tv);
  int numbytes = 0;
  
  if(value == -1){
    if(verboseMode)
      vpERROR_TRACE( "Select error" );
    return -1;
  }
  else if(value == 0){
    //Timeout
    return 0;
  }
  else{
    for(unsigned int i=0; i<receptor_list.size(); i++){
      if(FD_ISSET(receptor_list[i].socketFileDescriptorReceptor,&readFileDescriptor)){
        char *buf = new char [max_size_message];
        numbytes=recv(receptor_list[i].socketFileDescriptorReceptor, buf, max_size_message, 0);
        
        if(numbytes <= 0)
        {
          std::cout << "Disconnected : " << inet_ntoa(receptor_list[i].receptorAddress.sin_addr) << std::endl;
          receptor_list.erase(receptor_list.begin()+i);
          return numbytes;
        }
        else if(numbytes > 0){
          std::string returnVal(buf, numbytes);              
          currentMessageReceived.append(returnVal);
        }
        delete [] buf;
        break;
      }
    }
  }
  
  return numbytes;
}

int vpNetwork::_receiveRequestOnceFrom(const int &receptorEmitting)
{
  if(receptor_list.size() == 0 || receptorEmitting > (int)receptor_list.size()-1 )
  {
    if(verboseMode)
      vpTRACE( "No receptor at the specified index!" );
    return -1;
  }
  
  tv.tv_sec = tv_sec;
  tv.tv_usec = tv_usec;
  
  FD_ZERO(&readFileDescriptor);        
  
  socketMax = receptor_list[receptorEmitting].socketFileDescriptorReceptor;
  FD_SET(receptor_list[receptorEmitting].socketFileDescriptorReceptor,&readFileDescriptor);

  int value = select(socketMax+1,&readFileDescriptor,NULL,NULL,&tv);
  int numbytes = 0;
  if(value == -1){
    if(verboseMode)
      vpERROR_TRACE( "Select error" );
    return -1;
  }
  else if(value == 0){
    //Timeout
    return 0;
  }
  else{
    if(FD_ISSET(receptor_list[receptorEmitting].socketFileDescriptorReceptor,&readFileDescriptor)){
      char *buf = new char [max_size_message];
      numbytes=recv(receptor_list[receptorEmitting].socketFileDescriptorReceptor, buf, max_size_message, 0);
      
      if(numbytes <= 0)
      {
        std::cout << "Disconnected : " << inet_ntoa(receptor_list[receptorEmitting].receptorAddress.sin_addr) << std::endl;
        receptor_list.erase(receptor_list.begin()+receptorEmitting);
        return numbytes;
      }
      else if(numbytes > 0){
        std::string returnVal(buf, numbytes);              
        currentMessageReceived.append(returnVal);
      }
      delete [] buf;
    }
  }
  
  return numbytes;
}