(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.58.2.1 and 1.68

version 1.58.2.1, 2007/09/11 16:32:43 version 1.68, 2008/03/07 19:17:34
Line 48 
Line 48 
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
 # include "SystemWindows.cpp" # include "SystemWindows.cpp"
 #elif defined(PEGASUS_OS_TYPE_UNIX) || \  #elif defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
       defined(PEGASUS_OS_VMS) || \  
       defined(PEGASUS_OS_VXWORKS)  
 # include "SystemPOSIX.cpp" # include "SystemPOSIX.cpp"
 #else #else
 # error "Unsupported platform" # error "Unsupported platform"
Line 185 
Line 183 
     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 196 
Line 316 
     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(hostName.getCString(), 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 213 
Line 333 
     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(hostName.getCString(), 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 234 
Line 354 
     CString hostNameCString = hostName.getCString();     CString hostNameCString = hostName.getCString();
     const char* hostNamePtr = hostNameCString;     const char* hostNamePtr = hostNameCString;
  
 #if defined(PEGASUS_OS_LINUX)  
     char hostEntryBuffer[8192];     char hostEntryBuffer[8192];
     struct hostent hostEntryStruct;     struct hostent hostEntryStruct;
     int hostEntryErrno;      hostEntry = getHostByName(hostNamePtr, &hostEntryStruct,
           hostEntryBuffer, sizeof (hostEntryBuffer));
     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);  
 #else  
     hostEntry = gethostbyname(hostNamePtr);  
 #endif  
  
     if (hostEntry)     if (hostEntry)
     {     {
         ::memcpy( &inaddr, hostEntry->h_addr,4);         ::memcpy( &inaddr, hostEntry->h_addr,4);
         ipAddress = ::inet_ntoa( inaddr );         ipAddress = ::inet_ntoa( inaddr );
     }  
     hostIP = ipAddress;     hostIP = ipAddress;
     return true;     return true;
       }
       return false;
 #endif #endif
 } }
  
Line 286 
Line 385 
     }     }
     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 296 
Line 423 
 // ------------------------------------------------------------------------ // ------------------------------------------------------------------------
 // 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 309 
Line 436 
 #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 324 
Line 455 
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
     Uint32 tmp_addr = inet_addr((char *) hostname);     Uint32 tmp_addr = inet_addr((char *) hostname);
   
     struct hostent* hostEntry;     struct hostent* hostEntry;
  
 // Note: 0xFFFFFFFF is actually a valid IP address (255.255.255.255). // Note: 0xFFFFFFFF is actually a valid IP address (255.255.255.255).
Line 333 
Line 463 
  
     if (tmp_addr == 0xFFFFFFFF)  // if hostname is not an IP address     if (tmp_addr == 0xFFFFFFFF)  // if hostname is not an IP address
     {     {
 #if defined(PEGASUS_OS_LINUX)  
         char hostEntryBuffer[8192];         char hostEntryBuffer[8192];
         struct hostent hostEntryStruct;         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_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)         if (!hostEntry)
         {         {
             // error, couldn't resolve the ip             // error, couldn't resolve the ip
Line 393 
Line 490 
         // resolve hostaddr to a real host entry         // resolve hostaddr to a real host entry
         // casting to (const char *) as (char *) will work as (void *) too,         // casting to (const char *) as (char *) will work as (void *) too,
         // those it fits all platforms         // those it fits all platforms
 #if defined(PEGASUS_OS_LINUX)  
         char hostEntryBuffer[8192];         char hostEntryBuffer[8192];
         struct hostent hostEntryStruct;         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);  
 #else  
         hostEntry =         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)         if (hostEntry == 0)
         {         {
             // error, couldn't resolve the ip             // error, couldn't resolve the ip
Line 454 
Line 526 
     const char* hostname,     const char* hostname,
     Uint32* resolvedNameIP)     Uint32* resolvedNameIP)
 { {
       struct hostent* hostEntry;
   
     // ask the DNS for hostname resolution to IP address     // ask the DNS for hostname resolution to IP address
     // this can mean a time delay for as long as the DNS     // this can mean a time delay for as long as the DNS
     // takes to answer     // 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];     char hostEntryBuffer[8192];
     struct hostent hostEntryStruct;     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)     if (hostEntry == 0)
     {     {
         // error, couldn't resolve the hostname to an ip address         // error, couldn't resolve the hostname to an ip address
Line 509 
Line 560 
 { {
     struct hostent *entry;     struct hostent *entry;
  
     entry = gethostbyaddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);      entry = getHostByAddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);
  
     if (entry == 0)     if (entry == 0)
     {     {
Line 567 
Line 618 
     hints.ai_socktype = SOCK_STREAM;     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;     hints.ai_protocol = IPPROTO_TCP;
     res1root = res2root = 0;     res1root = res2root = 0;
     getaddrinfo(csName, 0, &hints, &res1root);      getAddrInfo(csName, 0, &hints, &res1root);
     getaddrinfo(localHostName, 0, &hints, &res2root);      getAddrInfo(localHostName, 0, &hints, &res2root);
  
     res1 = res1root;     res1 = res1root;
     while (res1 && !isLocal)     while (res1 && !isLocal)
Line 597 
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 606 
Line 663 
  
     hints.ai_family = AF_INET6;     hints.ai_family = AF_INET6;
     res1root = res2root = 0;     res1root = res2root = 0;
     getaddrinfo(csName, 0, &hints, &res1root);      getAddrInfo(csName, 0, &hints, &res1root);
     getaddrinfo(localHostName, 0, &hints, &res2root);      getAddrInfo(localHostName, 0, &hints, &res2root);
  
     res1 = res1root;     res1 = res1root;
     while (res1 && !isLocal)     while (res1 && !isLocal)
Line 638 
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 658 
Line 720 
 #if defined(PEGASUS_OS_LINUX) || \ #if defined(PEGASUS_OS_LINUX) || \
     defined(PEGASUS_OS_AIX) || \     defined(PEGASUS_OS_AIX) || \
     defined(PEGASUS_OS_HPUX) || \     defined(PEGASUS_OS_HPUX) || \
     defined(PEGASUS_OS_PASE)      defined(PEGASUS_OS_PASE) || \
       defined(PEGASUS_OS_VMS)
  
     struct in_addr inaddr;     struct in_addr inaddr;
     // if inet_aton failed(return=0),     // if inet_aton failed(return=0),
Line 728 
Line 791 
 #endif #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;
   
       do
       {
   #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;
   
       do
       {
   #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;
   }
   
   #if defined(PEGASUS_OS_ZOS) || \
       defined(PEGASUS_OS_VMS) || \
       defined(PEGASUS_ENABLE_IPV6)
   
   int System::getAddrInfo(
       const char *hostname,
       const char *servname,
       const struct addrinfo *hints,
       struct addrinfo **res)
   {
       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,
                        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;
   }
   
   #endif
   
 // System ID constants for Logger::put and Logger::trace // System ID constants for Logger::put and Logger::trace
 const String System::CIMLISTENER = "cimlistener"; // Listener systme ID const String System::CIMLISTENER = "cimlistener"; // Listener systme ID
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   

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