vpNetwork.h

/****************************************************************************
 *
 * $Id: vpNetwork.h 3820 2012-06-27 13:13:29Z 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
 *
 *****************************************************************************/

#ifndef vpNetwork_H
#define vpNetwork_H

#include <visp/vpConfig.h>
#include <visp/vpRequest.h>

#include <vector>
#include <stdio.h>
#include <string.h>
#include <iostream>

#ifdef UNIX
#  include <unistd.h>
#  include <sys/socket.h>
#  include <netinet/in.h>
#  include <arpa/inet.h>
#  include <netdb.h>
#else
#  include<io.h>
//#  include<winsock.h>
#  include<winsock2.h>
#  pragma comment(lib, "ws2_32.lib")
#endif


class VISP_EXPORT vpNetwork
{
protected:

  struct vpReceptor{
    int                   socketFileDescriptorReceptor;
#ifdef UNIX
    socklen_t             receptorAddressSize;
#else
    int                   receptorAddressSize;
#endif
    struct sockaddr_in    receptorAddress;
    std::string           receptorIP;
  };
  
  struct vpEmitter{
    struct sockaddr_in    emitterAdress;
    int                   socketFileDescriptorEmitter;
  };
  
  //######## PARAMETERS ########
  //#                          #
  //############################
  
  vpEmitter               emitter;
  std::vector<vpReceptor> receptor_list;
  fd_set                  readFileDescriptor;
  int                     socketMax;
  
  //Message Handling
  std::vector<vpRequest*> request_list;
  
  unsigned int            max_size_message;
  std::string             separator;
  std::string             beginning;
  std::string             end;
  std::string             param_sep;
  
  std::string             currentMessageReceived;
    
  struct timeval          tv;
  long                    tv_sec;
  long                    tv_usec;
  
  bool                    verboseMode;
  
private:
  
  std::vector<int>  _handleRequests();
  int               _handleFirstRequest();
  
  void              _receiveRequest();
  void              _receiveRequestFrom(const int &receptorEmitting);
  int               _receiveRequestOnce();
  int               _receiveRequestOnceFrom(const int &receptorEmitting);
  
public:

                    vpNetwork();
  virtual           ~vpNetwork();
  
  void              addDecodingRequest(vpRequest *);
  
  int               getReceptorIndex(const char *name);
  
  std::string       getRequestIdFromIndex(const int &ind){ 
                        if(ind >= (int)request_list.size() || ind < 0)
                          return "";
                        return request_list[ind]->getId(); 
                    }
  
  unsigned int      getMaxSizeReceivedMessage(){ return max_size_message; }
  
  virtual void      print(const char *id = "");
  
  template<typename T>
  int               receive(T* object, const int &sizeOfObject = sizeof(T));
  template<typename T>
  int               receiveFrom(T* object, const int &receptorEmitting, const int &sizeOfObject = sizeof(T));
  
  std::vector<int>  receiveRequest();
  std::vector<int>  receiveRequestFrom(const int &receptorEmitting);
  int               receiveRequestOnce();
  int               receiveRequestOnceFrom(const int &receptorEmitting);
  
  std::vector<int>  receiveAndDecodeRequest();
  std::vector<int>  receiveAndDecodeRequestFrom(const int &receptorEmitting);
  int               receiveAndDecodeRequestOnce();
  int               receiveAndDecodeRequestOnceFrom(const int &receptorEmitting);
  
  void              removeDecodingRequest(const char *);
  
  template<typename T>
  int               send(T* object, const int &sizeOfObject = sizeof(T));
  template<typename T>
  int               sendTo(T* object, const int &dest, const int &sizeOfObject = sizeof(T));
  
  int               sendRequest(vpRequest &req);
  int               sendRequestTo(vpRequest &req, const int &dest);
  
  int               sendAndEncodeRequest(vpRequest &req);
  int               sendAndEncodeRequestTo(vpRequest &req, const int &dest);
  
  void              setMaxSizeReceivedMessage(const unsigned int &s){ max_size_message = s;}
  
  void              setTimeoutSec(const long &sec){ tv_sec = sec; }
  
  void              setTimeoutUSec(const long &usec){ tv_usec = usec; }
  
  void              setVerbose(const bool &mode){ verboseMode = mode; }
};

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

template<typename T>
int vpNetwork::receive(T* object, const int &sizeOfObject)
{
  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++){
    FD_SET(receptor_list[i].socketFileDescriptorReceptor,&readFileDescriptor);

    if(i == 0)
      socketMax = receptor_list[i].socketFileDescriptorReceptor;
   
    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)){
        numbytes = recv(receptor_list[i].socketFileDescriptorReceptor, (char*)(void*)object, sizeOfObject, 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;
        }
        
        break;
      }
    }
  }
  
  return numbytes;
}

template<typename T>
int vpNetwork::receiveFrom(T* object, const int &receptorEmitting, const int &sizeOfObject)
{
  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)){
      numbytes = recv(receptor_list[receptorEmitting].socketFileDescriptorReceptor, (char*)(void*)object, sizeOfObject, 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;
      }
    }
  }
  
  return numbytes;
}

template<typename T>
int vpNetwork::send(T* object, const int &sizeOfObject)
{
  if(receptor_list.size() == 0)
  {
    if(verboseMode)
      vpTRACE( "No receptor !" );
    return 0;
  }
  
  int flags = 0;
#if ! defined(APPLE) && ! defined(WIN32)
  flags = MSG_NOSIGNAL; // Only for Linux
#endif
  return sendto(receptor_list[0].socketFileDescriptorReceptor, (const char*)(void*)object, sizeOfObject, 
                flags, (sockaddr*) &receptor_list[0].receptorAddress,receptor_list[0].receptorAddressSize);
}

template<typename T>
int vpNetwork::sendTo(T* object, const int &dest, const int &sizeOfObject)
{
  if(receptor_list.size() == 0 || dest > (int)receptor_list.size()-1 )
  {
    if(verboseMode)
      vpTRACE( "No receptor at the specified index." );
    return 0;
  }
  
  int flags = 0;
#if ! defined(APPLE) && ! defined(WIN32)
  flags = MSG_NOSIGNAL; // Only for Linux
#endif

  return sendto(receptor_list[dest].socketFileDescriptorReceptor, (const char*)(void*)object, sizeOfObject, 
                flags, (sockaddr*) &receptor_list[dest].receptorAddress,receptor_list[dest].receptorAddressSize);
}

#endif