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.17 and 1.36

version 1.17, 2003/08/15 14:10:29

version 1.36, 2006/01/27 19:21:20

Line 1

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

//%2005////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

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

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

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

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

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

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

Line 28

Line 34

// Ramnath Ravindran (Ramnath.Ravindran@compaq.com) 03/21/2002

// replaced instances of "| ios::binary" with

// PEGASUS_OR_IOS_BINARY

// Robert Kieninger, IBM (kieningr@de.ibm.com) for Bug#667

// Dave Sudlik, IBM (dsudlik@us.ibm.com) for Bug#1462

// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)

// David Dillard, Symantec Corp. (david_dillard@symantec.com)

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

Line 40

Line 50

#include <cctype> // for tolower()

#include <cstring>

#include "System.h"

#include "Socket.h"

#ifdef PEGASUS_OS_TYPE_WINDOWS

# include <windows.h>

#else

# include <arpa/inet.h>

#endif

#include <Pegasus/Common/PegasusVersion.h>

Line 49

Line 66

# include "SystemUnix.cpp"

#elif defined(PEGASUS_OS_TYPE_NSK)

# include "SystemNsk.cpp"

#elif defined(PEGASUS_OS_VMS)

# include "SystemVms.cpp"

#else

# error "Unsupported platform"

#endif

Line 61

Line 80

PEGASUS_NAMESPACE_BEGIN

Boolean System::bindVerbose = false;

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

{

#if defined(PEGASUS_OS_OS400)

AtoE((char *)fromPath);

AtoE((char *)toPath);

#endif

ifstream is(fromPath PEGASUS_IOS_BINARY);

ofstream os(toPath PEGASUS_IOS_BINARY);

#if defined(PEGASUS_OS_OS400)

EtoA((char *)fromPath);

EtoA((char *)toPath);

#endif

char c;

while (is.get(c))

Line 87

Line 98

return true;

}

// ATTN: Move to platform-specific System implementation files and call

static const Uint8 _toLowerTable[256] =

// strcasecmp where it is available.

Sint32 System::strcasecmp(const char* s1, const char* s2)

{

while (*s1 && *s2)

0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,

0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,

0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,

0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,

0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,

0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,

0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,

0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,

0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,

0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,

0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,

0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F,

0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,

0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,

0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,

0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,

0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,

0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,

0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,

0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,

0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,

0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,

0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,

0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,

0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,

0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,

};

Sint32 System::strcasecmp(const char* s1, const char* s2)

{

int r = tolower(*s1++) - tolower(*s2++);

// Note: this is faster than glibc strcasecmp().

if (r)

Uint8* p = (Uint8*)s1;

return r;

Uint8* q = (Uint8*)s2;

}

int r;

for (;;)

{

if ((r = _toLowerTable[p[0]] - _toLowerTable[q[0]]) || !p[0] ||

(r = _toLowerTable[p[1]] - _toLowerTable[q[1]]) || !p[1] ||

(r = _toLowerTable[p[2]] - _toLowerTable[q[2]]) || !p[2] ||

(r = _toLowerTable[p[3]] - _toLowerTable[q[3]]) || !p[3])

break;

if (*s2)

p += 4;

return -1;

q += 4;

else if (*s1)

}

return 1;

return 0;

return r;

}

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

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

{

char *p;

char buff[2048];

if (fullpath == NULL)

{

basename[0] = '\0';

return basename;

}

strcpy(buff, fullpath);

for(p = buff + strlen(buff); p >= buff; p--)

for (const char* p = fullpath + strlen(fullpath) - 1; p >= fullpath; p--)

{

if (*p == '\\' || *p == '/')

{

Line 126

Line 174

return basename;

}

strcpy(basename, fullpath);

return basename;

}

Line 154

Line 203

return dirname;

}

String System::getHostIP(const String &hostName)

{

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_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)

char * gottenIPAdress = NULL;

gottenIPAdress = ::inet_ntoa( inaddr );

if (gottenIPAdress != NULL)

{

EtoA(gottenIPAdress);

ipAddress.assign(gottenIPAdress);

}

#else

ipAddress = ::inet_ntoa( inaddr );

#endif

}

return ipAddress;

}

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

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

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

Uint32 System::_acquireIP(const char* hostname)

{

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, relaxed

// this requirement to alphabetic character *or* digit. So bug 1462 changed the

// flow here to call inet_addr first to check for a valid IP address in dotted

// decimal notation. If it's not a valid IP address, then try to validate

// it as a hostname.

// RFC 1123 states: The host SHOULD check the string syntactically for a

// dotted-decimal number before looking it up in the Domain Name System.

// 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).

// A better solution would be to use inet_aton() or equivalent, as

// inet_addr() is now considered "obsolete".

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

{

#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_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;

}

unsigned char ip_part1,ip_part2,ip_part3,ip_part4;

ip_part1 = hostEntry->h_addr[0];

ip_part2 = hostEntry->h_addr[1];

ip_part3 = hostEntry->h_addr[2];

ip_part4 = hostEntry->h_addr[3];

ip = ip_part1;

ip = (ip << 8) + ip_part2;

ip = (ip << 8) + ip_part3;

ip = (ip << 8) + ip_part4;

}

else // else hostname *is* a dotted-decimal IP address

{

// resolve hostaddr to a real host entry

// casting to (const char *) as (char *) will work as (void *) too, those it fits all platforms

#ifndef PEGASUS_OS_OS400

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

#else

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

#endif

if (hostEntry == 0)

{

// error, couldn't resolve the ip

return 0xFFFFFFFF;

} else

{

unsigned char ip_part1,ip_part2,ip_part3,ip_part4;

ip_part1 = hostEntry->h_addr[0];

ip_part2 = hostEntry->h_addr[1];

ip_part3 = hostEntry->h_addr[2];

ip_part4 = hostEntry->h_addr[3];

ip = ip_part1;

ip = (ip << 8) + ip_part2;

ip = (ip << 8) + ip_part3;

ip = (ip << 8) + ip_part4;

}

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;

}

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

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

Legend:

Removed from v.1.17
changed lines
	Added in v.1.36

No CVS admin address has been configured