(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.54 and 1.60.4.1

version 1.54, 2006/01/30 16:16:47 version 1.60.4.1, 2007/06/08 10:40:29
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                (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>
Line 49 
Line 41 
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "XmlReader.h" #include "XmlReader.h"
 #include "ArrayInternal.h" #include "ArrayInternal.h"
   #include "HostAddress.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 193 
Line 186 
     _rep = new CIMKeyBindingRep(*x._rep);     _rep = new CIMKeyBindingRep(*x._rep);
 } }
  
 CIMKeyBinding::CIMKeyBinding(const CIMName& name, const String& value, Type type)  CIMKeyBinding::CIMKeyBinding(
       const CIMName& name,
       const String& value,
       Type type)
 { {
     _rep = new CIMKeyBindingRep(name, value, type);     _rep = new CIMKeyBindingRep(name, value, type);
 } }
Line 224 
Line 220 
 //  case CIMTYPE_REAL32: //  case CIMTYPE_REAL32:
 //  case CIMTYPE_REAL64: //  case CIMTYPE_REAL64:
     case CIMTYPE_OBJECT:     case CIMTYPE_OBJECT:
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       case CIMTYPE_INSTANCE:
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
         // From PEP 194: EmbeddedObjects cannot be keys.         // From PEP 194: EmbeddedObjects cannot be keys.
         throw TypeMismatchException();         throw TypeMismatchException();
         break;         break;
Line 313 
Line 312 
 //      case CIMTYPE_REAL32: //      case CIMTYPE_REAL32:
 //      case CIMTYPE_REAL64: //      case CIMTYPE_REAL64:
         case CIMTYPE_OBJECT:         case CIMTYPE_OBJECT:
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           case CIMTYPE_INSTANCE:
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             // From PEP 194: EmbeddedObjects cannot be keys.             // From PEP 194: EmbeddedObjects cannot be keys.
             return false;             return false;
             break;             break;
Line 351 
Line 353 
         catch (Exception&)         catch (Exception&)
         {         {
             // If CIMObjectPath parsing fails, just compare strings             // If CIMObjectPath parsing fails, just compare strings
             return (String::equal(x.getValue(), y.getValue()));              return String::equal(x.getValue(), y.getValue());
         }         }
         break;         break;
     case CIMKeyBinding::BOOLEAN:     case CIMKeyBinding::BOOLEAN:
         // Case-insensitive comparison is sufficient for booleans         // Case-insensitive comparison is sufficient for booleans
         return (String::equalNoCase(x.getValue(), y.getValue()));          return String::equalNoCase(x.getValue(), y.getValue());
         break;         break;
     case CIMKeyBinding::NUMERIC:     case CIMKeyBinding::NUMERIC:
         // Note: This comparison assumes XML syntax for integers         // Note: This comparison assumes XML syntax for integers
Line 386 
Line 388 
         }         }
         // Note: Keys may not be real values, so don't try comparing as reals         // 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         // We couldn't parse the numbers, so just compare the strings
         return (String::equal(x.getValue(), y.getValue()));          return String::equal(x.getValue(), y.getValue());
         break;         break;
     default:  // CIMKeyBinding::STRING     default:  // CIMKeyBinding::STRING
         return (String::equal(x.getValue(), y.getValue()));          return String::equal(x.getValue(), y.getValue());
         break;         break;
     }     }
  
Line 444 
Line 446 
  
     static Boolean isValidHostname(const String& hostname)     static Boolean isValidHostname(const String& hostname)
     {     {
         //------------------------------------------------------------------          HostAddress addr(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]) &&          return addr.isValid();
                       (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));  
     }     }
  
     //     //
Line 880 
Line 737 
                 isComma = true;                 isComma = true;
             }             }
  
               if (*p == '-')
               {
             Sint64 x;             Sint64 x;
   
             if (!XmlReader::stringToSignedInteger(p, x))             if (!XmlReader::stringToSignedInteger(p, x))
                 throw MalformedObjectNameException(objectName);                 throw MalformedObjectNameException(objectName);
               }
               else
               {
                   Uint64 x;
                   if (!XmlReader::stringToUnsignedInteger(p, x))
                       throw MalformedObjectNameException(objectName);
               }
  
             valueString.assign(p, n);             valueString.assign(p, n);
  
Line 1069 
Line 934 
  
             CIMKeyBinding::Type type = keyBindings[i].getType();             CIMKeyBinding::Type type = keyBindings[i].getType();
  
             if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)              if (type == CIMKeyBinding::STRING ||
                   type == CIMKeyBinding::REFERENCE)
                 objectName.append('"');                 objectName.append('"');
  
             objectName.append(value);             objectName.append(value);
  
             if (type == CIMKeyBinding::STRING || type == CIMKeyBinding::REFERENCE)              if (type == CIMKeyBinding::STRING ||
                   type == CIMKeyBinding::REFERENCE)
                 objectName.append('"');                 objectName.append('"');
  
             if (i + 1 != n)             if (i + 1 != n)

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