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.59 and 1.80

version 1.59, 2007/09/11 17:56:33

version 1.80, 2012/07/03 15:23:11

Line 1

//%2006////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// License.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// Permission is hereby granted, free of charge, to any person obtaining a

// of this software and associated documentation files (the "Software"), to

// copy of this software and associated documentation files (the "Software"),

// deal in the Software without restriction, including without limitation the

// to deal in the Software without restriction, including without limitation

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// sell copies of the Software, and to permit persons to whom the Software is

// and/or sell copies of the Software, and to permit persons to whom the

// furnished to do so, subject to the following conditions:

// Software is furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// The above copyright notice and this permission notice shall be included

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// in all copies or substantial portions of the Software.

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

//%/////////////////////////////////////////////////////////////////////////////

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

#include <Pegasus/Common/Config.h>

#endif

#include <fstream>

#include <cctype> // for tolower()

Line 48

Line 44

#if defined(PEGASUS_OS_TYPE_WINDOWS)

# include "SystemWindows.cpp"

#elif defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)

#elif defined(PEGASUS_OS_TYPE_UNIX)

# include "SystemPOSIX.cpp"

# include "SystemUnix.cpp"

#elif defined(PEGASUS_OS_VMS)

# include "SystemPOSIX.cpp"

# include "SystemVms.cpp"

#else

# error "Unsupported platform"

#endif

Line 60

Boolean System::bindVerbose = false;

Mutex System::_mutexForGetHostName;

Mutex System::_mutexForGetFQHN;

String System::_hostname;

String System::_fullyQualifiedHostname;

Boolean System::copyFile(const char* fromPath, const char* toPath)

{

ifstream is(fromPath PEGASUS_IOS_BINARY);

Line 136

Line 144

return r;

}

bool System::strncasecmp(

const char* s1,

size_t s1_l,

const char* s2,

size_t s2_l)

{

// Function is even faster than System::strcasecmp()

if (s1_l != s2_l)

{

return false;

}

Uint8* p = (Uint8*)s1;

Uint8* q = (Uint8*)s2;

// lets do a loop-unrolling optimized compare here

while (len >= 8)

{

if ((_toLowerTable[p[0]]-_toLowerTable[q[0]]) ||

(_toLowerTable[p[1]]-_toLowerTable[q[1]]) ||

(_toLowerTable[p[2]]-_toLowerTable[q[2]]) ||

(_toLowerTable[p[3]]-_toLowerTable[q[3]]) ||

(_toLowerTable[p[4]]-_toLowerTable[q[4]]) ||

(_toLowerTable[p[5]]-_toLowerTable[q[5]]) ||

(_toLowerTable[p[6]]-_toLowerTable[q[6]]) ||

(_toLowerTable[p[7]]-_toLowerTable[q[7]]))

{

return false;

}

len -= 8;

p += 8;

q += 8;

}

while (len >= 4)

{

if ((_toLowerTable[p[0]]-_toLowerTable[q[0]]) ||

(_toLowerTable[p[1]]-_toLowerTable[q[1]]) ||

(_toLowerTable[p[2]]-_toLowerTable[q[2]]) ||

(_toLowerTable[p[3]]-_toLowerTable[q[3]]))

{

return false;

}

len -= 4;

p += 4;

q += 4;

}

while (len--)

{

if ((_toLowerTable[p[0]]-_toLowerTable[q[0]]))

{

return false;

}

p++;

q++;

}

return true;

}

// Return the just the file name from the path into basename

char *System::extract_file_name(const char *fullpath, char *basename)

{

Line 183

Line 249

return dirname;

}

String System::getHostName()

{

// Use double-checked locking pattern to avoid overhead of

// mutex on subsequent calls.

if (0 == _hostname.size())

{

AutoMutex lock(_mutexForGetHostName);

if (0 == _hostname.size())

{

char hostname[PEGASUS_MAXHOSTNAMELEN + 1];

// If gethostname() fails, an empty or truncated value is used.

hostname[0] = 0;

gethostname(hostname, sizeof(hostname));

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

_hostname.assign(hostname);

}

return _hostname;

}

static String _getFullyQualifiedHostName()

{

char hostName[PEGASUS_MAXHOSTNAMELEN + 1];

// Get the short name of the local host.

// If gethostname() fails, an empty or truncated value is used.

hostName[0] = 0;

gethostname(hostName, sizeof(hostName));

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

#if defined(PEGASUS_OS_ZOS)|| \

defined(PEGASUS_OS_VMS)

String fqName;

struct addrinfo *resolv;

struct addrinfo hint;

struct hostent *he;

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

hint.ai_flags = AI_CANONNAME;

hint.ai_family = AF_UNSPEC; // any family

hint.ai_socktype = 0; // any socket type

hint.ai_protocol = 0; // any protocol

int success = System::getAddrInfo(hostName, NULL, &hint, &resolv);

if (success==0)

{

// assign fully qualified hostname

fqName.assign(resolv->ai_canonname);

}

else

{

if ((he = System::getHostByName(hostName)))

{

strncpy(hostName, he->h_name, sizeof(hostName) - 1);

}

// assign hostName

// if gethostbyname was successful assign that result

// else assign unqualified hostname

fqName.assign(hostName);

}

if (resolv)

{

freeaddrinfo(resolv);

}

return fqName;

#else /* !PEGASUS_OS_ZOS && !PEGASUS_OS_VMS */

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

struct hostent* hostEntry = System::getHostByName(

hostName, &hostEntryStruct, hostEntryBuffer, sizeof (hostEntryBuffer));

if (hostEntry)

{

strncpy(hostName, hostEntry->h_name, sizeof(hostName) - 1);

}

return String(hostName);

#endif

}

String System::getFullyQualifiedHostName()

{

// Use double-checked locking pattern to avoid overhead of

// mutex on subsequent calls.

if (0 == _fullyQualifiedHostname.size())

{

AutoMutex lock(_mutexForGetFQHN);

if (0 == _fullyQualifiedHostname.size())

{

_fullyQualifiedHostname = _getFullyQualifiedHostName();

}

return _fullyQualifiedHostname;

}

void System::setHostName(const String & hostName)

{

AutoMutex lock(_mutexForGetHostName);

_hostname.assign(hostName);

}

void System::setFullyQualifiedHostName(const String & fullHostName)

{

AutoMutex lock(_mutexForGetFQHN);

_fullyQualifiedHostname.assign(fullHostName);

}

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

{

CString hostNameCString = hostName.getCString();

const char* hostNamePtr;

// In case hostName equals _hostname or _fullyQualifiedHostname

// we need to use the system-supplied hostname instead for IP resolution

// _hostname or _fullyQualifiedHostname might be configured values

// which cannot be resolved by the system to an IP address

if (String::equalNoCase(hostName, _hostname) ||

String::equalNoCase(hostName, _fullyQualifiedHostname))

{

char localHostName[PEGASUS_MAXHOSTNAMELEN];

gethostname(localHostName, PEGASUS_MAXHOSTNAMELEN);

hostNamePtr= (const char*) localHostName;

}

else

{

hostNamePtr = hostNameCString;

}

#ifdef PEGASUS_ENABLE_IPV6

struct addrinfo *info, hints;

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

Line 194

Line 396

hints.ai_family = *af;

hints.ai_protocol = IPPROTO_TCP;

hints.ai_socktype = SOCK_STREAM;

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

if (!getAddrInfo(hostNamePtr, 0, &hints, &info))

{

char ipAddress[PEGASUS_INET_ADDRSTR_LEN];

HostAddress::convertBinaryToText(info->ai_family,

Line 211

Line 413

hints.ai_family = *af;

hints.ai_protocol = IPPROTO_TCP;

hints.ai_socktype = SOCK_STREAM;

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

if (!getAddrInfo(hostNamePtr, 0, &hints, &info))

{

char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];

HostAddress::convertBinaryToText(info->ai_family,

Line 229

Line 431

struct hostent* hostEntry;

struct in_addr inaddr;

String ipAddress;

CString hostNameCString = hostName.getCString();

const char* hostNamePtr = hostNameCString;

char hostEntryBuffer[8192];

struct hostent hostEntryStruct;

Line 263

Line 463

}

else

{

#if defined(PEGASUS_OS_VMS)

// vms has tcpipv6 support in the kernel so socket

// will always work so a call to "bind" is needed

// to complete this test.

struct sockaddr_storage listenAddress;

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

SocketLength addressLength;

HostAddress::convertTextToBinary(

HostAddress::AT_IPV6,

"::1",

&reinterpret_cast<struct sockaddr_in6*>(&listenAddress)->sin6_addr);

listenAddress.ss_family = AF_INET6;

reinterpret_cast<struct sockaddr_in6*>(&listenAddress)->sin6_port = 0;

addressLength = sizeof(struct sockaddr_in6);

if (::bind(

ip6Socket,

reinterpret_cast<struct sockaddr*>(&listenAddress),

addressLength) < 0)

{

Socket::close(ip6Socket);

return false;

}

#endif // PEGASUS_OS_VMS

Socket::close(ip6Socket);

}

Line 273

Line 501

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

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

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

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

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

{

#ifdef PEGASUS_ENABLE_IPV6

String ipAddress;

Line 286

Line 514

#else

*af = AF_INET;

Uint32 ip = 0xFFFFFFFF;

if (!hostname) return 0xFFFFFFFF;

if (!hostname)

{

*af = 0xFFFFFFFF;

return false;

}

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

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

Line 434

Line 666

#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

Line 442

Line 673

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

#endif

case AF_INET:

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

{

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

Uint32 tmp;

memcpy(&tmp, binIPAddress, sizeof(Uint32));

Uint32 n = ntohl(tmp);

return n >= PEGASUS_IPV4_LOOPBACK_RANGE_START &&

n <= PEGASUS_IPV4_LOOPBACK_RANGE_END;

}

return false;

Line 451

Line 687

Boolean System::isLocalHost(const String &hostName)

{

// if value of hostName is "localhost" or equals the value of _hostname or

// equals the value of _fullyQualifiedHostname we can safely assume it to

// be the local host

if (String::equalNoCase(hostName,String("localhost")) ||

String::equalNoCase(hostName, _hostname) ||

String::equalNoCase(hostName, _fullyQualifiedHostname))

{

return true;

}

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

#ifdef PEGASUS_ENABLE_IPV6

CString csName = hostName.getCString();

Line 494

Line 740

}

res1 = res1->ai_next;

}

if (res1root)

{

freeaddrinfo(res1root);

}

if (res2root)

{

freeaddrinfo(res2root);

}

if (isLocal)

{

return true;

Line 535

Line 787

}

res1 = res1->ai_next;

}

if (res1root)

{

freeaddrinfo(res1root);

}

if (res2root)

{

freeaddrinfo(res2root);

}

return isLocal;

#else

Line 555

Line 812

#if defined(PEGASUS_OS_LINUX) || \

defined(PEGASUS_OS_AIX) || \

defined(PEGASUS_OS_HPUX) || \

defined(PEGASUS_OS_PASE)

defined(PEGASUS_OS_PASE) || \

defined(PEGASUS_OS_VMS)

struct in_addr inaddr;

// if inet_aton failed(return=0),

Line 579

Line 837

if (!hostNameIsIPNotation) // if hostname is not an IP address

{

// localhost ?

if (String::equalNoCase(hostName,String("localhost"))) return true;

char localHostName[PEGASUS_MAXHOSTNAMELEN];

CString cstringLocalHostName = System::getHostName().getCString();

strcpy(localHostName, (const char*) cstringLocalHostName);

Line 719

Line 975

return hostEntry;

}

#if defined(PEGASUS_OS_ZOS) || \

defined(PEGASUS_OS_VMS) || \

defined(PEGASUS_ENABLE_IPV6)

int System::getAddrInfo(

const char *hostname,

const char *servname,

Line 728

Line 988

int rc = 0;

unsigned int maxTries = 5;

#ifdef PEGASUS_OS_PASE

CString hostNameCString;

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

{

hostNameCString = getHostName().getCString();

hostname = (const char*)hostNameCString;

}

#endif

while ((rc = getaddrinfo(hostname,

servname,

hints,

Line 761

Line 1030

return rc;

}

#endif

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

#ifdef PEGASUS_FLAVOR

const String System::CIMLISTENER = "cimlistener" PEGASUS_FLAVOR;

#else

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

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.59
changed lines
	Added in v.1.80

No CVS admin address has been configured