(file) Return to CIMObjectPath.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMObjectPath.cpp between version 1.32 and 1.55

version 1.32, 2003/11/11 22:22:41 version 1.55, 2006/05/02 20:26:58
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%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.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // 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 28 
Line 34 
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                (carolann_graves@hp.com) //                (carolann_graves@hp.com)
   //              Dave Sudlik, IBM (dsudlik@us.ibm.com)
   //              Vijay Eli, IBM (vijayeli@in.ibm.com), bug#2556.
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <cctype>  
 #include <cstring> #include <cstring>
 #include <iostream> #include <iostream>
 #include "HashTable.h" #include "HashTable.h"
 #include "CIMObjectPath.h" #include "CIMObjectPath.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "CIMName.h" #include "CIMName.h"
 #include "Destroyer.h"  
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "XmlReader.h" #include "XmlReader.h"
 #include "ArrayInternal.h" #include "ArrayInternal.h"
Line 215 
Line 221 
     case CIMTYPE_REFERENCE:     case CIMTYPE_REFERENCE:
         kbType = REFERENCE;         kbType = REFERENCE;
         break;         break;
   //  case CIMTYPE_REAL32:
   //  case CIMTYPE_REAL64:
       case CIMTYPE_OBJECT:
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       case CIMTYPE_INSTANCE:
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           // From PEP 194: EmbeddedObjects cannot be keys.
           throw TypeMismatchException();
           break;
     default:     default:
         kbType = NUMERIC;         kbType = NUMERIC;
         break;         break;
Line 298 
Line 313 
             kbValue = XmlReader::stringToValue(0, getValue().getCString(),             kbValue = XmlReader::stringToValue(0, getValue().getCString(),
                                                value.getType());                                                value.getType());
             break;             break;
   //      case CIMTYPE_REAL32:
   //      case CIMTYPE_REAL64:
           case CIMTYPE_OBJECT:
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           case CIMTYPE_INSTANCE:
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               // From PEP 194: EmbeddedObjects cannot be keys.
               return false;
               break;
         default:  // Numerics         default:  // Numerics
             if (getType() != NUMERIC) return false;             if (getType() != NUMERIC) return false;
             kbValue = XmlReader::stringToValue(0, getValue().getCString(),             kbValue = XmlReader::stringToValue(0, getValue().getCString(),
Line 315 
Line 339 
  
 Boolean operator==(const CIMKeyBinding& x, const CIMKeyBinding& y) Boolean operator==(const CIMKeyBinding& x, const CIMKeyBinding& y)
 { {
     return      // Check that the names and types match
         x.getName().equal(y.getName()) &&      if (!(x.getName().equal(y.getName())) ||
         String::equal(x.getValue(), y.getValue()) &&          !(x.getType() == y.getType()))
         x.getType() == y.getType();      {
           return false;
       }
   
       switch (x.getType())
       {
       case CIMKeyBinding::REFERENCE:
           try
           {
               // References should be compared as CIMObjectPaths
               return (CIMObjectPath(x.getValue()) == CIMObjectPath(y.getValue()));
           }
           catch (Exception&)
           {
               // If CIMObjectPath parsing fails, just compare strings
               return (String::equal(x.getValue(), y.getValue()));
           }
           break;
       case CIMKeyBinding::BOOLEAN:
           // Case-insensitive comparison is sufficient for booleans
           return (String::equalNoCase(x.getValue(), y.getValue()));
           break;
       case CIMKeyBinding::NUMERIC:
           // Note: This comparison assumes XML syntax for integers
           // First try comparing as unsigned integers
           {
               Uint64 xValue;
               Uint64 yValue;
               if (XmlReader::stringToUnsignedInteger(
                       x.getValue().getCString(), xValue) &&
                   XmlReader::stringToUnsignedInteger(
                       y.getValue().getCString(), yValue))
               {
                   return (xValue == yValue);
               }
           }
           // Next try comparing as signed integers
           {
               Sint64 xValue;
               Sint64 yValue;
               if (XmlReader::stringToSignedInteger(
                       x.getValue().getCString(), xValue) &&
                   XmlReader::stringToSignedInteger(
                       y.getValue().getCString(), yValue))
               {
                   return (xValue == yValue);
               }
           }
           // Note: Keys may not be real values, so don't try comparing as reals
           // We couldn't parse the numbers, so just compare the strings
           return (String::equal(x.getValue(), y.getValue()));
           break;
       default:  // CIMKeyBinding::STRING
           return (String::equal(x.getValue(), y.getValue()));
           break;
       }
   
       PEGASUS_UNREACHABLE(return false;)
 } }
  
  
Line 367 
Line 448 
         return *this;         return *this;
     }     }
  
       static Boolean isValidHostname(const String& hostname)
       {
           //------------------------------------------------------------------
           // Validate the hostname.  The hostname value may or may not be a
           // fully-qualified domain name (e.g., xyz.company.com) or may be an
           // IP address.  A port number may follow the hostname.
           // Hostnames must match one of the following regular expressions:
           // ^([A-Za-z0-9][A-Za-z0-9-]*)(\.[A-Za-z][A-Za-z0-9-]*)*(:[0-9]*)?$
           // ^([0-9]*\.[0-9]*\.[0-9]*\.[0-9]*)(:[0-9]*)?$
           // Note for Bug#1462. Be careful here, from RFC 1123:
           // - The syntax of a legal Internet host name was specified in
           //   RFC-952 [DNS:4]. One aspect of host name syntax is hereby
           //   changed: the restriction on the first character is relaxed to
           //   allow either a letter or a digit.
           // - If a dotted-decimal number can be entered without identifying
           //   delimiters, then a full syntactic check must be made, because
           //   a segment of a host domain name is now allowed to begin with a
           //   digit and could legally be entirely numeric (see Section 6.1.2.4).
           //   However, a valid host name can never have the dotted-decimal form
           //   #.#.#.#, since at least the highest-level component label will be
           //   alphabetic.
           // The algorithm below has been updated accordingly.
           //------------------------------------------------------------------
   
           Uint32 i = 0;
   
           Boolean isValid = false;
   
           if (isascii(hostname[0]) && isdigit(hostname[0]))
           {
               //--------------------------------------------------------------
               // Attempt to validate an IP address, but keep in mind that it
               // might be a host name, since the leading character can now be
               // a digit.
               //--------------------------------------------------------------
               isValid = true;
   
               for (Uint32 octet=1; octet<=4; octet++)
               {
                   Uint32 octetValue = 0;
   
                   //----------------------------------------------------------
                   // If a non-digit is encountered in the input parameter,
                   // then break from here and attempt to validate as host name.
                   //----------------------------------------------------------
                   if (!(isascii(hostname[i]) && isdigit(hostname[i])))
                   {
                       isValid = false;
                       break;
                   }
   
                   // skip over digits
                   while (isascii(hostname[i]) && isdigit(hostname[i]))
                   {
                       octetValue = octetValue*10 + (hostname[i] - '0');
                       i++;
                   }
   
                   if (octetValue > 255)
                   {
                       isValid = false;
                       break;
                   }
   
                   // Check for invalid character in IP address
                   if ((octet != 4) && (hostname[i++] != '.'))
                   {
                       isValid = false;
                       break;
                   }
   
                   // Check for the case where it's a valid host name that happens
                   // to have 4 (or more) leading all-numeric host segments.
                   if ((octet == 4) && (hostname[i] != ':') && hostname[i] != char(0))
                   {
                       isValid = false;
                       break;
                   }
               }
           }
           if (!isValid)   // if it is not a valid IP address
           {
               i = 0;  // reset index for host name check
   
               // Validate a host name
               isValid = true;
   
               Boolean expectHostSegment = true;
               Boolean hostSegmentIsNumeric;
   
               while (expectHostSegment == true)
               {
                   expectHostSegment = false;
                   hostSegmentIsNumeric = true; // assume all-numeric host segment
   
                   if (!(isascii(hostname[i]) &&
                         (isalnum(hostname[i]) || (hostname[i] == '_'))))
                   {
                       return false;
                   }
   
                   while (isascii(hostname[i]) &&
                          (isalnum(hostname[i]) || (hostname[i] == '-') ||
                           (hostname[i] == '_')))
                   {
                       // If a non-digit is encountered, set "all-numeric"
                       // flag to false
                       if (isalpha(hostname[i]) || (hostname[i] == '-') ||
                                                   (hostname[i] == '_')) {
                           hostSegmentIsNumeric = false;
                       }
                       i++;
                   }
   
                   if (hostname[i] == '.')
                   {
                       i++;
                       expectHostSegment = true;
                   }
               }
               // If the last Host Segment is all numeric, then return false.
               // RFC 1123 says "highest-level component label will be alphabetic".
               if (hostSegmentIsNumeric) {
                   return false;
               }
           }
   
           if (!isValid) // if not a valid IP address or host name
           {
               return false;
           }
   
           // Check for a port number:
   
           if (hostname[i] == ':')
           {
               i++;
               if (!(isascii(hostname[i]) && isdigit(hostname[i])))
               {
                   return false;
               }
               i++;
   
               while (isascii(hostname[i]) && isdigit(hostname[i]))
               {
                   i++;
               }
           }
   
           return (hostname[i] == char(0));
       }
   
     //     //
     // Contains port as well (e.g., myhost:1234).     // Contains port as well (e.g., myhost:1234).
     //     //
Line 457 
Line 690 
  
     p += 2;     p += 2;
  
     //----------------------------------------------------------------------      char* slash = strchr(p, '/');
     // Validate the hostname. A domain is allowed after the hostname.      if (!slash)
     // Eg. xyz.company.com  
     // Hostnames must match the following regular expression:  
     // ^([A-Za-z][A-Za-z0-9-]*)(\.[A-Za-z][A-Za-z0-9-]*)*$  
     //----------------------------------------------------------------------  
   
     char* q = p;  
   
     Boolean foundDot = true;  
     while (foundDot == true)  
     {     {
         foundDot = false;  
   
         if (!isalpha(*q))  
             throw MalformedObjectNameException(objectName);             throw MalformedObjectNameException(objectName);
   
         q++;  
   
         while (isalnum(*q) || *q == '-')  
         {  
             q++;  
         }         }
  
         if (*q == '.')      String hostname = String(p, (Uint32)(slash - p));
       if (!CIMObjectPathRep::isValidHostname(hostname))
         {         {
             q++;  
             foundDot = true;  
         }  
      }  
   
     // Check for a port:  
   
     if (*q == ':')  
     {  
         q++;  
         // Check for a port number:  
   
         if (!isdigit(*q))  
             throw MalformedObjectNameException(objectName);  
   
         while (isdigit(*q))  
             q++;  
     }  
   
     // Finally, assign the host name:  
   
     host.assign(p, q - p);  
   
     // Check for slash terminating the entire sequence:  
   
     if (*q != '/')  
     {  
         host.clear();  
         throw MalformedObjectNameException(objectName);         throw MalformedObjectNameException(objectName);
     }     }
       host = hostname;
  
     // Do not step past the '/'; it will be consumed by the namespace parser     // Do not step past the '/'; it will be consumed by the namespace parser
     p = q;      p = slash;
  
     return true;     return true;
 } }
Line 650 
Line 839 
                     type = CIMKeyBinding::REFERENCE;                     type = CIMKeyBinding::REFERENCE;
                 }                 }
             }             }
             catch (Exception & e)              catch (const Exception &)
             {             {
                 // Not a reference value; leave type as STRING                 // Not a reference value; leave type as STRING
             }             }
Line 740 
Line 929 
  
     // Convert to a C String first:     // Convert to a C String first:
  
     CString pCString = objectName.getCStringUTF8();      CString pCString = objectName.getCString();
     char* p = const_cast<char*>((const char*) pCString);     char* p = const_cast<char*>((const char*) pCString);
     Boolean gotHost;     Boolean gotHost;
     Boolean gotNamespace;     Boolean gotNamespace;
Line 798 
Line 987 
  
 void CIMObjectPath::setHost(const String& host) void CIMObjectPath::setHost(const String& host)
 { {
       if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host))
       {
           throw MalformedObjectNameException(host);
       }
   
     _rep->_host = host;     _rep->_host = host;
 } }
  
Line 901 
Line 1095 
 { {
     CIMObjectPath ref = *this;     CIMObjectPath ref = *this;
  
     // ATTN-RK-P2-20020510: Need to make hostname and namespace lower case?      // Normalize hostname by changing to lower case
       ref._rep->_host.toLower(); // ICU_TODO:
   
       // Normalize namespace by changing to lower case
       if (!ref._rep->_nameSpace.isNull())
       {
           String nameSpaceLower = ref._rep->_nameSpace.getString();
           nameSpaceLower.toLower(); // ICU_TODO:
           ref._rep->_nameSpace = nameSpaceLower;
       }
  
       // Normalize class name by changing to lower case
       if (!ref._rep->_className.isNull())
       {
     String classNameLower = ref._rep->_className.getString ();     String classNameLower = ref._rep->_className.getString ();
     classNameLower.toLower(); // ICU_TODO:     classNameLower.toLower(); // ICU_TODO:
     ref._rep->_className = classNameLower;     ref._rep->_className = classNameLower;
       }
  
     for (Uint32 i = 0, n = ref._rep->_keyBindings.size(); i < n; i++)     for (Uint32 i = 0, n = ref._rep->_keyBindings.size(); i < n; i++)
     {     {
           // Normalize key binding name by changing to lower case
           if (!ref._rep->_keyBindings[i]._rep->_name.isNull())
           {
         String keyBindingNameLower =         String keyBindingNameLower =
             ref._rep->_keyBindings[i]._rep->_name.getString ();             ref._rep->_keyBindings[i]._rep->_name.getString ();
         keyBindingNameLower.toLower();              keyBindingNameLower.toLower(); // ICU_TODO:
         ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;         ref._rep->_keyBindings[i]._rep->_name = keyBindingNameLower;
     }     }
  
     // ATTN-RK-20020826: Need to sort keys?          // Normalize the key value
           switch (ref._rep->_keyBindings[i]._rep->_type)
           {
           case CIMKeyBinding::REFERENCE:
               try
               {
                   // Convert reference to CIMObjectPath and recurse
                   ref._rep->_keyBindings[i]._rep->_value =
                       CIMObjectPath(ref._rep->_keyBindings[i]._rep->_value).
                           _toStringCanonical();
               }
               catch (Exception&)
               {
                   // Leave value unchanged if the CIMObjectPath parsing fails
               }
               break;
           case CIMKeyBinding::BOOLEAN:
               // Normalize the boolean string by changing to lower case
               ref._rep->_keyBindings[i]._rep->_value.toLower(); // ICU_TODO:
               break;
           case CIMKeyBinding::NUMERIC:
               // Normalize the numeric string by converting to integer and back
               Uint64 uValue;
               Sint64 sValue;
               // First try converting to unsigned integer
               if (XmlReader::stringToUnsignedInteger(
                       ref._rep->_keyBindings[i]._rep->_value.getCString(),
                           uValue))
               {
                   char buffer[32];  // Should need 21 chars max
                   sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", uValue);
                   ref._rep->_keyBindings[i]._rep->_value = String(buffer);
               }
               // Next try converting to signed integer
               else if (XmlReader::stringToSignedInteger(
                            ref._rep->_keyBindings[i]._rep->_value.getCString(),
                                sValue))
               {
                   char buffer[32];  // Should need 21 chars max
                   sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", sValue);
                   ref._rep->_keyBindings[i]._rep->_value = String(buffer);
               }
               // Leave value unchanged if it cannot be converted to an integer
               break;
           default:  // CIMKeyBinding::STRING
               // No normalization required for STRING
               break;
           }
       }
   
       // Note: key bindings are sorted when set in the CIMObjectPath
  
     return ref.toString();     return ref.toString();
 } }
Line 923 
Line 1183 
 Boolean CIMObjectPath::identical(const CIMObjectPath& x) const Boolean CIMObjectPath::identical(const CIMObjectPath& x) const
 { {
     return     return
         String::equal(_rep->_host, x._rep->_host) &&          String::equalNoCase(_rep->_host, x._rep->_host) &&
         _rep->_nameSpace.equal(x._rep->_nameSpace) &&         _rep->_nameSpace.equal(x._rep->_nameSpace) &&
         _rep->_className.equal(x._rep->_className) &&         _rep->_className.equal(x._rep->_className) &&
         _rep->_keyBindings == x._rep->_keyBindings;         _rep->_keyBindings == x._rep->_keyBindings;
Line 944 
Line 1204 
     return !operator==(x, y);     return !operator==(x, y);
 } }
  
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 PEGASUS_STD(ostream)& operator<<(  
     PEGASUS_STD(ostream)& os,  
     const CIMObjectPath& x)  
 {  
     return os << x.toString();  
 }  
 #endif  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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