UDPServer.cc

#include "UDPServer.hh"
#include<Base/Common/W32Compat.hh>

#ifdef WIN32
#  include <winsock.h>
#  include <io.h>
#else
#  include <sys/socket.h>
#  include <sys/types.h>
#  include <arpa/inet.h>
#  include <netdb.h>
#endif

#include <cstdlib>
#include <string>
#include <cstring>
#include <iostream>
#include <cstdio>
#include <Base/Debug/Error.hh>
#include <Base/Debug/TimeMeasure.hh>

#include "errno.h"

#include <Base/Common/BIASpragma.hh>

using namespace std;
using namespace BIAS;

UDPServer::UDPServer() { 
  socket_descriptor_ = 0;
  // Prepare the send buffer
  send_buffer_ = new char[UDP_PACKAGE_SIZE];
  // Number of the first message to be sent
  message_counter_ = 0;
  TCPinsteadOfUDP_ = false;
  Throttle_=1;
} // constructor



UDPServer::~UDPServer() {
  delete[] send_buffer_;
  Disconnect();  
} // destructor


int UDPServer::Send(const char *message, const size_t message_size) 
{
  BIASCDOUT(D_UDP_SEND,"Send: "<<message_size<<endl);
  BIAS::TimeMeasure t1;
  if (socket_descriptor_ <= 0) {
    BIASERR("UDPServer:send(): not connected. Use Connect()");
    return -1;
  }

  // Convert the beginning of the send buffer to an message frame header
  message_frame_header* mfh = (message_frame_header*) send_buffer_;

  // Save the message_number
  BIASCDOUT(D_UDP_SEND,"Message counter: "<<message_counter_<<endl);
  mfh->message_number = message_counter_++;
  if (message_counter_ > maxMessageNumber) 
    message_counter_ = 0;

  // Calculate the necessary number of frames to send the message
  // with the message header at the beginning of each udp package
  register int message_frames_total;
  message_frames_total = (int)message_size / (UDP_PACKAGE_SIZE - sizeof(message_frame_header)) + 1;
  BIASCDOUT(D_UDP_SEND,"Message frames to send image: "<<message_frames_total<<endl);
  
  if ( ( message_size % (UDP_PACKAGE_SIZE - sizeof(message_frame_header)) )==0)
    message_frames_total--;
  
  MessageSize_ = (unsigned int)message_size + 
    message_frames_total*sizeof(message_frame_header);

  // Write the number of message frames into the message frame header
  mfh->message_frames_total = message_frames_total;

  // Calculate the start position for the message data in the send buffer
  char* data_start = send_buffer_ + sizeof(message_frame_header);
  
  
  // Calculate the available space for data
  int data_length = UDP_PACKAGE_SIZE - sizeof(message_frame_header);

  // Real size of message data put into the send buffer (changes only at the last message frame)
  int actual_data_length = data_length;
//   t1.Start();
  //
  // Now we can start sending udp packages
  //
  for (int i = 0; i < message_frames_total; i++) {
    
    // Is it the last frame?
    if ( i == (message_frames_total - 1) ) {
      actual_data_length = (int)message_size - (i * data_length);
    } 

    // Copy the message data into the send buffer
    memcpy(data_start, &((char*) message)[i * data_length], actual_data_length);

    // Save the current frame number in the frame header
    mfh->message_frame_number = i;
    int bytes_sent;
    if (TCPinsteadOfUDP_) {
      bytes_sent = send( socket_descriptor_, 
             send_buffer_, 
             sizeof(message_frame_header) + actual_data_length, 
             0);        
      
    }
    else {
      // Send the send buffer using the udp socket
      bytes_sent = sendto( socket_descriptor_, 
               send_buffer_, 
               sizeof(message_frame_header) + actual_data_length, 
               0, 
               (struct sockaddr*) &UDPSockAddr_, 
               sizeof(UDPSockAddr_));       
      BIASCDOUT(D_UDP_SEND,"Sendto in "<<i<<" th iteration."<<endl);
    }
    if (bytes_sent < 0) {
      syscallerror("Failed to send via UDP Socket. Stop sending packages!");
#ifdef WIN32
      int error = WSAGetLastError();
#endif
      return -1;
    }
    if (Throttle_ >0)
      biasusleep(Throttle_ * 1000); // wait a bit, to avoid UDP packet collisions 
    //     cout <<"Send frame "<<i<<" with size: "<<sizeof(message_frame_header) 
    //       + actual_data_length<<endl;
  } // for 
  //   t1.Stop();
  //   cout <<"throttle: "<<Throttle_<<" frames per message: "<<message_frames_total<<" time [ms]: "<<t1.GetRealTime()/1000<<endl;
  //   t1.Reset();
  return mfh->message_frames_total;

} // send()


int UDPServer::SendToUDP (const char* message, const size_t message_size, const char* ipAddress, int port) {

    if (TCPinsteadOfUDP_) {
        BIASERR("UDPServer: SendToUDP is only usable with UDP sockets");
        return -1;
    }

    BIASCDOUT(D_UDP_SEND,"SendToUDP: "<< message_size << endl);
  if (socket_descriptor_ <= 0) {
    BIASERR("UDPServer: SendToUDP(): invalid socket descriptor, call Connect before sending");
    return -1;
  }

  // Convert the beginning of the send buffer to an message frame header
  message_frame_header* mfh = (message_frame_header*) send_buffer_;

  // Save the message_number
  BIASCDOUT(D_UDP_SEND,"Message counter: "<<message_counter_<<endl);
  mfh->message_number = message_counter_++;
  if (message_counter_ > maxMessageNumber) 
    message_counter_ = 0;

  // Calculate the necessary number of frames to send the message
  // with the message header at the beginning of each udp package
  register int message_frames_total;
  message_frames_total = (int)message_size / (UDP_PACKAGE_SIZE - sizeof(message_frame_header)) + 1;
  BIASCDOUT(D_UDP_SEND,"Message frames to send image: "<<message_frames_total<<endl);
  
  if ( ( message_size % (UDP_PACKAGE_SIZE - sizeof(message_frame_header)) ) == 0)
    message_frames_total--;
  
  MessageSize_ = (unsigned int)message_size + 
    message_frames_total*sizeof(message_frame_header);

  // Write the number of message frames into the message frame header
  mfh->message_frames_total = message_frames_total;

  // Calculate the start position for the message data in the send buffer
  char* data_start = send_buffer_ + sizeof(message_frame_header);
  
  
  // Calculate the available space for data
  int data_length = UDP_PACKAGE_SIZE - sizeof(message_frame_header);

  // Real size of message data put into the send buffer (changes only at the last message frame)
  int actual_data_length = data_length;

  // Now we can start sending udp packages
  for (int i = 0; i < message_frames_total; i++) {
    
    // Is it the last frame?
    if ( i == (message_frames_total - 1) ) {
      actual_data_length = (int)message_size - (i * data_length);
    } 

    // Copy the message data into the send buffer
    memcpy(data_start, &((char*) message)[i * data_length], actual_data_length);

    // Save the current frame number in the frame header
    mfh->message_frame_number = i;
    int bytes_sent;

        // Prepare structure for remote host sending
        struct sockaddr_in UDPHostAddr;
        hostent* remoteHost;
        unsigned int addr;

        if (strlen(ipAddress) < 16) {
            
            addr = inet_addr(ipAddress);
            if((remoteHost = gethostbyaddr((char *) &addr, 4, AF_INET)) == NULL) {
                syscallerror("Could not retrieve host information for ip address: " << ipAddress);
                exit(-1);
            }
        } else {
            syscallerror("Error: supplied host IPv4 address string is too large.");
            exit(255);
        }

        char* ip = inet_ntoa(*((struct in_addr *)remoteHost->h_addr));

        memset(&UDPHostAddr, 0, sizeof(UDPHostAddr));
        UDPHostAddr.sin_family = AF_INET;
        UDPHostAddr.sin_addr.s_addr = inet_addr(ip);
        UDPHostAddr.sin_port = htons(port);
        
        // Send the send buffer using the udp socket
        bytes_sent = sendto(socket_descriptor_, send_buffer_,
                              sizeof(message_frame_header) + actual_data_length, 0,
                                                (struct sockaddr*) &UDPHostAddr, sizeof(UDPHostAddr));
        BIASCDOUT(D_UDP_SEND,"Sendto in "<<i<<" th iteration."<<endl);

if (bytes_sent < 0) {
      syscallerror("Failed to send via UDP Socket. Stop sending packages!");
#ifdef WIN32
      int error = WSAGetLastError();
#endif
      return -1;
    }
    if (Throttle_ >0)
      biasusleep(Throttle_ * 1000); // wait a bit, to avoid UDP packet collisions 
  } // for 
  return mfh->message_frames_total;
}
  

int UDPServer::Connect(const char* ipaddress_or_name, int port, bool UseTCP ) 
{
    TCPinsteadOfUDP_ = UseTCP;
    hostent* remoteHost;

#ifdef WIN32
  WORD wVersionRequested;
  WSADATA wsaData;
  int err=0;
  /* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
  wVersionRequested = MAKEWORD(2, 2);
  err = WSAStartup(wVersionRequested, &wsaData);
  if (err != 0) {
    /* Tell the user that we could not find a usable */
    /* Winsock DLL.                                  */
    syscallerror("WSAStartup failed with error: "<< err);
    return 1;
  }
#endif

    unsigned int addr;  
    if (!isalpha(ipaddress_or_name[0]))    /* host address is an IPv4 address */
    {
        if (strlen(ipaddress_or_name) < 16)
        {
            addr = inet_addr(ipaddress_or_name);
            if((remoteHost = gethostbyaddr((char *) &addr, 4, AF_INET))==NULL){
                syscallerror("Could not retrieve IP address of client name: "<<ipaddress_or_name);
                exit(-1);
            }
        }
        else
        {
            syscallerror("error: Supplied host IPv4 address string is too large.");
            exit(255);
        }
    }
    else{
      if ( (remoteHost = gethostbyname(ipaddress_or_name) ) == NULL) {
        syscallerror("Could not retrieve IP address of client name: "<<ipaddress_or_name);
        exit(-1);
      }
    }

  char* ipaddress = inet_ntoa(*((struct in_addr *)remoteHost->h_addr));

  // Set up the destination address
  memset( &UDPSockAddr_, 0, sizeof(UDPSockAddr_));
  UDPSockAddr_.sin_family = AF_INET;
  UDPSockAddr_.sin_addr.s_addr = inet_addr(ipaddress);
  UDPSockAddr_.sin_port = htons(port);  

  if (TCPinsteadOfUDP_) {
    int res;
    socket_descriptor_ = socket(AF_INET, SOCK_STREAM,0);
    do {
      res=connect( socket_descriptor_, (sockaddr*)&UDPSockAddr_,
           sizeof(UDPSockAddr_));
      if (res <0) perror("Failed to connect");
      biassleep(1);
    }
    while (res <0);
  }
  else
    socket_descriptor_ = socket(AF_INET, SOCK_DGRAM,0);
  if (socket_descriptor_ < 0) {
    cerr << "UDPServer: An error has occured while creating a UDP" <<
      " socket. Could not send any data.\n";
    return -1;
  }
  
  return 0;
}


int UDPServer::Connect(int port, bool UseTCP )
{
  TCPinsteadOfUDP_ = UseTCP;
#ifdef WIN32
  WORD wVersionRequested;
  WSADATA wsaData;
  int err=0;
  /* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
  wVersionRequested = MAKEWORD(2, 2);
  err = WSAStartup(wVersionRequested, &wsaData);
  if (err != 0) {
    /* Tell the user that we could not find a usable */
    /* Winsock DLL.                                  */
    syscallerror("WSAStartup failed with error: "<< err);
    return 1;
  }
#endif

  // Set up the destination address
  memset( &UDPSockAddr_, 0, sizeof(UDPSockAddr_));
  UDPSockAddr_.sin_family = AF_INET;
  UDPSockAddr_.sin_addr.s_addr = INADDR_ANY; //INADDR_BROADCAST; //ANY or BROADCAST??
  UDPSockAddr_.sin_port = htons(port);

  if (TCPinsteadOfUDP_) {
    int res;
    socket_descriptor_ = socket(AF_INET, SOCK_STREAM,0);
    do {
      res=connect( socket_descriptor_, (sockaddr*)&UDPSockAddr_,
       sizeof(UDPSockAddr_));
      if (res <0) perror("Failed to connect");
      biassleep(1);
    }
    while (res <0);
  }
  else
    socket_descriptor_ = socket(AF_INET, SOCK_DGRAM,0);
  if (socket_descriptor_ < 0) {
    cerr << "UDPServer: An error has occured while creating a UDP" <<
      " socket. Could not send any data.\n";
    return -1;
  }
  return 0;
}

int UDPServer::Disconnect()
{
 // Shutdown the socket
  if(socket_descriptor_ >=0){

#ifndef WIN32
    close(socket_descriptor_);
#else
    closesocket(socket_descriptor_);
    WSACleanup();
#endif
   
  }
  return 0;
}