(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.47.4.4 and 1.51

version 1.47.4.4, 2008/01/09 05:55:51 version 1.51, 2007/06/05 09:41:53
Line 43 
Line 43 
 #include "Network.h" #include "Network.h"
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/HostAddress.h>  
 #include <Pegasus/Common/Array.h>  
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
 # include "SystemWindows.cpp" # include "SystemWindows.cpp"
Line 54 
Line 52 
 # error "Unsupported platform" # error "Unsupported platform"
 #endif #endif
  
 #if defined(PEGASUS_OS_OS400)  
 # include "EBCDIC_OS400.h"  
 #endif  
   
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 187 
Line 181 
     return dirname;     return dirname;
 } }
  
 Boolean System::getHostIP(const String &hostName, int *af, String &hostIP)  String System::getHostIP(const String &hostName)
 { {
 #ifdef PEGASUS_ENABLE_IPV6  
     struct addrinfo *info, hints;  
     memset (&hints, 0, sizeof(struct addrinfo));  
   
     // Check for valid IPV4 address, if found return ipv4 address  
     *af = AF_INET;  
     hints.ai_family = *af;  
     hints.ai_protocol = IPPROTO_TCP;  
     hints.ai_socktype = SOCK_STREAM;  
     if (!getaddrinfo(hostName.getCString(), 0, &hints, &info))  
     {  
         char ipAddress[PEGASUS_INET_ADDRSTR_LEN];  
         HostAddress::convertBinaryToText(info->ai_family,  
             &((struct sockaddr_in*)(info->ai_addr))->sin_addr, ipAddress,  
             PEGASUS_INET_ADDRSTR_LEN);  
         hostIP = ipAddress;  
         freeaddrinfo(info);  
         return true;  
     }  
   
     // Check for valid IPV6 Address.  
     *af = AF_INET6;  
     hints.ai_family = *af;  
     hints.ai_protocol = IPPROTO_TCP;  
     hints.ai_socktype = SOCK_STREAM;  
     if (!getaddrinfo(hostName.getCString(), 0, &hints, &info))  
     {  
         char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];  
         HostAddress::convertBinaryToText(info->ai_family,  
             &((struct sockaddr_in6*)(info->ai_addr))->sin6_addr, ipAddress,  
             PEGASUS_INET6_ADDRSTR_LEN);  
         hostIP = ipAddress;  
         freeaddrinfo(info);  
         return true;  
     }  
   
     return false;  
 #else  
     *af = AF_INET;  
     struct hostent* hostEntry;     struct hostent* hostEntry;
     struct in_addr inaddr;     struct in_addr inaddr;
     String ipAddress;     String ipAddress;
Line 257 
Line 212 
         hostEntryBuffer,         hostEntryBuffer,
         sizeof(hostEntryBuffer),         sizeof(hostEntryBuffer),
         &hostEntryErrno);         &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 #else
     hostEntry = gethostbyname(hostNamePtr);     hostEntry = gethostbyname(hostNamePtr);
 #endif #endif
Line 272 
Line 219 
     if (hostEntry)     if (hostEntry)
     {     {
         ::memcpy( &inaddr, hostEntry->h_addr,4);         ::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 );         ipAddress = ::inet_ntoa( inaddr );
 #endif  
     }  
     hostIP = ipAddress;  
     return true;  
 #endif  
 }  
   
   
 #ifdef PEGASUS_ENABLE_IPV6  
 Boolean System::isIPv6StackActive()  
 {  
     SocketHandle ip6Socket;  
     if ((ip6Socket = Socket::createSocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP))  
         == PEGASUS_INVALID_SOCKET)  
     {  
         if (getSocketError() == PEGASUS_INVALID_ADDRESS_FAMILY)  
         {  
             return false;  
         }  
     }     }
     else      return ipAddress;
     {  
         Socket::close(ip6Socket);  
     }  
   
     return true;  
 } }
 #endif  
  
 // ------------------------------------------------------------------------ // ------------------------------------------------------------------------
 // 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)  Uint32 System::_acquireIP(const char* hostname)
 {  
 #ifdef PEGASUS_ENABLE_IPV6  
     String ipAddress;  
     if(getHostIP(hostname, af, ipAddress))  
 { {
         HostAddress::convertTextToBinary(*af, ipAddress.getCString(), dst);  
         return true;  
     }  
     return false;  
 #else  
     *af = AF_INET;  
     Uint32 ip = 0xFFFFFFFF;     Uint32 ip = 0xFFFFFFFF;
     if (!hostname) return 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 // 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, // to indicate hostname instead of IP address. But RFC 1123, section 2.1,
Line 351 
Line 244 
 // Hence the call to inet_addr() first. // 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);     Uint32 tmp_addr = inet_addr((char *) hostname);
 #endif  
  
     struct hostent* hostEntry;     struct hostent* hostEntry;
  
Line 388 
Line 277 
             hostEntryBuffer,             hostEntryBuffer,
             sizeof(hostEntryBuffer),             sizeof(hostEntryBuffer),
             &hostEntryErrno);             &hostEntryErrno);
 #elif defined(PEGASUS_OS_OS400)  
         hostEntry = gethostbyname(ebcdicHost);  
 #elif defined(PEGASUS_OS_ZOS) #elif defined(PEGASUS_OS_ZOS)
         char hostName[PEGASUS_MAXHOSTNAMELEN + 1];         char hostName[PEGASUS_MAXHOSTNAMELEN + 1];
         if (String::equalNoCase("localhost",String(hostname)))         if (String::equalNoCase("localhost",String(hostname)))
Line 407 
Line 294 
 #endif #endif
         if (!hostEntry)         if (!hostEntry)
         {         {
             // error, couldn't resolve the ip              return 0xFFFFFFFF;
             memcpy(dst, &ip, sizeof (Uint32));  
             return false;  
         }         }
         unsigned char ip_part1,ip_part2,ip_part3,ip_part4;         unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
  
Line 454 
Line 339 
             hostEntryBuffer,             hostEntryBuffer,
             sizeof(hostEntryBuffer),             sizeof(hostEntryBuffer),
             &hostEntryErrno);             &hostEntryErrno);
 #elif defined(PEGASUS_OS_OS400)  
         hostEntry =  
             gethostbyaddr((char *) &tmp_addr, sizeof(tmp_addr), AF_INET);  
 #else #else
         hostEntry =         hostEntry =
             gethostbyaddr((const char *) &tmp_addr, sizeof(tmp_addr), AF_INET);             gethostbyaddr((const char *) &tmp_addr, sizeof(tmp_addr), AF_INET);
Line 464 
Line 346 
         if (hostEntry == 0)         if (hostEntry == 0)
         {         {
             // error, couldn't resolve the ip             // error, couldn't resolve the ip
             memcpy(dst, &ip, sizeof (Uint32));              return 0xFFFFFFFF;
             return false;  
         }         }
         else         else
         {         {
Line 481 
Line 362 
             ip = (ip << 8) + ip_part4;             ip = (ip << 8) + ip_part4;
         }         }
     }     }
     memcpy(dst, &ip, sizeof (Uint32));  
       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;     return true;
 #endif  
 } }
  
 Boolean System::resolveHostNameAtDNS( Boolean System::resolveHostNameAtDNS(
Line 546 
Line 485 
 { {
     struct hostent *entry;     struct hostent *entry;
  
 #ifndef PEGASUS_OS_OS400  
     entry = gethostbyaddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);     entry = gethostbyaddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);
 #else  
     entry = gethostbyaddr((char *) &ip_addr, sizeof(ip_addr), AF_INET);  
 #endif  
     if (entry == 0)     if (entry == 0)
     {     {
         // error, couldn't resolve the ip         // error, couldn't resolve the ip
Line 572 
Line 508 
 } }
  
  
 Boolean System::isLoopBack(int af, void *binIPAddress)  
 {  
 #ifdef PEGASUS_ENABLE_IPV6  
     struct in6_addr ip6 = PEGASUS_IPV6_LOOPBACK_INIT;  
 #endif  
     Uint32 ip4 = PEGASUS_IPV4_LOOPBACK_INIT;  
     switch (af)  
     {  
 #ifdef PEGASUS_ENABLE_IPV6  
         case AF_INET6:  
             return !memcmp(&ip6, binIPAddress, sizeof (ip6));  
 #endif  
         case AF_INET:  
             Uint32 n = ntohl( *(Uint32*)binIPAddress);  
             return !memcmp(&ip4, &n, sizeof (ip4));  
     }  
   
     return false;  
 }  
   
 Boolean System::isLocalHost(const String &hostName) Boolean System::isLocalHost(const String &hostName)
 { {
 // Get all ip addresses on the node and compare them with the given hostname.  
 #ifdef PEGASUS_ENABLE_IPV6  
     CString csName = hostName.getCString();  
     struct addrinfo hints, *res1, *res2, *res1root, *res2root;  
     char localHostName[PEGASUS_MAXHOSTNAMELEN];  
     gethostname(localHostName, PEGASUS_MAXHOSTNAMELEN);  
     Boolean isLocal = false;  
   
     memset(&hints, 0, sizeof(hints));  
     hints.ai_family = AF_INET;  
     hints.ai_socktype = SOCK_STREAM;  
     hints.ai_protocol = IPPROTO_TCP;  
     res1root = res2root = 0;  
     getaddrinfo(csName, 0, &hints, &res1root);  
     getaddrinfo(localHostName, 0, &hints, &res2root);  
   
     res1 = res1root;  
     while (res1 && !isLocal)  
     {  
         if (isLoopBack(AF_INET,  
             &((struct sockaddr_in*)res1->ai_addr)->sin_addr))  
         {  
             isLocal = true;  
             break;  
         }  
   
         res2 = res2root;  
         while (res2)  
         {  
             if (!memcmp(&((struct sockaddr_in*)res1->ai_addr)->sin_addr,  
                 &((struct sockaddr_in*)res2->ai_addr)->sin_addr,  
                 sizeof (struct in_addr)))  
             {  
                 isLocal = true;  
                 break;  
             }  
             res2 = res2->ai_next;  
         }  
         res1 = res1->ai_next;  
     }  
     freeaddrinfo(res1root);  
     freeaddrinfo(res2root);  
     if (isLocal)  
     {  
         return true;  
     }  
   
     hints.ai_family = AF_INET6;  
     res1root = res2root = 0;  
     getaddrinfo(csName, 0, &hints, &res1root);  
     getaddrinfo(localHostName, 0, &hints, &res2root);  
   
     res1 = res1root;  
     while (res1 && !isLocal)  
     {  
         if (isLoopBack(AF_INET6,  
             &((struct sockaddr_in6*)res1->ai_addr)->sin6_addr))  
         {  
             isLocal = true;  
             break;  
         }  
   
         res2 = res2root;  
         while (res2)  
         {  
             if (!memcmp(&((struct sockaddr_in6*)res1->ai_addr)->sin6_addr,  
                 &((struct sockaddr_in6*)res2->ai_addr)->sin6_addr,  
                 sizeof (struct in6_addr)))  
             {  
                 isLocal = true;  
                 break;  
             }  
             res2 = res2->ai_next;  
         }  
         res1 = res1->ai_next;  
     }  
     freeaddrinfo(res1root);  
     freeaddrinfo(res2root);  
   
     return isLocal;  
 #else  
   
     // differentiate between a dotted IP address given     // differentiate between a dotted IP address given
     // and a real hostname given     // and a real hostname given
     CString csName = hostName.getCString();     CString csName = hostName.getCString();
Line 684 
Line 518 
     Uint32 tmp_addr = 0xFFFFFFFF;     Uint32 tmp_addr = 0xFFFFFFFF;
     Boolean hostNameIsIPNotation;     Boolean hostNameIsIPNotation;
  
 #ifdef PEGASUS_OS_OS400  
     AtoE(cc_hostname);  
 #endif  
   
     // Note: Platforms already supporting the inet_aton()     // Note: Platforms already supporting the inet_aton()
     //       should define their platform here,     //       should define their platform here,
     //        as this is the superior way to work     //        as this is the superior way to work
Line 758 
Line 588 
         if (hostIP == localHostIP) return true;         if (hostIP == localHostIP) return true;
     }     }
     return false;     return false;
 #endif  
 } }
  
 // System ID constants for Logger::put and Logger::trace // System ID constants for Logger::put and Logger::trace

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