TSocket.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
 
// System include(s):
extern "C" {
#   include <sys/types.h>
#   include <sys/socket.h>
#   include <netinet/in.h>
#   include <arpa/inet.h>
#   include <unistd.h>
#   include <netdb.h>
}
#include <cstring>
 
// ROOT include(s):
#include <TString.h>
#include <TInetAddress.h>
 
// Local include(s):
#include "xAODRootAccess/tools/TSocket.h"
 
namespace xAOD {
 
   TSocket::TSocket()
      : m_socket( -1 ) {
 
   }
 
   TSocket::~TSocket() {
 
      // Close the socket if it's open:
      if( isConnected() ) {
         close().ignore();
      }
   }
 
   StatusCode TSocket::connect( const TInetAddress& address, int port ) {
 
      // If the address is invalid, give up now:
      if( ! address.IsValid() ) {
         return StatusCode::FAILURE;
      }
 
      // If not, translate it to a network address:
      const UInt_t adr = htonl( address.GetAddress() );
 
      // "Translate" the port number:
      short sport = 0;
      struct servent sp_buf;
      struct servent *sp;
      char buf[1024];  // needs to be large enough for all strings in servent
      getservbyport_r( htons( port ), "tcp", &sp_buf, buf, sizeof(buf), &sp );
      if( sp ) {
         sport = sp->s_port;
      } else {
         sport = htons( port );
      }
 
      // Create a socket:
      m_socket = ::socket( AF_INET, SOCK_STREAM, 0 );
      if( m_socket < 0 ) {
         return StatusCode::FAILURE;
      }
 
      // Create the address that we want to connect to:
      struct sockaddr_in server;
      memset( &server, 0, sizeof( server ) );
      memcpy( &server.sin_addr, &adr, sizeof( adr ) );
      server.sin_family = address.GetFamily();
      server.sin_port = sport;
 
      // Connect to the address:
      if( ::connect( m_socket, ( struct sockaddr* ) &server,
                     sizeof( server ) ) < 0 ) {
         m_socket = -1;
         return StatusCode::FAILURE;
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
 
   StatusCode TSocket::close() {
 
      // Check if anything needs to be done:
      if( ! isConnected() ) {
         return StatusCode::RECOVERABLE;
      }
 
      // Close the socket:
      if( ::close( m_socket ) != 0 ) {
         return StatusCode::FAILURE;
      }
 
      // Return gracefully:
      m_socket = -1;
      return StatusCode::SUCCESS;
   }
 
   bool TSocket::isConnected() const {
 
      return ( m_socket != -1 );
   }
 
   StatusCode TSocket::send( const TString& payload ) {
 
      // Check if we're connected:
      if( ! isConnected() ) {
         return StatusCode::FAILURE;
      }
 
      // The buffer we are sending from:
      const char* buffer = payload.Data();
      // The total length of the message:
      const auto length = payload.Length();
      // Number of bytes already sent:
      int sent = 0;
 
      // Keep sending the message until everything is through:
      for( int i = 0; i < length; i += sent ) {
         sent = ::send( m_socket, buffer + i, length - i, 0 );
         if( sent < 0 ) {
            return StatusCode::FAILURE;
         } else if( sent == 0 ) {
            break;
         }
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }
   
} // namespace xAOD