(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.61 and 1.73.2.1

version 1.61, 2007/09/12 22:28:53 version 1.73.2.1, 2009/09/25 13:45:06
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 183 
Line 179 
     return dirname;     return dirname;
 } }
  
   String System::getHostName()
   {
       static String _hostname;
       static MutexType _mutex = PEGASUS_MUTEX_INITIALIZER;
   
       // Use double-checked locking pattern to avoid overhead of
       // mutex on subsequent calls.
   
       if (0 == _hostname.size())
       {
           mutex_lock(&_mutex);
   
           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);
           }
   
           mutex_unlock(&_mutex);
       }
   
       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()
   {
       static String _hostname;
       static MutexType _mutex = PEGASUS_MUTEX_INITIALIZER;
   
       // Use double-checked locking pattern to avoid overhead of
       // mutex on subsequent calls.
   
       if (0 == _hostname.size())
       {
           mutex_lock(&_mutex);
   
           if (0 == _hostname.size())
           {
               try
               {
                   _hostname = _getFullyQualifiedHostName();
               }
               catch (...)
               {
                   mutex_unlock(&_mutex);
                   throw;
               }
           }
   
           mutex_unlock(&_mutex);
       }
   
       return _hostname;
   }
   
 Boolean System::getHostIP(const String &hostName, int *af, String &hostIP) Boolean System::getHostIP(const String &hostName, int *af, String &hostIP)
 { {
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
Line 263 
Line 381 
     }     }
     else     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);         Socket::close(ip6Socket);
     }     }
  
Line 273 
Line 419 
 // ------------------------------------------------------------------------ // ------------------------------------------------------------------------
 // Convert a hostname into a a single host unique integer representation // 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 #ifdef PEGASUS_ENABLE_IPV6
     String ipAddress;     String ipAddress;
Line 286 
Line 432 
 #else #else
     *af = AF_INET;     *af = AF_INET;
     Uint32 ip = 0xFFFFFFFF;     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 // This code used to check if the first character of "hostname" was alphabetic
Line 434 
Line 584 
 #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 442 
Line 591 
             return !memcmp(&ip6, binIPAddress, sizeof (ip6));             return !memcmp(&ip6, binIPAddress, sizeof (ip6));
 #endif #endif
         case AF_INET:         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;     return false;
Line 494 
Line 648 
         }         }
         res1 = res1->ai_next;         res1 = res1->ai_next;
     }     }
       if (res1root)
       {
     freeaddrinfo(res1root);     freeaddrinfo(res1root);
       }
       if (res2root)
       {
     freeaddrinfo(res2root);     freeaddrinfo(res2root);
       }
     if (isLocal)     if (isLocal)
     {     {
         return true;         return true;
Line 535 
Line 695 
         }         }
         res1 = res1->ai_next;         res1 = res1->ai_next;
     }     }
       if (res1root)
       {
     freeaddrinfo(res1root);     freeaddrinfo(res1root);
       }
       if (res2root)
       {
     freeaddrinfo(res2root);     freeaddrinfo(res2root);
       }
     return isLocal;     return isLocal;
 #else #else
  
Line 733 
Line 898 
     int rc = 0;     int rc = 0;
     unsigned int maxTries = 5;     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,     while ((rc = getaddrinfo(hostname,
                      servname,                      servname,
                      hints,                      hints,

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