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 <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <netdb.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<<