source: flair-src/trunk/lib/FlairCore/src/UdtSocket.cpp@ 316

// %flair:license{
// This file is part of the Flair framework distributed under the
// CECILL-C License, Version 1.0.
// %flair:license}
//  created:    2015/04/21
//  filename:   UdtSocket.cpp
//
//  author:     Gildas Bayard
//              Copyright Heudiasyc UMR UTC/CNRS 7253
//
//  version:    $Id: $
//
//  purpose:    Class defining a UDT socket
//
//
/*********************************************************************/
#include "UdtSocket.h"
#include <udt.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

using std::string;

namespace flair {
namespace core {

UdtSocket::UdtSocket(const Object *parent, const std::string name,
                     bool _blockOnSend, bool _blockOnReceive)
    : ConnectedSocket(parent, name) {
  UDT::startup();
  blockOnSend = _blockOnSend;
  blockOnReceive = _blockOnReceive;
}

UdtSocket::~UdtSocket() {}

void UdtSocket::Listen(const unsigned int port,
                       const std::string localAddress) {
  socket = UDT::socket(AF_INET, SOCK_DGRAM, 0);

  UDT::setsockopt(socket, 0, UDT_SNDSYN, &blockOnSend, sizeof(bool));
  UDT::setsockopt(socket, 0, UDT_RCVSYN, &blockOnReceive, sizeof(bool));
  bool reuse = true;
  UDT::setsockopt(socket, 0, UDT_REUSEADDR, &reuse, sizeof(bool));

  sockaddr_in my_addr;
  my_addr.sin_family = AF_INET;
  my_addr.sin_port = htons(port);
  if (localAddress == "ANY") {
    my_addr.sin_addr.s_addr = INADDR_ANY;
  } else {
    inet_aton(localAddress.c_str(), &(my_addr.sin_addr));
  }
  memset(&(my_addr.sin_zero), '\0', 8);

  if (UDT::ERROR == UDT::bind(socket, (sockaddr *)&my_addr, sizeof(my_addr))) {
    Err("bind, %s\n", UDT::getlasterror().getErrorMessage());
  }

  UDT::listen(socket, 1);
}

UdtSocket *UdtSocket::Accept(Time timeout) {
  // TIMEOUT UNSUPPORTED!!
  UdtSocket *acceptedSocket = new UdtSocket(this->Parent(), this->ObjectName());
  acceptedSocket->blockOnSend = this->blockOnSend;
  acceptedSocket->blockOnReceive = this->blockOnReceive;

  sockaddr_in their_addr;
  int namelen = sizeof(their_addr);

  if ((acceptedSocket->socket = UDT::accept(socket, (sockaddr *)&their_addr,
                                            &namelen)) == UDT::INVALID_SOCK) {
    Err("accept: %s, code %i\n", UDT::getlasterror().getErrorMessage(),
        UDT::getlasterror().getErrorCode());
  }

  return acceptedSocket;
}

bool UdtSocket::Connect(const unsigned int port,
                        const std::string distantAddress, Time timeout) {
  bool success = true;
  socket = UDT::socket(AF_INET, SOCK_DGRAM, 0);

  UDT::setsockopt(socket, 0, UDT_SNDSYN, &blockOnSend, sizeof(bool));
  UDT::setsockopt(socket, 0, UDT_RCVSYN, &blockOnReceive, sizeof(bool));
  bool reuse = true;
  UDT::setsockopt(socket, 0, UDT_REUSEADDR, &reuse, sizeof(bool));

  sockaddr_in serv_addr;
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(short(port));
  if (inet_pton(AF_INET, distantAddress.c_str(), &serv_addr.sin_addr) <= 0) {
    Warn("incorrect network address.\n");
    success = false;
  }
  memset(&(serv_addr.sin_zero), '\0', 8);

  if (UDT::ERROR ==
      UDT::connect(socket, (sockaddr *)&serv_addr, sizeof(serv_addr))) {
    success = false;
  }
  if (!success) {
    UDT::close(socket);
    return false;
  } else
    return true;
}

ssize_t UdtSocket::SendMessage(const char *buffer, size_t bufferSize,
                               Time timeout) {
  int udtTimeout = timeout;
  if (blockOnSend) {
    if (UDT::setsockopt(socket, 0, UDT_SNDTIMEO, &udtTimeout,
                        sizeof(udtTimeout)) != 0)
      Err("error UDT_SNDTIMEO %s\n", UDT::getlasterror().getErrorMessage());
  }
  ssize_t bytesSent = UDT::sendmsg(socket, buffer, bufferSize, -1, true);

  return bytesSent;
}

ssize_t UdtSocket::RecvMessage(char *buffer, size_t bufferSize, Time timeout) {
  int udtTimeout = timeout;
  if (blockOnReceive) {
    if (UDT::setsockopt(socket, 0, UDT_RCVTIMEO, &udtTimeout,
                        sizeof(udtTimeout)) != 0)
      Err("error UDT_RCVTIMEO %s\n", UDT::getlasterror().getErrorMessage());
  }
  ssize_t bytesRead = UDT::recvmsg(socket, buffer, bufferSize);

  /*
      if(bytesRead<0) {
          if(UDT::getlasterror().getErrorCode()==CUDTException::ECONNLOST) {
              connection_lost=true;
          }
      }
  */
  return bytesRead;
}

uint16_t UdtSocket::NetworkToHost16(uint16_t data) { return ntohs(data); }

uint16_t UdtSocket::HostToNetwork16(uint16_t data) { return htons(data); }

uint32_t UdtSocket::NetworkToHost32(uint32_t data) { return ntohl(data); }

uint32_t UdtSocket::HostToNetwork32(uint32_t data) { return htonl(data); }

} // end namespace core
} // end namespace flair