(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.34 and 1.55

version 1.34, 2003/11/13 20:16:15 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 431 
Line 455 
         // fully-qualified domain name (e.g., xyz.company.com) or may be an         // fully-qualified domain name (e.g., xyz.company.com) or may be an
         // IP address.  A port number may follow the hostname.         // IP address.  A port number may follow the hostname.
         // Hostnames must match one of the following regular expressions:         // Hostnames must match one of the following regular expressions:
         // ^([A-Za-z][A-Za-z0-9-]*)(\.[A-Za-z][A-Za-z0-9-]*)*(:[0-9]*)?$          // ^([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]*)?$         // ^([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;         Uint32 i = 0;
  
         if (isdigit(hostname[0]))          Boolean isValid = false;
   
           if (isascii(hostname[0]) && isdigit(hostname[0]))
         {         {
             // Validate an IP address              //--------------------------------------------------------------
               // 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++)             for (Uint32 octet=1; octet<=4; octet++)
             {             {
                 Uint32 octetValue = 0;                 Uint32 octetValue = 0;
  
                 if (!isdigit(hostname[i]))                  //----------------------------------------------------------
                   // 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])))
                 {                 {
                     return false;                      isValid = false;
                       break;
                 }                 }
  
                 while (isdigit(hostname[i]))                  // skip over digits
                   while (isascii(hostname[i]) && isdigit(hostname[i]))
                 {                 {
                     octetValue = octetValue*10 + (hostname[i] - '0');                     octetValue = octetValue*10 + (hostname[i] - '0');
                     i++;                     i++;
Line 458 
Line 508 
  
                 if (octetValue > 255)                 if (octetValue > 255)
                 {                 {
                     return false;                      isValid = false;
                       break;
                 }                 }
  
                   // Check for invalid character in IP address
                 if ((octet != 4) && (hostname[i++] != '.'))                 if ((octet != 4) && (hostname[i++] != '.'))
                 {                 {
                     return false;                      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;
             }             }
         }         }
         else          }
           if (!isValid)   // if it is not a valid IP address
         {         {
               i = 0;  // reset index for host name check
   
             // Validate a hostname             // Validate a hostname
               isValid = true;
  
             Boolean expectHostSegment = true;             Boolean expectHostSegment = true;
               Boolean hostSegmentIsNumeric;
  
             while (expectHostSegment == true)             while (expectHostSegment == true)
             {             {
                 expectHostSegment = false;                 expectHostSegment = false;
                   hostSegmentIsNumeric = true; // assume all-numeric host segment
  
                 if (!isalpha(hostname[i++]))                  if (!(isascii(hostname[i]) &&
                         (isalnum(hostname[i]) || (hostname[i] == '_'))))
                 {                 {
                     return false;                     return false;
                 }                 }
  
                 while (isalnum(hostname[i]) || (hostname[i] == '-'))                  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++;                     i++;
                 }                 }
  
Line 493 
Line 568 
                     expectHostSegment = true;                     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:         // Check for a port number:
  
         if (hostname[i] == ':')         if (hostname[i] == ':')
         {         {
             if (!isdigit(hostname[++i]))              i++;
               if (!(isascii(hostname[i]) && isdigit(hostname[i])))
             {             {
                 return false;                 return false;
             }             }
               i++;
  
             while (isdigit(hostname[++i]));              while (isascii(hostname[i]) && isdigit(hostname[i]))
               {
                   i++;
               }
         }         }
  
         return (hostname[i] == char(0));         return (hostname[i] == char(0));
Line 749 
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 839 
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 897 
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 1109 
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.34  
changed lines
  Added in v.1.55
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2