Socket.cc

#include "otsdaq/NetworkUtilities/Socket.h"
#include "otsdaq/Macros/CoutMacros.h"
#include "otsdaq/MessageFacility/MessageFacility.h"
 
#include <cassert>
#include <iostream>
#include <sstream>
 
#include <arpa/inet.h>
#include <unistd.h>
// #include <sys/socket.h>
#include <netdb.h>
// #include <ifaddrs.h>
// #include <sys/ioctl.h>
// #if defined(SIOCGIFHWADDR)
// #include <net/if.h>
// #else
// #include <net/if_dl.h>
// #endif
// #include <cstdlib>
#include <cstring>
// #include <cstdio>
 
using namespace ots;
 
//==============================================================================
Socket::Socket(const std::string& IPAddress, unsigned int port)
    : socketNumber_(-1), IPAddress_(IPAddress), requestedPort_(port)
{
    __COUTT__ << "Socket constructor " << IPAddress << ":" << port << __E__;
 
    if(port >= (1 << 16))
    {
        __SS__ << "FATAL: Invalid Port " << port << ". Max port number is "
               << (1 << 16) - 1 << "." << std::endl;
        __SS_THROW__;
    }
 
    // network stuff
    socketAddress_.sin_family = AF_INET;      // use IPv4 host byte order
    socketAddress_.sin_port   = htons(port);  // short, network byte order
 
    __COUTT__ << "IPAddress: " << IPAddress << " port: " << port
              << " htons: " << socketAddress_.sin_port << std::endl;
 
    if(inet_aton(IPAddress.c_str(), &socketAddress_.sin_addr) == 0)
    {
        __SS__ << "FATAL: Invalid IP:Port combination. Please verify... " << IPAddress
               << ":" << port << std::endl;
        __SS_THROW__;
    }
 
    memset(&(socketAddress_.sin_zero), '\0', 8);  // zero the rest of the struct
 
    __COUTT__ << "Constructed socket for port " << ntohs(socketAddress_.sin_port) << "="
              << getPort() << " htons: " << socketAddress_.sin_port << std::endl;
}  //end constructor
 
//==============================================================================
Socket::Socket(void)
{
    __SS__ << "ERROR: This method should never be called. This is the protected "
              "constructor. There is something wrong in your inheritance scheme!"
           << std::endl;
    __SS_THROW__;
}  //end protected constructor
 
//==============================================================================
Socket::~Socket(void)
{
    __COUTT__ << "CLOSING THE SOCKET #" << socketNumber_ << " IP: " << IPAddress_
              << " port: " << getPort() << " htons: " << socketAddress_.sin_port
              << std::endl;
    if(socketNumber_ != -1)
        close(socketNumber_);
}  //end destructor
 
//==============================================================================
void Socket::initialize(unsigned int socketReceiveBufferSize)
{
    __COUT__ << "Initializing port " << ntohs(socketAddress_.sin_port)
             << " htons: " << socketAddress_.sin_port << std::endl;
    struct addrinfo  hints;
    struct addrinfo* res;
    int              status = 0;
 
    // first, load up address structs with getaddrinfo():
    memset(&hints, 0, sizeof hints);
    hints.ai_family   = AF_INET;     // use IPv4 for OtsUDPHardware
    hints.ai_socktype = SOCK_DGRAM;  // SOCK_DGRAM
    hints.ai_flags    = AI_PASSIVE;  // fill in my IP for me
 
    bool socketInitialized = false;
    int  fromPort          = FirstSocketPort;
    int  toPort            = LastSocketPort;
 
    if(ntohs(socketAddress_.sin_port) != 0)
        fromPort = toPort = ntohs(socketAddress_.sin_port);
 
    std::stringstream port;
 
    __COUT__ << "Attempting to bind a socket on IP: " << IPAddress_ << " to the first "
             << "available port in range [" << fromPort << ", " << toPort << "]..."
             << std::endl;
 
    for(int p = fromPort; p <= toPort && !socketInitialized; p++)
    {
        port.str("");
        port << p;
        __COUTT__ << "]\tBinding port: " << port.str() << std::endl;
        socketAddress_.sin_port = htons(p);  // short, network byte order
 
        if((status = getaddrinfo(NULL, port.str().c_str(), &hints, &res)) != 0)
        {
            __COUTT__ << "]\tGetaddrinfo error status: " << status << std::endl;
            continue;
        }
 
        // make a socket:
        socketNumber_ = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 
        __COUTT__ << "]\tSocket Number: " << socketNumber_
                  << " for port: " << ntohs(socketAddress_.sin_port) << " initialized."
                  << std::endl;
        // bind it to the port we passed in to getaddrinfo():
        if(bind(socketNumber_, res->ai_addr, res->ai_addrlen) == -1)
        {
            __COUTT__ << "]\tPort " << port.str() << " unavailable, trying next port..."
                      << std::endl;
            close(socketNumber_);  // otherwise every occupied port leaks a descriptor
            socketNumber_ = -1;
        }
        else
        {
            char yes = '1';
            setsockopt(socketNumber_, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
            socketInitialized = true;
            __COUT__ << "Socket on port: " << port.str() << " ON IP: " << IPAddress_
                     << " INITIALIZED OK! (socket #" << socketNumber_ << ")" << std::endl;
        }
 
        freeaddrinfo(res);  // free the linked-list
    }
 
    if(!socketInitialized)
    {
        __SS__ << "FATAL: Socket could not initialize socket (IP=" << IPAddress_
               << ", Port=" << ntohs(socketAddress_.sin_port)
               << "). Perhaps it is already in use?" << std::endl;
        __SS_THROW__;
    }
 
    __COUT__ << "Setting socket receive buffer size = " << socketReceiveBufferSize
             << " 0x" << std::hex << socketReceiveBufferSize << std::dec << __E__;
    if(setsockopt(socketNumber_,
                  SOL_SOCKET,
                  SO_RCVBUF,
                  (char*)&socketReceiveBufferSize,
                  sizeof(socketReceiveBufferSize)) < 0)
    {
        __COUT_ERR__ << "Failed to set socket receive size to " << socketReceiveBufferSize
                     << ". Attempting to revert to default." << std::endl;
 
        socketReceiveBufferSize = defaultSocketReceiveSize_;
 
        __COUT__ << "Setting socket receive buffer size = " << socketReceiveBufferSize
                 << " 0x" << std::hex << socketReceiveBufferSize << std::dec << __E__;
        if(setsockopt(socketNumber_,
                      SOL_SOCKET,
                      SO_RCVBUF,
                      (char*)&socketReceiveBufferSize,
                      sizeof(socketReceiveBufferSize)) < 0)
        {
            __SS__ << "Failed to set socket receive size to " << socketReceiveBufferSize
                   << ". Attempting to revert to default." << std::endl;
            __SS_THROW__;
        }
    }
 
    isInitialized_ = true;
}  //end initialize()
 
uint16_t Socket::getPort()
{
    return ntohs(socketAddress_.sin_port);
 
    //  //else extract from socket
    //  struct sockaddr_in sin;
    //  socklen_t len = sizeof(sin);
    //  getsockname(socketNumber_, (struct sockaddr *)&sin, &len);
    //  return ntohs(sin.sin_port);
}  //end getPort()
 
//==============================================================================
const struct sockaddr_in& Socket::getSocketAddress(void) { return socketAddress_; }