pegasus/src/Pegasus/Common/System.cpp - diff

Return to System.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/System.cpp between version 1.47.4.1 and 1.60

version 1.47.4.1, 2007/02/15 16:23:30

version 1.60, 2007/09/11 19:43:00

Line 43

#include "Network.h"

#include <Pegasus/Common/PegasusVersion.h>

#include <Pegasus/Common/FileSystem.h>

#include <Pegasus/Common/HostAddress.h>

#include <Pegasus/Common/Array.h>

#if defined(PEGASUS_OS_TYPE_WINDOWS)

# include "SystemWindows.cpp"

Line 52

Line 54

# error "Unsupported platform"

#endif

#if defined(PEGASUS_OS_OS400)

# include "EBCDIC_OS400.h"

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

Line 185

Line 183

return dirname;

}

String System::getHostIP(const String &hostName)

Boolean System::getHostIP(const String &hostName, int *af, String &hostIP)

{

#ifdef PEGASUS_ENABLE_IPV6

struct addrinfo *info, hints;

memset (&hints, 0, sizeof(struct addrinfo));

// Check for valid IPV4 address, if found return ipv4 address

*af = AF_INET;

hints.ai_family = *af;

hints.ai_protocol = IPPROTO_TCP;

hints.ai_socktype = SOCK_STREAM;

if (!getAddrInfo(hostName.getCString(), 0, &hints, &info))

{

char ipAddress[PEGASUS_INET_ADDRSTR_LEN];

HostAddress::convertBinaryToText(info->ai_family,

&(reinterpret_cast<struct sockaddr_in*>(info->ai_addr))->sin_addr,

ipAddress,

PEGASUS_INET_ADDRSTR_LEN);

hostIP = ipAddress;

freeaddrinfo(info);

return true;

}

// Check for valid IPV6 Address.

*af = AF_INET6;

hints.ai_family = *af;

hints.ai_protocol = IPPROTO_TCP;

hints.ai_socktype = SOCK_STREAM;

if (!getAddrInfo(hostName.getCString(), 0, &hints, &info))

{

char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];

HostAddress::convertBinaryToText(info->ai_family,

&(reinterpret_cast<struct sockaddr_in6*>(info->ai_addr))->sin6_addr,

ipAddress,

PEGASUS_INET6_ADDRSTR_LEN);

hostIP = ipAddress;

freeaddrinfo(info);

return true;

}

return false;

#else

*af = AF_INET;

struct hostent* hostEntry;

struct in_addr inaddr;

String ipAddress;

CString hostNameCString = hostName.getCString();

const char* hostNamePtr = hostNameCString;

#if defined(PEGASUS_OS_LINUX)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

gethostbyname_r(

hostNamePtr,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntry,

&hostEntryErrno);

#elif defined(PEGASUS_OS_SOLARIS)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

hostEntry = getHostByName(hostNamePtr, &hostEntryStruct,

hostEntryBuffer, sizeof (hostEntryBuffer));

hostEntry = gethostbyname_r(

(char *)hostNamePtr,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntryErrno);

#elif defined(PEGASUS_OS_OS400)

char ebcdicHost[PEGASUS_MAXHOSTNAMELEN];

if (strlen(hostNamePtr) < PEGASUS_MAXHOSTNAMELEN)

strcpy(ebcdicHost, hostNamePtr);

else

return ipAddress;

AtoE(ebcdicHost);

hostEntry = gethostbyname(ebcdicHost);

#else

hostEntry = gethostbyname(hostNamePtr);

#endif

if (hostEntry)

{

::memcpy( &inaddr, hostEntry->h_addr,4);

#if defined(PEGASUS_OS_OS400)

ipAddress = ::inet_ntoa( inaddr );

char * gottenIPAdress = NULL;

hostIP = ipAddress;

gottenIPAdress = ::inet_ntoa( inaddr );

return true;

}

return false;

#endif

}

if (gottenIPAdress != NULL)

#ifdef PEGASUS_ENABLE_IPV6

Boolean System::isIPv6StackActive()

{

SocketHandle ip6Socket;

if ((ip6Socket = Socket::createSocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP))

== PEGASUS_INVALID_SOCKET)

{

EtoA(gottenIPAdress);

if (getSocketError() == PEGASUS_INVALID_ADDRESS_FAMILY)

ipAddress.assign(gottenIPAdress);

{

return false;

}

#else

ipAddress = ::inet_ntoa( inaddr );

#endif

}

return ipAddress;

else

{

Socket::close(ip6Socket);

}

return true;

}

#endif

// ------------------------------------------------------------------------

// Convert a hostname into a a single host unique integer representation

// ------------------------------------------------------------------------

Uint32 System::_acquireIP(const char* hostname)

Boolean System::_acquireIP(const char* hostname, int *af, void *dst)

{

#ifdef PEGASUS_ENABLE_IPV6

String ipAddress;

if(getHostIP(hostname, af, ipAddress))

{

HostAddress::convertTextToBinary(*af, ipAddress.getCString(), dst);

return true;

}

return false;

#else

*af = AF_INET;

Uint32 ip = 0xFFFFFFFF;

if (!hostname) return 0xFFFFFFFF;

#ifdef PEGASUS_OS_OS400

char ebcdicHost[PEGASUS_MAXHOSTNAMELEN];

if (strlen(hostname) < PEGASUS_MAXHOSTNAMELEN)

strcpy(ebcdicHost, hostname);

else

return 0xFFFFFFFF;

AtoE(ebcdicHost);

#endif

////////////////////////////////////////////////////////////////////////////////

// This code used to check if the first character of "hostname" was alphabetic

// to indicate hostname instead of IP address. But RFC 1123, section 2.1,

Line 276

Line 300

// Hence the call to inet_addr() first.

////////////////////////////////////////////////////////////////////////////////

#ifdef PEGASUS_OS_OS400

Uint32 tmp_addr = inet_addr(ebcdicHost);

#else

Uint32 tmp_addr = inet_addr((char *) hostname);

#endif

struct hostent* hostEntry;

// Note: 0xFFFFFFFF is actually a valid IP address (255.255.255.255).

Line 290

Line 309

if (tmp_addr == 0xFFFFFFFF) // if hostname is not an IP address

{

#if defined(PEGASUS_OS_LINUX)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

hostEntry = getHostByName(hostname, &hostEntryStruct,

hostEntryBuffer, sizeof (hostEntryBuffer));

gethostbyname_r(

hostname,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntry,

&hostEntryErrno);

#elif defined(PEGASUS_OS_SOLARIS)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

hostEntry = gethostbyname_r(

(char *)hostname,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntryErrno);

#elif defined(PEGASUS_OS_OS400)

hostEntry = gethostbyname(ebcdicHost);

#elif defined(PEGASUS_OS_ZOS)

char hostName[PEGASUS_MAXHOSTNAMELEN + 1];

if (String::equalNoCase("localhost",String(hostname)))

{

gethostname( hostName, PEGASUS_MAXHOSTNAMELEN );

hostName[sizeof(hostName)-1] = 0;

hostEntry = gethostbyname(hostName);

}

else

{

hostEntry = gethostbyname((char *)hostname);

}

#else

hostEntry = gethostbyname((char *)hostname);

#endif

if (!hostEntry)

{

return 0xFFFFFFFF;

// error, couldn't resolve the ip

memcpy(dst, &ip, sizeof (Uint32));

return false;

}

unsigned char ip_part1,ip_part2,ip_part3,ip_part4;

Line 350

Line 336

// resolve hostaddr to a real host entry

// casting to (const char *) as (char *) will work as (void *) too,

// those it fits all platforms

#if defined(PEGASUS_OS_LINUX)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

gethostbyaddr_r(

(const char*) &tmp_addr,

sizeof(tmp_addr),

AF_INET,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntry,

&hostEntryErrno);

#elif defined(PEGASUS_OS_SOLARIS)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

hostEntry = gethostbyaddr_r(

(const char *) &tmp_addr,

sizeof(tmp_addr),

AF_INET,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntryErrno);

#elif defined(PEGASUS_OS_OS400)

hostEntry =

gethostbyaddr((char *) &tmp_addr, sizeof(tmp_addr), AF_INET);

#else

hostEntry =

gethostbyaddr((const char *) &tmp_addr, sizeof(tmp_addr), AF_INET);

getHostByAddr((const char*) &tmp_addr, sizeof(tmp_addr), AF_INET,

#endif

&hostEntryStruct, hostEntryBuffer, sizeof (hostEntryBuffer));

if (hostEntry == 0)

{

// error, couldn't resolve the ip

return 0xFFFFFFFF;

memcpy(dst, &ip, sizeof (Uint32));

return false;

}

else

{

Line 403

Line 362

ip = (ip << 8) + ip_part4;

}

memcpy(dst, &ip, sizeof (Uint32));

return ip;

}

Boolean System::sameHost (const String & hostName)

{

// If a port is included, return false

if (hostName.find (":") != PEG_NOT_FOUND)

{

return false;

}

// Retrieve IP addresses for both hostnames

Uint32 hostNameIP, systemHostIP = 0xFFFFFFFF;

hostNameIP = System::_acquireIP ((const char *) hostName.getCString ());

if (hostNameIP == 0x7F000001)

{

// localhost or IP address of 127.0.0.1

// real IP address needed for compare

hostNameIP = System::_acquireIP

((const char *) System::getHostName ().getCString ());

}

if (hostNameIP == 0xFFFFFFFF)

{

// Malformed IP address or not resolveable

return false;

}

systemHostIP = System::_acquireIP

((const char *) System::getFullyQualifiedHostName ().getCString ());

if (systemHostIP == 0x7F000001)

{

// localhost or IP address of 127.0.0.1

// real IP address needed for compare

systemHostIP = System::_acquireIP

((const char *) System::getHostName ().getCString ());

}

if (systemHostIP == 0xFFFFFFFF)

{

// Malformed IP address or not resolveable

return false;

}

if (hostNameIP != systemHostIP)

{

return false;

}

return true;

#endif

}

Boolean System::resolveHostNameAtDNS(

const char* hostname,

Uint32* resolvedNameIP)

{

struct hostent* hostEntry;

// ask the DNS for hostname resolution to IP address

// this can mean a time delay for as long as the DNS

// takes to answer

struct hostent* hostEntry;

#if defined(PEGASUS_OS_LINUX)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

gethostbyname_r(

hostname,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntry,

&hostEntryErrno);

#elif defined(PEGASUS_OS_SOLARIS)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

int hostEntryErrno;

hostEntry = getHostByName(hostname, &hostEntryStruct,

hostEntryBuffer, sizeof (hostEntryBuffer));

hostEntry = gethostbyname_r(

(char *)hostname,

&hostEntryStruct,

hostEntryBuffer,

sizeof(hostEntryBuffer),

&hostEntryErrno);

#else

hostEntry = gethostbyname((char *)hostname);

#endif

if (hostEntry == 0)

{

// error, couldn't resolve the hostname to an ip address

Line 526

Line 406

{

struct hostent *entry;

#ifndef PEGASUS_OS_OS400

entry = getHostByAddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);

entry = gethostbyaddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);

#else

entry = gethostbyaddr((char *) &ip_addr, sizeof(ip_addr), AF_INET);

#endif

if (entry == 0)

{

// error, couldn't resolve the ip

Line 552

Line 429

}

Boolean System::isLoopBack(int af, void *binIPAddress)

{

#ifdef PEGASUS_ENABLE_IPV6

struct in6_addr ip6 = PEGASUS_IPV6_LOOPBACK_INIT;

#endif

Uint32 ip4 = PEGASUS_IPV4_LOOPBACK_INIT;

switch (af)

{

#ifdef PEGASUS_ENABLE_IPV6

case AF_INET6:

return !memcmp(&ip6, binIPAddress, sizeof (ip6));

#endif

case AF_INET:

Uint32 n = ntohl( *(Uint32*)binIPAddress);

return !memcmp(&ip4, &n, sizeof (ip4));

}

return false;

}

Boolean System::isLocalHost(const String &hostName)

{

// Get all ip addresses on the node and compare them with the given hostname.

#ifdef PEGASUS_ENABLE_IPV6

CString csName = hostName.getCString();

struct addrinfo hints, *res1, *res2, *res1root, *res2root;

char localHostName[PEGASUS_MAXHOSTNAMELEN];

gethostname(localHostName, PEGASUS_MAXHOSTNAMELEN);

Boolean isLocal = false;

memset(&hints, 0, sizeof(hints));

hints.ai_family = AF_INET;

hints.ai_socktype = SOCK_STREAM;

hints.ai_protocol = IPPROTO_TCP;

res1root = res2root = 0;

getAddrInfo(csName, 0, &hints, &res1root);

getAddrInfo(localHostName, 0, &hints, &res2root);

res1 = res1root;

while (res1 && !isLocal)

{

if (isLoopBack(AF_INET,

&(reinterpret_cast<struct sockaddr_in*>(res1->ai_addr))->sin_addr))

{

isLocal = true;

break;

}

res2 = res2root;

while (res2)

{

if (!memcmp(

&(reinterpret_cast<struct sockaddr_in*>(res1->ai_addr))->

sin_addr,

&(reinterpret_cast<struct sockaddr_in*>(res2->ai_addr))->

sin_addr,

sizeof (struct in_addr)))

{

isLocal = true;

break;

}

res2 = res2->ai_next;

}

res1 = res1->ai_next;

}

freeaddrinfo(res1root);

freeaddrinfo(res2root);

if (isLocal)

{

return true;

}

hints.ai_family = AF_INET6;

res1root = res2root = 0;

getAddrInfo(csName, 0, &hints, &res1root);

getAddrInfo(localHostName, 0, &hints, &res2root);

res1 = res1root;

while (res1 && !isLocal)

{

if (isLoopBack(

AF_INET6,

&(reinterpret_cast<struct sockaddr_in6*>(res1->ai_addr))->

sin6_addr))

{

isLocal = true;

break;

}

res2 = res2root;

while (res2)

{

if (!memcmp(

&(reinterpret_cast<struct sockaddr_in6*>(res1->ai_addr))->

sin6_addr,

&(reinterpret_cast<struct sockaddr_in6*>(res2->ai_addr))->

sin6_addr,

sizeof (struct in6_addr)))

{

isLocal = true;

break;

}

res2 = res2->ai_next;

}

res1 = res1->ai_next;

}

freeaddrinfo(res1root);

freeaddrinfo(res2root);

return isLocal;

#else

// differentiate between a dotted IP address given

// and a real hostname given

CString csName = hostName.getCString();

Line 562

Line 549

Uint32 tmp_addr = 0xFFFFFFFF;

Boolean hostNameIsIPNotation;

#ifdef PEGASUS_OS_OS400

AtoE(cc_hostname);

#endif

// Note: Platforms already supporting the inet_aton()

// should define their platform here,

// as this is the superior way to work

#if defined(PEGASUS_OS_LINUX) || defined(PEGASUS_OS_AIX)

#if defined(PEGASUS_OS_LINUX) || \

defined(PEGASUS_OS_AIX) || \

defined(PEGASUS_OS_HPUX) || \

defined(PEGASUS_OS_PASE) || \

defined(PEGASUS_OS_VMS)

struct in_addr inaddr;

// if inet_aton failed(return=0),

Line 636

Line 623

if (hostIP == localHostIP) return true;

}

return false;

#endif

}

struct hostent* System::getHostByName(

const char* name,

struct hostent* he,

char* buf,

size_t len)

{

int hostEntryErrno = 0;

struct hostent* hostEntry = 0;

unsigned int maxTries = 5;

{

#if defined(PEGASUS_OS_LINUX)

gethostbyname_r(name,

he,

buf,

len,

&hostEntry,

&hostEntryErrno);

#elif defined(PEGASUS_OS_SOLARIS)

hostEntry = gethostbyname_r((char *)name,

he,

buf,

len,

&hostEntryErrno);

#elif defined(PEGASUS_OS_ZOS)

char hostName[PEGASUS_MAXHOSTNAMELEN + 1];

if (String::equalNoCase("localhost", String(name)))

{

gethostname(hostName, PEGASUS_MAXHOSTNAMELEN);

hostName[sizeof(hostName) - 1] = 0;

hostEntry = gethostbyname(hostName);

}

else

{

hostEntry = gethostbyname((char *)name);

}

hostEntryErrno = h_errno;

#else

hostEntry = gethostbyname((char *)name);

hostEntryErrno = h_errno;

#endif

} while (hostEntry == 0 && hostEntryErrno == TRY_AGAIN &&

maxTries-- > 0);

return hostEntry;

}

struct hostent* System::getHostByAddr(

const char *addr,

int len,

int type,

struct hostent* he,

char* buf,

size_t buflen)

{

int hostEntryErrno = 0;

struct hostent* hostEntry = 0;

unsigned int maxTries = 5;

{

#if defined(PEGASUS_OS_LINUX)

gethostbyaddr_r(addr,

len,

type,

he,

buf,

buflen,

&hostEntry,

&hostEntryErrno);

#elif defined(PEGASUS_OS_SOLARIS)

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

hostEntry = gethostbyaddr_r(addr,

len,

type,

he,

buf,

buflen,

&hostEntryErrno);

#else

hostEntry = gethostbyaddr(addr,

len,

type);

hostEntryErrno = h_errno;

#endif

} while (hostEntry == 0 && hostEntryErrno == TRY_AGAIN &&

maxTries-- > 0);

return hostEntry;

}

int System::getAddrInfo(

const char *hostname,

const char *servname,

const struct addrinfo *hints,

struct addrinfo **res)

{

int rc = 0;

unsigned int maxTries = 5;

while ((rc = getaddrinfo(hostname,

servname,

hints,

res)) == EAI_AGAIN &&

maxTries-- > 0)

;

return rc;

}

int System::getNameInfo(

const struct sockaddr *sa,

size_t salen,

char *host,

size_t hostlen,

char *serv,

size_t servlen,

int flags)

{

int rc = 0;

unsigned int maxTries = 5;

while ((rc = getnameinfo(sa,

salen,

host,

hostlen,

serv,

servlen,

flags)) == EAI_AGAIN &&

maxTries-- > 0)

;

return rc;

}

// System ID constants for Logger::put and Logger::trace

const String System::CIMLISTENER = "cimlistener"; // Listener systme ID

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.47.4.1
changed lines
	Added in v.1.60

No CVS admin address has been configured