JNetwork.hh

Go to the documentation of this file.

#ifndef __JSYSTEM__JNETWORK__
#define __JSYSTEM__JNETWORK__
 
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <ifaddrs.h>
#include <string.h>
#include <string>
#include <sstream>
#include <vector>
 
#include "JLang/JException.hh"
 
/**
 * \file
 * Hostname and IP address functions.
 * \author mdejong
 */
namespace JSYSTEM {}
namespace JPP { using namespace JSYSTEM; }
 
namespace JSYSTEM {
 
 
  namespace {
 
    using JLANG::JSystemException;
 
 
    /**
     * Auxiliary class to compare endianess of network and system.
     */
    class JCompareEndian {
    public:
      /**
       * Default constructor.
       */
      JCompareEndian() :
        endian(ntohs(0x1234) == 0x1234) 
      {}
 
 
      /**
       * Function object operator.
       *
       * \return              true if network and system endianess same; else false
       */
      bool operator()() const 
      { 
        return endian; 
      }
 
 
    private:
      const bool endian;
    };
  }
 
 
  /**
   * Function object operator.
   *
   * \return              true if network and system endianess same; else false
   */
  static const JCompareEndian compareEndian;
 
 
  /**
   * Get host name.
   *
   * Note that to obtain a host name including the domain name, 
   * JSYSTEM::getHostname(JSYSTEM::getIPnumber()) should be used.
   *
   * \return              host name
   */
  inline std::string getHostname()
  {
    const size_t MAXIMUM_LENGTH = 256;
    char  buffer[MAXIMUM_LENGTH];
 
    if (gethostname(buffer, MAXIMUM_LENGTH) == 0)
      return std::string(buffer);
    else
      throw JSystemException("Unknown host name.");
  }
 
 
 
  /**
   * Get host name.
   *
   * \param  ip           IP number
   * \return              host name
   */
  inline std::string getHostname(const int ip)
  {
    in_addr buffer;
 
    buffer.s_addr = ip;
 
    hostent* p = gethostbyaddr(&buffer, sizeof(in_addr), AF_INET);
 
    if (p != NULL)
      return std::string(p->h_name);
    else
      throw JSystemException("Unknown IP address.");
  }
 
 
  /**
   * Get IP number.
   *
   * \param  host_name    host name
   * \return              IP number
   */
  inline int getIPnumber(const std::string& host_name)
  {
    int ip = -1;
 
    std::string buffer = host_name;
 
    if (buffer == "" || buffer == "localhost") {
      buffer = getHostname();
    }
 
    const hostent* hp = gethostbyname(buffer.c_str());
 
    if (hp != NULL) {
      memcpy((char *) &ip, hp->h_addr, sizeof(int));
    }
 
    return ip;
  }
 
 
  /**
   * Get IP number.
   *
   * \return              IP number
   */
  inline int getIPnumber()
  {
    return getIPnumber(getHostname());
  }
 
 
  /**
   * Get IP address (decimal-dot notation).
   *
   * \param  ip           IP number
   * \return              IP address
   */
  inline std::string getIPaddress(const int ip)
  {
    std::ostringstream os;
 
    if (compareEndian())
      os << ((ip >> 24) & 0xFF) << '.'
         << ((ip >> 16) & 0xFF) << '.'
         << ((ip >>  8) & 0xFF) << '.'
         << ((ip >>  0) & 0xFF);
    else
      os << ((ip >>  0) & 0xFF) << '.'
         << ((ip >>  8) & 0xFF) << '.'
         << ((ip >> 16) & 0xFF) << '.'
         << ((ip >> 24) & 0xFF);
  
    return os.str();
  }
 
 
  /**
   * Get IP address (decimal-dot notation).
   *
   * \return              IP address
   */
  inline std::string getIPaddress()
  {
    return getIPaddress(getIPnumber());
  }
 
 
  /**
   * Get host identifier within network.
   *
   * \param  ip           IP number
   * \return              ID
   */
  inline unsigned short getSubaddress(const int ip)
  {
    if (compareEndian())
      return (unsigned short) (ip & 0x0000FFFF);
    else
      return (unsigned short) (((ip & 0xFF000000) >> 24) |
                               ((ip & 0x00FF0000) >>  8) );
  }
 
 
  /**
   * Get host identifier within network.
   *
   * \return              ID
   */
  inline unsigned short getSubaddress()
  {
    return getSubaddress(getIPnumber());
  }
 
 
  /**
   * Get list of IP address (decimal-dot notation).
   *
   * \return              IP address
   */
  inline std::vector<std::string> getListOfIPaddresses()
  {
    using namespace std;
    
    const size_t MAXIMUM_LENGTH = 256;
    char  buffer[MAXIMUM_LENGTH];
 
    vector<string> result;
    
    struct ifaddrs *p = NULL;
 
    if (getifaddrs(&p) == 0) {
 
      for ( ; p != NULL; p = p->ifa_next) {
 
        if (p->ifa_addr->sa_family == AF_INET  ||
            p->ifa_addr->sa_family == AF_INET6) {
 
          if (getnameinfo( p->ifa_addr,
                          (p->ifa_addr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6),
                          buffer, MAXIMUM_LENGTH,
                          NULL, 0, NI_NUMERICHOST) == 0) {
 
            result.push_back(buffer);
          }
        }
      }
    }
 
    freeifaddrs(p);
 
    return result;
  }
}
 
#endif