(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.29 and 1.39.4.1

version 1.29, 2005/06/06 14:27:55 version 1.39.4.1, 2006/07/30 19:26:30
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // 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 copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 37 
Line 39 
 //              Robert Kieninger, IBM (kieningr@de.ibm.com) for Bug#667 //              Robert Kieninger, IBM (kieningr@de.ibm.com) for Bug#667
 //              Dave Sudlik, IBM (dsudlik@us.ibm.com) for Bug#1462 //              Dave Sudlik, IBM (dsudlik@us.ibm.com) for Bug#1462
 //              Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com) //              Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
   //              David Dillard, Symantec Corp. (david_dillard@symantec.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 50 
Line 53 
 #include <cstring> #include <cstring>
 #include "System.h" #include "System.h"
 #include "Socket.h" #include "Socket.h"
   #include "Network.h"
 #ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC  
 # include <windows.h>  
 #else  
 # include <arpa/inet.h>  
 #endif  
   
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
  
 #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)
 # include "SystemUnix.cpp"  # include "SystemPOSIX.cpp"
 #elif defined(PEGASUS_OS_TYPE_NSK) #elif defined(PEGASUS_OS_TYPE_NSK)
 # include "SystemNsk.cpp" # include "SystemNsk.cpp"
 #elif defined(PEGASUS_OS_VMS) #elif defined(PEGASUS_OS_VMS)
 # include "SystemVms.cpp"  # include "SystemPOSIX.cpp"
 #else #else
 # error "Unsupported platform" # error "Unsupported platform"
 #endif #endif
  
 #if defined(PEGASUS_OS_OS400) #if defined(PEGASUS_OS_OS400)
 # include "OS400ConvertChar.h"  # include "EBCDIC_OS400.h"
 #endif #endif
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 97 
Line 94 
     return true;     return true;
 } }
  
 // ATTN: Move to platform-specific System implementation files and call  static const Uint8 _toLowerTable[256] =
 // strcasecmp where it is available.  
 Sint32 System::strcasecmp(const char* s1, const char* s2)  
 { {
     while (*s1 && *s2)      0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
       0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
       0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
       0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
       0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
       0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
       0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
       0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
       0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
       0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
       0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
       0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F,
       0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
       0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
       0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
       0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
       0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
       0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
       0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
       0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
       0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
       0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
       0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
       0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
       0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
       0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
       0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
       0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
       0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
       0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
       0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
       0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
   };
   
   Sint32 System::strcasecmp(const char* s1, const char* s2)
     {     {
         int r = tolower(*s1++) - tolower(*s2++);      // Note: this is faster than glibc strcasecmp().
  
         if (r)      Uint8* p = (Uint8*)s1;
             return r;      Uint8* q = (Uint8*)s2;
     }      int r;
   
       for (;;)
       {
           if ((r = _toLowerTable[p[0]] - _toLowerTable[q[0]]) || !p[0] ||
               (r = _toLowerTable[p[1]] - _toLowerTable[q[1]]) || !p[1] ||
               (r = _toLowerTable[p[2]] - _toLowerTable[q[2]]) || !p[2] ||
               (r = _toLowerTable[p[3]] - _toLowerTable[q[3]]) || !p[3])
               break;
  
     if (*s2)          p += 4;
         return -1;          q += 4;
     else if (*s1)      }
         return 1;  
  
     return 0;      return r;
 } }
  
 // Return the just the file name from the path into basename // Return the just the file name from the path into basename
 char *System::extract_file_name(const char *fullpath, char *basename) char *System::extract_file_name(const char *fullpath, char *basename)
 { {
   char *p;  
   char buff[2048];  
   if (fullpath == NULL)   if (fullpath == NULL)
     {     {
       basename[0] = '\0';       basename[0] = '\0';
       return basename;       return basename;
     }     }
   strcpy(buff, fullpath);  
   for(p = buff + strlen(buff); p >= buff; p--)    for (const char* p = fullpath + strlen(fullpath) - 1; p >= fullpath; p--)
     {     {
       if (*p == '\\' || *p == '/')       if (*p == '\\' || *p == '/')
         {         {
Line 136 
Line 170 
           return basename;           return basename;
         }         }
     }     }
   
   strcpy(basename, fullpath);   strcpy(basename, fullpath);
   return basename;   return basename;
 } }
Line 144 
Line 179 
 char *System::extract_file_path(const char *fullpath, char *dirname) char *System::extract_file_path(const char *fullpath, char *dirname)
 { {
   char *p;   char *p;
   char buff[2048];    char buff[4096];
   if (fullpath == NULL)   if (fullpath == NULL)
     {     {
       dirname[0] = '\0';       dirname[0] = '\0';
       return dirname;       return dirname;
     }     }
   strcpy(buff, fullpath);    strncpy(buff, fullpath, sizeof(buff)-1);
     buff[sizeof(buff)-1] =  '\0';
   for(p = buff + strlen(buff); p >= buff; p--)   for(p = buff + strlen(buff); p >= buff; p--)
     {     {
       if (*p == '\\' || *p == '/')       if (*p == '\\' || *p == '/')
Line 166 
Line 202 
  
 String System::getHostIP(const String &hostName) String System::getHostIP(const String &hostName)
 { {
     struct hostent * phostent;      struct hostent* hostEntry;
     struct in_addr   inaddr;     struct in_addr   inaddr;
     String ipAddress = String::EMPTY;      String ipAddress;
     CString csName = hostName.getCString();      CString hostNameCString = hostName.getCString();
     const char * ccName = csName;      const char* hostNamePtr = hostNameCString;
 #ifndef PEGASUS_OS_OS400  
     if ((phostent = ::gethostbyname(ccName)) != NULL)  #if defined(PEGASUS_OS_LINUX)
 #else      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];
       struct hostent hostEntryStruct;
       int hostEntryErrno;
   
       hostEntry = gethostbyname_r(
           (char *)hostNamePtr,
           &hostEntryStruct,
           hostEntryBuffer,
           sizeof(hostEntryBuffer),
           &hostEntryErrno);
   #elif defined(PEGASUS_OS_OS400)
     char ebcdicHost[PEGASUS_MAXHOSTNAMELEN];     char ebcdicHost[PEGASUS_MAXHOSTNAMELEN];
     if (strlen(ccName) < PEGASUS_MAXHOSTNAMELEN)      if (strlen(hostNamePtr) < PEGASUS_MAXHOSTNAMELEN)
         strcpy(ebcdicHost, ccName);          strcpy(ebcdicHost, hostNamePtr);
     else     else
         return ipAddress;         return ipAddress;
     AtoE(ebcdicHost);     AtoE(ebcdicHost);
     if ((phostent = ::gethostbyname(ebcdicHost)) != NULL)      hostEntry = gethostbyname(ebcdicHost);
   #else
       hostEntry = gethostbyname(hostNamePtr);
 #endif #endif
   
       if (hostEntry)
     {     {
         ::memcpy( &inaddr, phostent->h_addr,4);          ::memcpy( &inaddr, hostEntry->h_addr,4);
 #ifdef PEGASUS_PLATFORM_ZOS_ZSERIES_IBM  #if defined(PEGASUS_OS_OS400)
         char * gottenIPAdress = NULL;         char * gottenIPAdress = NULL;
         gottenIPAdress = ::inet_ntoa( inaddr );         gottenIPAdress = ::inet_ntoa( inaddr );
         __etoa(gottenIPAdress);  
         if (gottenIPAdress != NULL)         if (gottenIPAdress != NULL)
         {         {
               EtoA(gottenIPAdress);
             ipAddress.assign(gottenIPAdress);             ipAddress.assign(gottenIPAdress);
         }         }
 #else #else
Line 230 
Line 293 
  
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
         Uint32 tmp_addr = inet_addr(ebcdicHost);         Uint32 tmp_addr = inet_addr(ebcdicHost);
 #elif defined(PEGASUS_OS_ZOS)  
         Uint32 tmp_addr = inet_addr_ebcdic((char *)hostname);  
 #else #else
         Uint32 tmp_addr = inet_addr((char *) hostname);         Uint32 tmp_addr = inet_addr((char *) hostname);
 #endif #endif
  
         struct hostent *entry;      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).
 //       A better solution would be to use inet_aton() or equivalent, as //       A better solution would be to use inet_aton() or equivalent, as
Line 244 
Line 305 
  
     if (tmp_addr == 0xFFFFFFFF)  // if hostname is not an IP address     if (tmp_addr == 0xFFFFFFFF)  // if hostname is not an IP address
         {         {
 #ifdef PEGASUS_PLATFORM_SOLARIS_SPARC_CC  #if defined(PEGASUS_OS_LINUX)
 #define HOSTENT_BUFF_SIZE        8192          char hostEntryBuffer[8192];
                 char      buf[HOSTENT_BUFF_SIZE];          struct hostent hostEntryStruct;
                 int       h_errorp;          int hostEntryErrno;
                 struct    hostent hp;  
           gethostbyname_r(
                 entry = gethostbyname_r((char *)hostname, &hp, buf,              hostname,
                                                                 HOSTENT_BUFF_SIZE, &h_errorp);              &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_OS400) #elif defined(PEGASUS_OS_OS400)
                 entry = gethostbyname(ebcdicHost);          hostEntry = gethostbyname(ebcdicHost);
 #elif defined(PEGASUS_OS_ZOS) #elif defined(PEGASUS_OS_ZOS)
                 char hostName[ PEGASUS_MAXHOSTNAMELEN ];          char hostName[PEGASUS_MAXHOSTNAMELEN + 1];
                 if (String::equalNoCase("localhost",String(hostname)))                 if (String::equalNoCase("localhost",String(hostname)))
                 {                 {
                         gethostname( hostName, PEGASUS_MAXHOSTNAMELEN );                         gethostname( hostName, PEGASUS_MAXHOSTNAMELEN );
                         entry = gethostbyname(hostName);              hostName[sizeof(hostName)-1] = 0;
               hostEntry = gethostbyname(hostName);
                 } else                 } else
                 {                 {
                         entry = gethostbyname((char *)hostname);              hostEntry = gethostbyname((char *)hostname);
                 }                 }
 #else #else
                 entry = gethostbyname((char *)hostname);          hostEntry = gethostbyname((char *)hostname);
 #endif #endif
                 if (!entry)          if (!hostEntry)
                 {                 {
                         return 0xFFFFFFFF;                         return 0xFFFFFFFF;
                 }                 }
                 unsigned char ip_part1,ip_part2,ip_part3,ip_part4;                 unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
  
                 ip_part1 = entry->h_addr[0];                  ip_part1 = hostEntry->h_addr[0];
                 ip_part2 = entry->h_addr[1];                  ip_part2 = hostEntry->h_addr[1];
                 ip_part3 = entry->h_addr[2];                  ip_part3 = hostEntry->h_addr[2];
                 ip_part4 = entry->h_addr[3];                  ip_part4 = hostEntry->h_addr[3];
                 ip = ip_part1;                 ip = ip_part1;
                 ip = (ip << 8) + ip_part2;                 ip = (ip << 8) + ip_part2;
                 ip = (ip << 8) + ip_part3;                 ip = (ip << 8) + ip_part3;
Line 287 
Line 364 
                 // 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, those it fits all platforms                 // casting to (const char *) as (char *) will work as (void *) too, those it fits all platforms
 #ifndef PEGASUS_OS_OS400 #ifndef PEGASUS_OS_OS400
         entry = gethostbyaddr((const char *) &tmp_addr, sizeof(tmp_addr), AF_INET);          hostEntry = gethostbyaddr((const char *) &tmp_addr, sizeof(tmp_addr), AF_INET);
 #else #else
                 entry = gethostbyaddr((char *) &tmp_addr, sizeof(tmp_addr), AF_INET);                  hostEntry = gethostbyaddr((char *) &tmp_addr, sizeof(tmp_addr), AF_INET);
 #endif #endif
                 if (entry == 0)                  if (hostEntry == 0)
                 {                 {
                         // error, couldn't resolve the ip                         // error, couldn't resolve the ip
                         return 0xFFFFFFFF;                         return 0xFFFFFFFF;
Line 300 
Line 377 
  
                         unsigned char ip_part1,ip_part2,ip_part3,ip_part4;                         unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
  
                         ip_part1 = entry->h_addr[0];                          ip_part1 = hostEntry->h_addr[0];
                         ip_part2 = entry->h_addr[1];                          ip_part2 = hostEntry->h_addr[1];
                         ip_part3 = entry->h_addr[2];                          ip_part3 = hostEntry->h_addr[2];
                         ip_part4 = entry->h_addr[3];                          ip_part4 = hostEntry->h_addr[3];
                         ip = ip_part1;                         ip = ip_part1;
                         ip = (ip << 8) + ip_part2;                         ip = (ip << 8) + ip_part2;
                         ip = (ip << 8) + ip_part3;                         ip = (ip << 8) + ip_part3;

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