Host.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS system source for the DUNE DAQ project.
// Fork baseline commit: system-00-00-20 (2020-09-25).
// Renamed since fork: yes (from src/Host.cxx to src/Host.cpp).
 
/*
 *  Host.cxx
 *  OksSystem
 *
 *  Created by Matthias Wiesmann on 03.02.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/utsname.h>
 
#include <unistd.h>
 
#include <iostream>
#include <sstream>
#include <strings.h>
 
#include "okssystem/Host.hpp"
 
#define BUFFER_SIZE 256

 
struct sockaddr_in
OksSystem::Host::resolve(const std::string& name) throw()
{
  struct addrinfo* info_ptr;
  const char* str = name.c_str();
  const int status = getaddrinfo(str, 0, 0, &info_ptr);
  struct sockaddr_in address;
  bzero(&address, sizeof(address));
  address.sin_family = AF_INET;
  address.sin_addr.s_addr = 0;
  if (status == 0) {
    struct sockaddr_in* ptr = (sockaddr_in*)info_ptr->ai_addr;
    address = *ptr;
    freeaddrinfo(info_ptr);
  } // if
  return address;
} // resolve

 
std::string
OksSystem::Host::resolve(struct sockaddr_in address) throw()
{
  char buffer[NI_MAXHOST];
  const struct sockaddr* ptr = (const struct sockaddr*)&address;
  const int status = getnameinfo(ptr, sizeof(address), buffer, sizeof(buffer), 0, 0, 0);
  if (status != 0)
    return to_string(address);
  return std::string(buffer);
} // resolve

 
std::string
OksSystem::Host::expand(const std::string& name) throw()
{
  const struct sockaddr_in address = resolve(name);
  if (address.sin_addr.s_addr != 0)
    return resolve(address);
  return std::string(name);
} // expand

 
std::string
OksSystem::Host::to_string(struct sockaddr_in ip_addr)
{
  const char* s = inet_ntoa(ip_addr.sin_addr);
  return std::string(s);
} // to_string
 
// Constructors, destructors
// --------------------------

 
OksSystem::Host::Host() throw() {} // Host
 
OksSystem::Host::Host(const OksSystem::Host& other)
{
  m_name = other.m_name;
  if (!other.m_full_name.empty()) {
    m_full_name = other.m_full_name;
  } // if
} // Host

 
OksSystem::Host::Host(const std::string& s_name)
{
  m_name = s_name;
} // Host
 
OksSystem::Host::Host(struct sockaddr_in ip_addr)
{
  m_name = resolve(ip_addr);
  m_full_name = m_name;
} // Host
 
OksSystem::Host::~Host() throw() {} // OksSystem
 
// Operator
// --------------------------

 
OksSystem::Host::operator struct sockaddr_in() const throw()
{
  return ip();
} // struct sockaddr_in

 
bool
OksSystem::Host::equals(const Host& other) const throw()
{
  return full_name() == other.full_name();
} // equals
 
// Methods
// --------------------------

 
const std::string&
OksSystem::Host::name() const throw()
{
  return m_name;
}

 
struct sockaddr_in
OksSystem::Host::ip() const throw()
{
  return resolve(m_name);
}

 
const std::string&
OksSystem::Host::full_name() const throw()
{
  if (m_full_name.empty()) {
    m_full_name = expand(m_name);
  } // if
  return m_full_name;
} // full_name

 
std::string
OksSystem::Host::ip_string() const throw()
{
  const struct sockaddr_in address = ip();
  return to_string(address);
} // ip_string
 
bool
OksSystem::operator==(const Host& a, const Host& b) throw()
{
  return a.equals(b);
} // operator ==
 
bool
OksSystem::operator!=(const Host& a, const Host& b) throw()
{
  return !a.equals(b);
} // operator ≠
 
// Local Host
// --------------------------

 
OksSystem::LocalHost* OksSystem::LocalHost::s_instance = 0;

 
const std::string&
OksSystem::LocalHost::local_name() throw()
{
  return instance()->name();
} // localhostname

 
const std::string&
OksSystem::LocalHost::full_local_name() throw()
{
  return instance()->full_name();
} // fulllocalhostname

 
const OksSystem::LocalHost*
OksSystem::LocalHost::instance() throw()
{
  if (0 == s_instance) {
    s_instance = new LocalHost();
  } //
  return s_instance;
} // instance

 
OksSystem::LocalHost::LocalHost() throw()
  : Host()
{
  struct utsname u_name_data;
  const int status = ::uname(&u_name_data);
  if (status == 0) {
    m_name = u_name_data.nodename;
    m_os_name = u_name_data.sysname;
    m_release = u_name_data.release;
    m_version = u_name_data.version;
    m_machine = u_name_data.machine;
  } else {
    char buffer[NI_MAXHOST];
    const int host_status = gethostname(buffer, sizeof(buffer));
    if (host_status == 0) {
      m_name = buffer;
    } else { // both uname and gethostname screwed
      m_name.clear();
    } // check for host_name
  } // uname failed.
} // LocalHost
 
OksSystem::LocalHost::~LocalHost() throw()
{
  //  delete s_instance;
}

 
const std::string&
OksSystem::LocalHost::os_name() const throw()
{
  return m_os_name;
} // os_name

 
const std::string&
OksSystem::LocalHost::os_release() const throw()
{
  return m_release;
} // os_release

 
const std::string&
OksSystem::LocalHost::os_version() const throw()
{
  return m_version;
} // os_version

 
const std::string&
OksSystem::LocalHost::machine() const throw()
{
  return m_machine;
} // machine

 
const std::string&
OksSystem::LocalHost::description() const throw()
{
  if (m_description.empty()) {
    std::ostringstream stream;
    stream << m_os_name << " " << m_release << "/" << m_machine;
    m_description = stream.str();
  }
  return m_description;
} // description

 
const char*
OksSystem::getfullhost() throw()
{
  const std::string& str = OksSystem::LocalHost::full_local_name();
  return str.c_str();
} // full_host_name

 
bool
OksSystem::operator==(const LocalHost&, const LocalHost&) throw()
{
  return true;
}

 
bool
OksSystem::operator!=(const LocalHost&, const LocalHost&) throw()
{
  return false;
}
 
std::ostream&
operator<<(std::ostream& stream, const OksSystem::Host& host)
{
  stream << host.full_name();
  return stream;
} // operator<<