(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.56 and 1.61

version 1.56, 2007/08/13 11:23:18 version 1.61, 2007/09/12 22:28:53
Line 194 
Line 194 
     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 211 
Line 211 
     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 232 
Line 232 
     CString hostNameCString = hostName.getCString();     CString hostNameCString = hostName.getCString();
     const char* hostNamePtr = hostNameCString;     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];     char hostEntryBuffer[8192];
     struct hostent hostEntryStruct;     struct hostent hostEntryStruct;
     int hostEntryErrno;      hostEntry = getHostByName(hostNamePtr, &hostEntryStruct,
           hostEntryBuffer, sizeof (hostEntryBuffer));
     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 322 
Line 301 
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
     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 331 
Line 309 
  
     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 391 
Line 336 
         // 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];  
         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];         char hostEntryBuffer[8192];
         struct hostent hostEntryStruct;         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 452 
Line 372 
     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 507 
Line 406 
 { {
     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 565 
Line 464 
     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 604 
Line 503 
  
     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 656 
Line 555 
 #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 726 
Line 626 
 #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;
   
       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.56  
changed lines
  Added in v.1.61
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2