(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.2 and 1.54

version 1.47.4.2, 2007/07/03 21:50:04 version 1.54, 2007/07/17 18:39:30
Line 54 
Line 54 
 # 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 202 
Line 198 
     {     {
         char ipAddress[PEGASUS_INET_ADDRSTR_LEN];         char ipAddress[PEGASUS_INET_ADDRSTR_LEN];
         HostAddress::convertBinaryToText(info->ai_family,         HostAddress::convertBinaryToText(info->ai_family,
             &((struct sockaddr_in*)(info->ai_addr))->sin_addr, ipAddress,              &(reinterpret_cast<struct sockaddr_in*>(info->ai_addr))->sin_addr,
               ipAddress,
             PEGASUS_INET_ADDRSTR_LEN);             PEGASUS_INET_ADDRSTR_LEN);
         hostIP = ipAddress;         hostIP = ipAddress;
         freeaddrinfo(info);         freeaddrinfo(info);
Line 218 
Line 215 
     {     {
         char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];         char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];
         HostAddress::convertBinaryToText(info->ai_family,         HostAddress::convertBinaryToText(info->ai_family,
             &((struct sockaddr_in6*)(info->ai_addr))->sin6_addr, ipAddress,              &(reinterpret_cast<struct sockaddr_in6*>(info->ai_addr))->sin6_addr,
               ipAddress,
             PEGASUS_INET6_ADDRSTR_LEN);             PEGASUS_INET6_ADDRSTR_LEN);
         hostIP = ipAddress;         hostIP = ipAddress;
         freeaddrinfo(info);         freeaddrinfo(info);
Line 257 
Line 255 
         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 262 
     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;     hostIP = ipAddress;
     return true;     return true;
Line 308 
Line 287 
     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 329 
Line 299 
 // 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 366 
Line 332 
             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 432 
Line 396 
             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 524 
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 575 
Line 533 
 // 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();
     struct addrinfo hints, *res1, *res2;      struct addrinfo hints, *res1, *res2, *res1root, *res2root;
     char localHostName[PEGASUS_MAXHOSTNAMELEN];     char localHostName[PEGASUS_MAXHOSTNAMELEN];
     gethostname(localHostName, PEGASUS_MAXHOSTNAMELEN);     gethostname(localHostName, PEGASUS_MAXHOSTNAMELEN);
     Boolean isLocal = false;     Boolean isLocal = false;
Line 584 
Line 542 
     hints.ai_family = AF_INET;     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_STREAM;     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;     hints.ai_protocol = IPPROTO_TCP;
     res1 = res2 = 0;      res1root = res2root = 0;
     getaddrinfo(csName, 0, &hints, &res1);      getaddrinfo(csName, 0, &hints, &res1root);
     getaddrinfo(localHostName, 0, &hints, &res2);      getaddrinfo(localHostName, 0, &hints, &res2root);
  
       res1 = res1root;
     while (res1 && !isLocal)     while (res1 && !isLocal)
     {     {
         if (isLoopBack(AF_INET,         if (isLoopBack(AF_INET,
             &((struct sockaddr_in*)res1->ai_addr)->sin_addr))              &(reinterpret_cast<struct sockaddr_in*>(res1->ai_addr))->sin_addr))
         {         {
             isLocal = true;             isLocal = true;
             break;             break;
         }         }
  
         struct addrinfo *tmp = res2;          res2 = res2root;
         while (tmp)          while (res2)
         {         {
             if (!memcmp(&((struct sockaddr_in*)res1->ai_addr)->sin_addr,              if (!memcmp(
                 &((struct sockaddr_in*)res2->ai_addr)->sin_addr,                      &(reinterpret_cast<struct sockaddr_in*>(res1->ai_addr))->
                           sin_addr,
                       &(reinterpret_cast<struct sockaddr_in*>(res2->ai_addr))->
                           sin_addr,
                 sizeof (struct in_addr)))                 sizeof (struct in_addr)))
             {             {
                 isLocal = true;                 isLocal = true;
                 break;                 break;
             }             }
             tmp = tmp->ai_next;              res2 = res2->ai_next;
         }         }
         res1 = res1->ai_next;         res1 = res1->ai_next;
     }     }
     freeaddrinfo(res1);      freeaddrinfo(res1root);
     freeaddrinfo(res2);      freeaddrinfo(res2root);
     if (isLocal)     if (isLocal)
     {     {
         return true;         return true;
     }     }
  
     hints.ai_family = AF_INET6;     hints.ai_family = AF_INET6;
     res1 = res2 = 0;      res1root = res2root = 0;
     getaddrinfo(csName, 0, &hints, &res1);      getaddrinfo(csName, 0, &hints, &res1root);
     getaddrinfo(localHostName, 0, &hints, &res2);      getaddrinfo(localHostName, 0, &hints, &res2root);
   
       res1 = res1root;
     while (res1 && !isLocal)     while (res1 && !isLocal)
     {     {
         if (isLoopBack(AF_INET6,          if (isLoopBack(
             &((struct sockaddr_in6*)res1->ai_addr)->sin6_addr))                  AF_INET6,
                   &(reinterpret_cast<struct sockaddr_in6*>(res1->ai_addr))->
                       sin6_addr))
         {         {
             isLocal = true;             isLocal = true;
             break;             break;
         }         }
  
         struct addrinfo *tmp = res2;          res2 = res2root;
         while (tmp)          while (res2)
         {         {
             if (!memcmp(&((struct sockaddr_in6*)res1->ai_addr)->sin6_addr,              if (!memcmp(
                 &((struct sockaddr_in6*)res2->ai_addr)->sin6_addr,                      &(reinterpret_cast<struct sockaddr_in6*>(res1->ai_addr))->
                           sin6_addr,
                       &(reinterpret_cast<struct sockaddr_in6*>(res2->ai_addr))->
                           sin6_addr,
                 sizeof (struct in6_addr)))                 sizeof (struct in6_addr)))
             {             {
                 isLocal = true;                 isLocal = true;
                 break;                 break;
             }             }
             tmp = tmp->ai_next;              res2 = res2->ai_next;
         }         }
         res1 = res1->ai_next;         res1 = res1->ai_next;
     }     }
     freeaddrinfo(res1);      freeaddrinfo(res1root);
     freeaddrinfo(res2);      freeaddrinfo(res2root);
  
     return isLocal;     return isLocal;
 #else #else
Line 659 
Line 628 
     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
 #if defined(PEGASUS_OS_LINUX) || defined(PEGASUS_OS_AIX)  #if defined(PEGASUS_OS_LINUX) || \
       defined(PEGASUS_OS_AIX) || \
       defined(PEGASUS_OS_HPUX)
  
     struct in_addr inaddr;     struct in_addr inaddr;
     // if inet_aton failed(return=0),     // if inet_aton failed(return=0),

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