(file) Return to System.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/System.cpp between version 1.69 and 1.80

version 1.69, 2008/09/02 14:11:21 version 1.80, 2012/07/03 15:23:11
Line 1 
Line 1 
 //%2006////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // 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
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // 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
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  
 // 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> #include <Pegasus/Common/Config.h>
 #endif  
  
 #include <fstream> #include <fstream>
 #include <cctype>  // for tolower() #include <cctype>  // for tolower()
Line 48 
Line 44 
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
 # include "SystemWindows.cpp" # include "SystemWindows.cpp"
 #elif defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)  #elif defined(PEGASUS_OS_TYPE_UNIX)
 # include "SystemPOSIX.cpp" # include "SystemPOSIX.cpp"
   # include "SystemUnix.cpp"
   #elif defined(PEGASUS_OS_VMS)
   # include "SystemPOSIX.cpp"
   # include "SystemVms.cpp"
 #else #else
 # error "Unsupported platform" # error "Unsupported platform"
 #endif #endif
Line 60 
Line 60 
  
 Boolean System::bindVerbose = false; 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) Boolean System::copyFile(const char* fromPath, const char* toPath)
 { {
     ifstream is(fromPath PEGASUS_IOS_BINARY);     ifstream is(fromPath PEGASUS_IOS_BINARY);
Line 136 
Line 144 
     return r;     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;
       register int len = s1_l;
      // 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 // Return the just the file name from the path into basename
 char *System::extract_file_name(const char *fullpath, char *basename) char *System::extract_file_name(const char *fullpath, char *basename)
 { {
Line 185 
Line 251 
  
 String System::getHostName() String System::getHostName()
 { {
     static String _hostname;  
     static MutexType _mutex = PEGASUS_MUTEX_INITIALIZER;  
   
     // Use double-checked locking pattern to avoid overhead of     // Use double-checked locking pattern to avoid overhead of
     // mutex on subsequent calls.     // mutex on subsequent calls.
  
     if (0 == _hostname.size())     if (0 == _hostname.size())
     {     {
         mutex_lock(&_mutex);          AutoMutex lock(_mutexForGetHostName);
  
         if (0 == _hostname.size())         if (0 == _hostname.size())
         {         {
Line 204 
Line 267 
             hostname[sizeof(hostname)-1] = 0;             hostname[sizeof(hostname)-1] = 0;
             _hostname.assign(hostname);             _hostname.assign(hostname);
         }         }
   
         mutex_unlock(&_mutex);  
     }     }
  
     return _hostname;     return _hostname;
Line 276 
Line 337 
  
 String System::getFullyQualifiedHostName() String System::getFullyQualifiedHostName()
 { {
     static String _hostname;  
     static MutexType _mutex = PEGASUS_MUTEX_INITIALIZER;  
   
     // Use double-checked locking pattern to avoid overhead of     // Use double-checked locking pattern to avoid overhead of
     // mutex on subsequent calls.     // mutex on subsequent calls.
  
     if (0 == _hostname.size())      if (0 == _fullyQualifiedHostname.size())
     {     {
         mutex_lock(&_mutex);          AutoMutex lock(_mutexForGetFQHN);
  
         if (0 == _hostname.size())          if (0 == _fullyQualifiedHostname.size())
         {         {
             try              _fullyQualifiedHostname = _getFullyQualifiedHostName();
             {  
                 _hostname = _getFullyQualifiedHostName();  
             }             }
             catch (...)  
             {  
                 mutex_unlock(&_mutex);  
                 throw;  
             }             }
   
       return _fullyQualifiedHostname;
         }         }
  
         mutex_unlock(&_mutex);  void System::setHostName(const String & hostName)
   {
       AutoMutex lock(_mutexForGetHostName);
       _hostname.assign(hostName);
     }     }
  
     return _hostname;  void System::setFullyQualifiedHostName(const String & fullHostName)
   {
       AutoMutex lock(_mutexForGetFQHN);
       _fullyQualifiedHostname.assign(fullHostName);
 } }
  
   
 Boolean System::getHostIP(const String &hostName, int *af, String &hostIP) 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 #ifdef PEGASUS_ENABLE_IPV6
     struct addrinfo *info, hints;     struct addrinfo *info, hints;
     memset (&hints, 0, sizeof(struct addrinfo));     memset (&hints, 0, sizeof(struct addrinfo));
Line 316 
Line 396 
     hints.ai_family = *af;     hints.ai_family = *af;
     hints.ai_protocol = IPPROTO_TCP;     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_socktype = SOCK_STREAM;     hints.ai_socktype = SOCK_STREAM;
     if (!getAddrInfo(hostName.getCString(), 0, &hints, &info))      if (!getAddrInfo(hostNamePtr, 0, &hints, &info))
     {     {
         char ipAddress[PEGASUS_INET_ADDRSTR_LEN];         char ipAddress[PEGASUS_INET_ADDRSTR_LEN];
         HostAddress::convertBinaryToText(info->ai_family,         HostAddress::convertBinaryToText(info->ai_family,
Line 333 
Line 413 
     hints.ai_family = *af;     hints.ai_family = *af;
     hints.ai_protocol = IPPROTO_TCP;     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_socktype = SOCK_STREAM;     hints.ai_socktype = SOCK_STREAM;
     if (!getAddrInfo(hostName.getCString(), 0, &hints, &info))      if (!getAddrInfo(hostNamePtr, 0, &hints, &info))
     {     {
         char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];         char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];
         HostAddress::convertBinaryToText(info->ai_family,         HostAddress::convertBinaryToText(info->ai_family,
Line 351 
Line 431 
     struct hostent* hostEntry;     struct hostent* hostEntry;
     struct in_addr inaddr;     struct in_addr inaddr;
     String ipAddress;     String ipAddress;
     CString hostNameCString = hostName.getCString();  
     const char* hostNamePtr = hostNameCString;  
  
     char hostEntryBuffer[8192];     char hostEntryBuffer[8192];
     struct hostent hostEntryStruct;     struct hostent hostEntryStruct;
Line 588 
Line 666 
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
     struct in6_addr ip6 = PEGASUS_IPV6_LOOPBACK_INIT;     struct in6_addr ip6 = PEGASUS_IPV6_LOOPBACK_INIT;
 #endif #endif
     Uint32 ip4 = PEGASUS_IPV4_LOOPBACK_INIT;  
     switch (af)     switch (af)
     {     {
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
Line 600 
Line 677 
             Uint32 tmp;             Uint32 tmp;
             memcpy(&tmp, binIPAddress, sizeof(Uint32));             memcpy(&tmp, binIPAddress, sizeof(Uint32));
             Uint32 n = ntohl(tmp);             Uint32 n = ntohl(tmp);
             return !memcmp(&ip4, &n, sizeof (ip4));              return n >= PEGASUS_IPV4_LOOPBACK_RANGE_START &&
                   n <= PEGASUS_IPV4_LOOPBACK_RANGE_END;
         }         }
     }     }
  
Line 609 
Line 687 
  
 Boolean System::isLocalHost(const String &hostName) 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. // Get all ip addresses on the node and compare them with the given hostname.
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
     CString csName = hostName.getCString();     CString csName = hostName.getCString();
Line 749 
Line 837 
  
     if (!hostNameIsIPNotation)  // if hostname is not an IP address     if (!hostNameIsIPNotation)  // if hostname is not an IP address
     {     {
         // localhost ?  
         if (String::equalNoCase(hostName,String("localhost"))) return true;  
         char localHostName[PEGASUS_MAXHOSTNAMELEN];         char localHostName[PEGASUS_MAXHOSTNAMELEN];
         CString cstringLocalHostName = System::getHostName().getCString();         CString cstringLocalHostName = System::getHostName().getCString();
         strcpy(localHostName, (const char*) cstringLocalHostName);         strcpy(localHostName, (const char*) cstringLocalHostName);
Line 947 
Line 1033 
 #endif #endif
  
 // System ID constants for Logger::put and Logger::trace // 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 const String System::CIMLISTENER = "cimlistener"; // Listener systme ID
   #endif
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.69  
changed lines
  Added in v.1.80
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2