|
version 1.21, 2002/09/20 17:17:22
|
version 1.76.4.3, 2013/06/03 22:35:12
|
|
|
|
| //%///////////////////////////////////////////////////////////////////////////// |
//%LICENSE//////////////////////////////////////////////////////////////// |
| |
// |
| |
// Licensed to The Open Group (TOG) under one or more contributor license |
| |
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with |
| |
// this work for additional information regarding copyright ownership. |
| |
// Each contributor licenses this file to you under the OpenPegasus Open |
| |
// Source License; you may not use this file except in compliance with the |
| |
// License. |
| |
// |
| |
// Permission is hereby granted, free of charge, to any person obtaining a |
| |
// copy of this software and associated documentation files (the "Software"), |
| |
// to deal in the Software without restriction, including without limitation |
| |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| |
// and/or sell copies of the Software, and to permit persons to whom the |
| |
// Software is furnished to do so, subject to the following conditions: |
| |
// |
| |
// The above copyright notice and this permission notice shall be included |
| |
// in all copies or substantial portions of the Software. |
| // | // |
| // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| // The Open Group, Tivoli Systems |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| |
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| |
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| |
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| |
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| // | // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
////////////////////////////////////////////////////////////////////////// |
| // of this software and associated documentation files (the "Software"), to |
|
| // deal in the Software without restriction, including without limitation the |
|
| // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
|
| // sell copies of the Software, and to permit persons to whom the Software is |
|
| // furnished to do so, subject to the following conditions: |
|
| // |
|
| // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
|
| // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
|
| // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
|
| // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
|
| // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
|
| // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
| // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
|
| // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
| // |
|
| //============================================================================== |
|
| // |
|
| // 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) |
|
| // | // |
| //%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| | |
| #include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
| #include <cctype> |
|
| #include <cstring> | #include <cstring> |
| |
#include <iostream> |
| #include "HashTable.h" | #include "HashTable.h" |
| #include "CIMObjectPath.h" | #include "CIMObjectPath.h" |
| #include "Indentor.h" |
|
| #include "CIMName.h" | #include "CIMName.h" |
| #include "Destroyer.h" |
#include "CIMValue.h" |
| #include "XmlWriter.h" |
|
| #include "XmlReader.h" | #include "XmlReader.h" |
| |
#include <Pegasus/Common/StringConversion.h> |
| #include "ArrayInternal.h" | #include "ArrayInternal.h" |
| #include "CIMOMPort.h" |
#include "HostLocator.h" |
| |
#include "System.h" |
| |
#include "CIMKeyBindingRep.h" |
| |
#include "CIMObjectPathRep.h" |
| | |
| PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| | |
|
|
|
| { | { |
| switch (str[i]) | switch (str[i]) |
| { | { |
| case '\n': |
case '\\': |
| result.append("\\n"); |
result.append("\\\\"); |
| break; |
|
| |
|
| case '\r': |
|
| result.append("\\r"); |
|
| break; |
|
| |
|
| case '\t': |
|
| result.append("\\t"); |
|
| break; | break; |
| | |
| case '"': | case '"': |
|
|
|
| return result; | return result; |
| } | } |
| | |
| static void _BubbleSort(Array<CIMKeyBinding>& x) |
static int _compare(const void* p1, const void* p2) |
| { | { |
| Uint32 n = x.size(); |
const CIMKeyBinding* kb1 = (const CIMKeyBinding*)p1; |
| |
const CIMKeyBinding* kb2 = (const CIMKeyBinding*)p2; |
| | |
| if (n < 2) |
return String::compareNoCase( |
| return; |
kb1->getName().getString(), |
| |
kb2->getName().getString()); |
| |
} |
| | |
| for (Uint32 i = 0; i < n - 1; i++) |
static void _Sort(Array<CIMKeyBinding>& x) |
| { | { |
| for (Uint32 j = 0; j < n - 1; j++) |
CIMKeyBinding* data = (CIMKeyBinding*)x.getData(); |
| { |
Uint32 size = x.size(); |
| if (String::compareNoCase(x[j].getName().getString(), |
|
| x[j+1].getName().getString()) > 0) |
|
| { |
|
| CIMKeyBinding t = x[j]; |
|
| x[j] = x[j+1]; |
|
| x[j+1] = t; |
|
| } |
|
| } |
|
| } |
|
| } |
|
| | |
| //////////////////////////////////////////////////////////////////////////////// |
|
| // | // |
| // CIMKeyBinding |
// If the key is a reference, the keys in the reference must also be |
| |
// sorted |
| // | // |
| //////////////////////////////////////////////////////////////////////////////// |
for (Uint32 k = 0; k < size; k++) |
| |
|
| class CIMKeyBindingRep |
|
| { |
|
| public: |
|
| CIMKeyBindingRep() |
|
| { | { |
| } |
CIMKeyBinding& kb = data[k]; |
| | |
| CIMKeyBindingRep(const CIMKeyBindingRep& x) |
if (kb.getType() == CIMKeyBinding::REFERENCE) |
| : _name(x._name), _value(x._value), _type(x._type) |
|
| { | { |
| |
CIMObjectPath tmp(kb.getValue()); |
| |
Array<CIMKeyBinding> keyBindings = tmp.getKeyBindings(); |
| |
_Sort(keyBindings); |
| |
tmp.setKeyBindings(keyBindings); |
| |
kb.setValue(tmp.toString()); |
| } | } |
| |
|
| CIMKeyBindingRep( |
|
| const CIMName& name, |
|
| const String& value, |
|
| CIMKeyBinding::Type type) |
|
| : _name(name), _value(value), _type(type) |
|
| { |
|
| } | } |
| | |
| ~CIMKeyBindingRep() |
if (size < 2) |
| { |
return; |
| } |
|
| | |
| CIMKeyBindingRep& operator=(const CIMKeyBindingRep& x) |
qsort((void*)data, size, sizeof(CIMKeyBinding), _compare); |
| { |
|
| if (&x != this) |
|
| { |
|
| _name = x._name; |
|
| _value = x._value; |
|
| _type = x._type; |
|
| } | } |
| return *this; |
|
| } |
|
| |
|
| CIMName _name; |
|
| String _value; |
|
| CIMKeyBinding::Type _type; |
|
| }; |
|
| | |
| |
//////////////////////////////////////////////////////////////////////////////// |
| |
// |
| |
// CIMKeyBinding |
| |
// |
| |
//////////////////////////////////////////////////////////////////////////////// |
| | |
| CIMKeyBinding::CIMKeyBinding() | CIMKeyBinding::CIMKeyBinding() |
| { | { |
|
|
|
| _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); |
| } | } |
|
|
|
| case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
| kbType = REFERENCE; | kbType = REFERENCE; |
| break; | break; |
| |
// case CIMTYPE_REAL32: |
| |
// case CIMTYPE_REAL64: |
| |
case CIMTYPE_OBJECT: |
| |
case CIMTYPE_INSTANCE: |
| |
// From PEP 194: EmbeddedObjects cannot be keys. |
| |
throw TypeMismatchException(); |
| |
break; |
| default: | default: |
| kbType = NUMERIC; | kbType = NUMERIC; |
| break; | break; |
|
|
|
| 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: |
| |
case CIMTYPE_INSTANCE: |
| |
// From PEP 194: EmbeddedObjects cannot be keys. |
| |
return false; |
| 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(), |
|
|
|
| | |
| 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()) |
| //////////////////////////////////////////////////////////////////////////////// |
|
| // |
|
| // CIMObjectPath |
|
| // |
|
| //////////////////////////////////////////////////////////////////////////////// |
|
| |
|
| class CIMObjectPathRep |
|
| { | { |
| public: |
case CIMKeyBinding::REFERENCE: |
| CIMObjectPathRep() |
try |
| { | { |
| |
// References should be compared as CIMObjectPaths |
| |
return (CIMObjectPath(x.getValue()) == CIMObjectPath(y.getValue())); |
| } | } |
| |
catch (Exception&) |
| CIMObjectPathRep(const CIMObjectPathRep& x) |
|
| : _host(x._host), _nameSpace(x._nameSpace), |
|
| _className(x._className), _keyBindings(x._keyBindings) |
|
| { | { |
| |
// If CIMObjectPath parsing fails, just compare strings |
| |
return String::equal(x.getValue(), y.getValue()); |
| } | } |
| |
case CIMKeyBinding::BOOLEAN: |
| CIMObjectPathRep( |
// Case-insensitive comparison is sufficient for booleans |
| const String& host, |
return String::equalNoCase(x.getValue(), y.getValue()); |
| const CIMNamespaceName& nameSpace, |
case CIMKeyBinding::NUMERIC: |
| const CIMName& className, |
// Note: This comparison assumes XML syntax for integers |
| const Array<CIMKeyBinding>& keyBindings) |
// First try comparing as unsigned integers |
| : _host(host), _nameSpace(nameSpace), |
|
| _className(className), _keyBindings(keyBindings) |
|
| { | { |
| } |
Uint64 xValue; |
| |
Uint64 yValue; |
| ~CIMObjectPathRep() |
if (StringConversion::stringToUnsignedInteger( |
| |
x.getValue().getCString(), xValue) && |
| |
StringConversion::stringToUnsignedInteger( |
| |
y.getValue().getCString(), yValue)) |
| { | { |
| |
return (xValue == yValue); |
| } | } |
| |
} |
| CIMObjectPathRep& operator=(const CIMObjectPathRep& x) |
// Next try comparing as signed integers |
| { | { |
| if (&x != this) |
Sint64 xValue; |
| |
Sint64 yValue; |
| |
if (StringConversion::stringToSignedInteger( |
| |
x.getValue().getCString(), xValue) && |
| |
StringConversion::stringToSignedInteger( |
| |
y.getValue().getCString(), yValue)) |
| { | { |
| _host = x._host; |
return (xValue == yValue); |
| _nameSpace = x._nameSpace; |
|
| _className = x._className; |
|
| _keyBindings = x._keyBindings; |
|
| } | } |
| return *this; |
|
| } | } |
| |
// 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()); |
| |
default: // CIMKeyBinding::STRING |
| |
return String::equal(x.getValue(), y.getValue()); |
| |
} |
| |
|
| |
PEGASUS_UNREACHABLE(return false;) |
| |
} |
| |
|
| | |
| |
//////////////////////////////////////////////////////////////////////////////// |
| // | // |
| // Contains port as well (e.g., myhost:1234). |
// CIMObjectPath |
| // | // |
| String _host; |
//////////////////////////////////////////////////////////////////////////////// |
| | |
| CIMNamespaceName _nameSpace; |
template<class REP> |
| CIMName _className; |
inline void Ref(REP* rep) |
| Array<CIMKeyBinding> _keyBindings; |
{ |
| }; |
rep->_refCounter++; |
| |
} |
| | |
| |
template<class REP> |
| |
inline void Unref(REP* rep) |
| |
{ |
| |
if (rep->_refCounter.decAndTestIfZero()) |
| |
delete rep; |
| |
} |
| | |
| CIMObjectPath::CIMObjectPath() | CIMObjectPath::CIMObjectPath() |
| { | { |
|
|
|
| | |
| CIMObjectPath::CIMObjectPath(const CIMObjectPath& x) | CIMObjectPath::CIMObjectPath(const CIMObjectPath& x) |
| { | { |
| _rep = new CIMObjectPathRep(*x._rep); |
_rep = x._rep; |
| |
Ref(_rep); |
| } | } |
| | |
| CIMObjectPath::CIMObjectPath(const String& objectName) | CIMObjectPath::CIMObjectPath(const String& objectName) |
|
|
|
| CIMObjectPath tmpRef; | CIMObjectPath tmpRef; |
| tmpRef.set(objectName); | tmpRef.set(objectName); |
| | |
| _rep = new CIMObjectPathRep(*tmpRef._rep); |
_rep = tmpRef._rep; |
| |
Ref(_rep); |
| } | } |
| | |
| CIMObjectPath::CIMObjectPath( | CIMObjectPath::CIMObjectPath( |
|
|
|
| // Test the objectName out to see if we get an exception | // Test the objectName out to see if we get an exception |
| CIMObjectPath tmpRef; | CIMObjectPath tmpRef; |
| tmpRef.set(host, nameSpace, className, keyBindings); | tmpRef.set(host, nameSpace, className, keyBindings); |
| |
_rep = tmpRef._rep; |
| _rep = new CIMObjectPathRep(*tmpRef._rep); |
Ref(_rep); |
| } | } |
| | |
| CIMObjectPath::~CIMObjectPath() | CIMObjectPath::~CIMObjectPath() |
| { | { |
| delete _rep; |
Unref(_rep); |
| } | } |
| | |
| CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x) | CIMObjectPath& CIMObjectPath::operator=(const CIMObjectPath& x) |
| { | { |
| *_rep = *x._rep; |
if (x._rep != _rep) |
| |
{ |
| |
Unref(_rep); |
| |
_rep = x._rep; |
| |
Ref(_rep); |
| |
} |
| return *this; | return *this; |
| } | } |
| | |
| |
static inline CIMObjectPathRep* _copyOnWriteCIMObjectPathRep( |
| |
CIMObjectPathRep* rep) |
| |
{ |
| |
if (rep->_refCounter.get() > 1) |
| |
{ |
| |
CIMObjectPathRep* tmpRep= new CIMObjectPathRep(*rep); |
| |
Unref(rep); |
| |
return tmpRep; |
| |
} |
| |
else |
| |
{ |
| |
return rep; |
| |
} |
| |
} |
| |
|
| void CIMObjectPath::clear() | void CIMObjectPath::clear() |
| { | { |
| |
// If there is more than one reference |
| |
// remove reference and get a new shiny empty representation |
| |
if (_rep->_refCounter.get() > 1) |
| |
{ |
| |
Unref(_rep); |
| |
_rep = new CIMObjectPathRep(); |
| |
} |
| |
else |
| |
{ |
| |
// If there is only one reference |
| |
// no need to copy the data, we own it |
| |
// just clear the fields |
| _rep->_host.clear(); | _rep->_host.clear(); |
| _rep->_nameSpace.clear(); | _rep->_nameSpace.clear(); |
| _rep->_className.clear(); | _rep->_className.clear(); |
| _rep->_keyBindings.clear(); | _rep->_keyBindings.clear(); |
| } | } |
| |
} |
| | |
| void CIMObjectPath::set( | void CIMObjectPath::set( |
| const String& host, | const String& host, |
|
|
|
| const CIMName& className, | const CIMName& className, |
| const Array<CIMKeyBinding>& keyBindings) | const Array<CIMKeyBinding>& keyBindings) |
| { | { |
| setHost(host); |
if ((host != String::EMPTY) && !CIMObjectPathRep::isValidHostname(host)) |
| setNameSpace(nameSpace); |
{ |
| setClassName(className); |
MessageLoaderParms mlParms( |
| setKeyBindings(keyBindings); |
"Common.CIMObjectPath.INVALID_HOSTNAME", |
| |
"$0, reason:\"invalid hostname\"", |
| |
host); |
| |
|
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| |
|
| |
_rep = _copyOnWriteCIMObjectPathRep(_rep); |
| |
|
| |
_rep->_host.assign(host); |
| |
_rep->_nameSpace = nameSpace; |
| |
_rep->_className = className; |
| |
_rep->_keyBindings = keyBindings; |
| |
_Sort(_rep->_keyBindings); |
| } | } |
| | |
| Boolean CIMObjectPath::_parseHostElement( |
Boolean _parseHostElement( |
| const String& objectName, | const String& objectName, |
| char*& p, | char*& p, |
| String& host) | String& host) |
| { | { |
| // See if there is a host name (true if it begins with "//"): | // See if there is a host name (true if it begins with "//"): |
| // Host is of the from <hostname>-<port> and begins with "//" |
// Host is of the form <hostname>:<port> and begins with "//" |
| // and ends with "/": | // and ends with "/": |
| | |
| if (p[0] != '/' || p[1] != '/') | if (p[0] != '/' || p[1] != '/') |
|
|
|
| | |
| p += 2; | p += 2; |
| | |
| //---------------------------------------------------------------------- |
char* slash = strchr(p, '/'); |
| // Validate the hostname. Hostnames must match the following |
if (!slash) |
| // regular expression: "[A-Za-z][A-Za-z0-9-]*" |
|
| //---------------------------------------------------------------------- |
|
| |
|
| char* q = p; |
|
| |
|
| if (!isalpha(*q)) |
|
| throw MalformedObjectNameException(objectName); |
|
| |
|
| q++; |
|
| |
|
| while (isalnum(*q) || *q == '-') |
|
| q++; |
|
| |
|
| // We now expect a port (or default the port). |
|
| |
|
| if (*q == ':') |
|
| { | { |
| q++; |
MessageLoaderParms mlParms( |
| // Check for a port number: |
"Common.CIMObjectPath.MISSING_SLASH_AFTER_HOST", |
| |
"$0, reason:\"missing slash after hostname\"", |
| if (!isdigit(*q)) |
objectName); |
| throw MalformedObjectNameException(objectName); |
throw MalformedObjectNameException(mlParms); |
| |
|
| while (isdigit(*q)) |
|
| q++; |
|
| |
|
| // Finally, assign the host name: |
|
| |
|
| host.assign(p, q - p); |
|
| } |
|
| else |
|
| { |
|
| host.assign(p, q - p); |
|
| |
|
| // Assign the default port number: |
|
| |
|
| host.append(":"); |
|
| host.append(PEGASUS_CIMOM_DEFAULT_PORT_STRING); |
|
| } | } |
| | |
| // Check for slash terminating the entire sequence: |
String hostname = String(p, (Uint32)(slash - p)); |
| |
if (!CIMObjectPathRep::isValidHostname(hostname)) |
| if (*q != '/') |
|
| { | { |
| host.clear(); |
MessageLoaderParms mlParms( |
| throw MalformedObjectNameException(objectName); |
"Common.CIMObjectPath.INVALID_HOSTNAME", |
| |
"$0, reason:\"invalid hostname\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| } | } |
| |
host = hostname; |
| | |
| p = ++q; |
// Do not step past the '/'; it will be consumed by the namespace parser |
| |
p = slash; |
| | |
| return true; | return true; |
| } | } |
| | |
| Boolean CIMObjectPath::_parseNamespaceElement( |
Boolean _parseNamespaceElement( |
| const String& objectName, | const String& objectName, |
| char*& p, | char*& p, |
| CIMNamespaceName& nameSpace) | CIMNamespaceName& nameSpace) |
|
|
|
| return false; | return false; |
| } | } |
| | |
| |
// A ':' as part of a keybinding value should not be interpreted as |
| |
// a namespace delimiter. Since keybinding pairs follow the first '.' |
| |
// in the object path string, the ':' delimiter only counts if it |
| |
// appears before the '.'. |
| |
|
| |
char* dot = strchr(p, '.'); |
| |
if (dot && (dot < colon)) |
| |
{ |
| |
return false; |
| |
} |
| |
|
| //---------------------------------------------------------------------- | //---------------------------------------------------------------------- |
| // Validate the namespace path. Namespaces must match the following | // Validate the namespace path. Namespaces must match the following |
| // regular expression: "[A-Za-z_]+(/[A-Za-z_]+)*" | // regular expression: "[A-Za-z_]+(/[A-Za-z_]+)*" |
| //---------------------------------------------------------------------- | //---------------------------------------------------------------------- |
| | |
| String namespaceName = String(p, colon - p); |
String namespaceName = String(p, (Uint32)(colon - p)); |
| if (!CIMNamespaceName::legal(namespaceName)) | if (!CIMNamespaceName::legal(namespaceName)) |
| { | { |
| throw MalformedObjectNameException(objectName); |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_NAMESPACE", |
| |
"$0, reason:\"invalid namespace name\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| } | } |
| nameSpace = namespaceName; | nameSpace = namespaceName; |
| | |
|
|
|
| } | } |
| | |
| /** | /** |
| ATTN: RK - Association classes have keys whose types are |
ATTN-RK: The DMTF specification for the string form of an |
| references. These reference values must be treated specially |
object path makes it impossible for a parser to distinguish |
| in the XML encoding, using the VALUE.REFERENCE tag structure. |
between a key values of String type and Reference type. |
| |
|
| Pegasus had been passing reference values simply as String |
Given the ambiguity, this implementation takes a guess at the |
| values. For example, EnumerateInstanceNames returned |
type of a quoted key value. If the value can be parsed into |
| KEYVALUEs of string type rather than VALUE.REFERENCEs. |
a CIMObjectPath with at least one key binding, the type is |
| |
set to REFERENCE. Otherwise, the type is set to STRING. |
| I've modified the XmlReader::getKeyBindingElement() and |
Note: This algorithm appears to be in line with what the Sun |
| XmlWriter::appendInstanceNameElement() methods to read and write |
WBEM Services implementation does. |
| the XML in the proper format. However, making that change |
|
| required that a CIMObjectPath object be able to distinguish |
To be totally correct, it would be necessary to retrieve the |
| between a key of String type and a key of reference type. |
class definition and look up the types of the key properties |
| |
to determine how to interpret the key values. This is clearly |
| I've modified the String format of CIMObjectPaths slightly to |
too inefficient for internal transformations between |
| allow efficient processing of references whose keys are also |
CIMObjectPaths and String values. |
| of reference type. The "official" form uses the same |
|
| encoding for key values of String type and of reference type, |
|
| and so it would be necessary to retrieve the class definition |
|
| and look up the types of the key properties to determine how |
|
| to treat the key values. This is clearly too inefficient for |
|
| internal transformations between CIMObjectPaths and String |
|
| values. |
|
| |
|
| The workaround is to encode a 'R' at the beginning of the |
|
| value for a key of reference type (before the opening '"'). |
|
| This allows the parser to know a priori whether the key is of |
|
| String or reference type. |
|
| |
|
| In this example: |
|
| |
|
| MyClass.Key1="StringValue",Key2=R"RefClass.KeyA="StringA",KeyB=10" |
|
| |
|
| Property Key1 of class MyClass is of String type, and so it |
|
| gets the usual encoding. Key2 is a reference property, so |
|
| the extra 'R' is inserted before its encoded value. Note |
|
| that this algorithm is recursive, such that RefClass could |
|
| include KeyC of reference type, which would also get encoded |
|
| with the 'R' notation. |
|
| |
|
| The toString() method inserts the 'R' to provide symmetry. A |
|
| new CIMKeyBinding type (REFERENCE) has been defined to denote |
|
| keys in a CIMObjectPath that are of reference type. This |
|
| CIMKeyBinding type must be used appropriately for |
|
| CIMObjectPath::toString() to behave correctly. |
|
| |
|
| A result of this change is that instances names in the |
|
| instance repository will include this extra 'R' character. |
|
| Note that for user-facing uses of the String encoding of |
|
| instance names (such as might appear in MOF for static |
|
| association instances or in the CGI client), this solution |
|
| is non-standard and therefore unacceptable. It is likely |
|
| that these points will need to process the more expensive |
|
| operation of retrieving the class definition to determine |
|
| the key property types. |
|
| */ | */ |
| void CIMObjectPath::_parseKeyBindingPairs( |
void _parseKeyBindingPairs( |
| const String& objectName, | const String& objectName, |
| char*& p, | char*& p, |
| Array<CIMKeyBinding>& keyBindings) | Array<CIMKeyBinding>& keyBindings) |
|
|
|
| char* equalsign = strchr(p, '='); | char* equalsign = strchr(p, '='); |
| if (!equalsign) | if (!equalsign) |
| { | { |
| throw MalformedObjectNameException(objectName); |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_KEYVALUEPAIR", |
| |
"$0, reason:\"invalid key-value pair, missing equal sign\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| } | } |
| | |
| *equalsign = 0; | *equalsign = 0; |
| | |
| if (!CIMName::legal(p)) | if (!CIMName::legal(p)) |
| throw MalformedObjectNameException(objectName); |
{ |
| |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_KEYNAME", |
| |
"$0, reason:\"invalid key-value pair, invalid key name:$1\"", |
| |
objectName, |
| |
p); |
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| | |
| CIMName keyName (p); | CIMName keyName (p); |
| | |
|
|
|
| p = equalsign + 1; | p = equalsign + 1; |
| CIMKeyBinding::Type type; | CIMKeyBinding::Type type; |
| | |
| if (*p == 'R') |
if (*p == '"') |
| { | { |
| p++; |
// Could be CIMKeyBinding::STRING or CIMKeyBinding::REFERENCE |
| | |
| type = CIMKeyBinding::REFERENCE; |
p++; |
| | |
| if (*p++ != '"') |
Buffer keyValueUTF8(128); |
| throw MalformedObjectNameException(objectName); |
|
| | |
| while (*p && *p != '"') | while (*p && *p != '"') |
| { | { |
| // ATTN: need to handle special characters here: |
|
| |
|
| if (*p == '\\') | if (*p == '\\') |
| *p++; |
{ |
| |
p++; |
| | |
| valueString.append(*p++); |
if ((*p != '\\') && (*p != '"')) |
| |
{ |
| |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_KEYVALUE", |
| |
"$0, reason:\"invalid key-value pair, " |
| |
"malformed value\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| } | } |
| | |
| if (*p++ != '"') |
keyValueUTF8.append(*p++); |
| throw MalformedObjectNameException(objectName); |
|
| } | } |
| else if (*p == '"') |
|
| { |
|
| p++; |
|
| | |
| |
if (*p++ != '"') |
| |
{ |
| |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_KEYVALUEPAIR_MISSINGQUOTE", |
| |
"$0, reason:\"invalid key-value pair, " |
| |
"missing quote in key value\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| |
|
| |
// Convert the UTF-8 value to a UTF-16 String |
| |
|
| |
valueString.assign( |
| |
(const char*)keyValueUTF8.getData(), |
| |
keyValueUTF8.size()); |
| |
|
| |
/* |
| |
Guess at the type of this quoted key value. If the value |
| |
can be parsed into a CIMObjectPath with at least one key |
| |
binding, the type is assumed to be a REFERENCE. Otherwise, |
| |
the type is set to STRING. (See method header for details.) |
| |
*/ |
| type = CIMKeyBinding::STRING; | type = CIMKeyBinding::STRING; |
| | |
| while (*p && *p != '"') |
/* Performance shortcut will check for |
| |
equal sign instead of doing the full |
| |
CIMObjectPath creation and exception handling |
| |
*/ |
| |
if (strchr(keyValueUTF8.getData(), '=')) |
| { | { |
| // ATTN: need to handle special characters here: |
// found an equal sign, high probability for a reference |
| |
try |
| if (*p == '\\') |
{ |
| *p++; |
CIMObjectPath testForPath(valueString); |
| |
if (testForPath.getKeyBindings().size() > 0) |
| valueString.append(*p++); |
{ |
| |
// We've found a reference value! |
| |
type = CIMKeyBinding::REFERENCE; |
| |
} |
| |
} |
| |
catch (const Exception &) |
| |
{ |
| |
// Not a reference value; leave type as STRING |
| |
} |
| } | } |
| |
|
| if (*p++ != '"') |
|
| throw MalformedObjectNameException(objectName); |
|
| } | } |
| else if (toupper(*p) == 'T' || toupper(*p) == 'F') | else if (toupper(*p) == 'T' || toupper(*p) == 'F') |
| { | { |
|
|
|
| | |
| if (!(((strncmp(p, "TRUE", n) == 0) && n == 4) || | if (!(((strncmp(p, "TRUE", n) == 0) && n == 4) || |
| ((strncmp(p, "FALSE", n) == 0) && n == 5))) | ((strncmp(p, "FALSE", n) == 0) && n == 5))) |
| throw MalformedObjectNameException(objectName); |
{ |
| |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_BOOLVALUE", |
| |
"$0, reason:\"invalid key-value pair, " |
| |
"value should be TRUE or FALSE\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| | |
| valueString.assign(p, n); | valueString.assign(p, n); |
| | |
|
|
|
| isComma = true; | isComma = true; |
| } | } |
| | |
| |
if (*p == '-') |
| |
{ |
| Sint64 x; | Sint64 x; |
| |
if (!StringConversion::stringToSignedInteger(p, x)) |
| if (!XmlReader::stringToSignedInteger(p, x)) |
{ |
| throw MalformedObjectNameException(objectName); |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_NEGATIVNUMBER_VALUE", |
| |
"$0, reason:\"invalid key-value pair, " |
| |
"invalid negative number value $1\"", |
| |
objectName, |
| |
p); |
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
Uint64 x; |
| |
if (!StringConversion::stringToUnsignedInteger(p, x)) |
| |
{ |
| |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_NEGATIVNUMBER_VALUE", |
| |
"$0, reason:\"invalid key-value pair, " |
| |
"invalid number value $1\"", |
| |
objectName, |
| |
p); |
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| |
} |
| | |
| valueString.assign(p, n); | valueString.assign(p, n); |
| | |
|
|
|
| { | { |
| if (*p++ != ',') | if (*p++ != ',') |
| { | { |
| throw MalformedObjectNameException(objectName); |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_KEYVALUEPAIR_MISSCOMMA", |
| |
"$0, reason:\"invalid key-value pair, " |
| |
"next key-value pair has to start with comma\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| } | } |
| } | } |
| } | } |
| | |
| _BubbleSort(keyBindings); |
_Sort(keyBindings); |
| } | } |
| | |
| void CIMObjectPath::set(const String& objectName) | void CIMObjectPath::set(const String& objectName) |
| { | { |
| |
// the clear automatically ensures |
| |
// we have our own copy of the representation |
| clear(); | clear(); |
| | |
| //-------------------------------------------------------------------------- | //-------------------------------------------------------------------------- |
|
|
|
| | |
| // Convert to a C String first: | // Convert to a C String first: |
| | |
| char* p = strdup(objectName.getCString()); |
CString pCString = objectName.getCString(); |
| Destroyer<char> destroyer(p); |
char* p = const_cast<char*>((const char*) pCString); |
| Boolean gotHost; | Boolean gotHost; |
| Boolean gotNamespace; | Boolean gotNamespace; |
| | |
|
|
|
| | |
| if (gotHost && !gotNamespace) | if (gotHost && !gotNamespace) |
| { | { |
| throw MalformedObjectNameException(objectName); |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.MISSING_NAMESPACE", |
| |
"$0, reason:\"host specified, missing namespace\"", |
| |
objectName); |
| |
throw MalformedObjectNameException(mlParms); |
| } | } |
| | |
| // Extract the class name: | // Extract the class name: |
|
|
|
| { | { |
| if (!CIMName::legal(p)) | if (!CIMName::legal(p)) |
| { | { |
| throw MalformedObjectNameException(objectName); |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_CLASSNAME", |
| |
"$0, reason:\"class name $1 not a legal CIM name\"", |
| |
objectName, |
| |
p); |
| |
throw MalformedObjectNameException(mlParms); |
| } | } |
| | |
| // ATTN: remove this later: a reference should only be able to hold | // ATTN: remove this later: a reference should only be able to hold |
|
|
|
| return; | return; |
| } | } |
| | |
| String className = String(p, dot - p); |
String className = String(p, (Uint32)(dot - p)); |
| if (!CIMName::legal(className)) | if (!CIMName::legal(className)) |
| { | { |
| throw MalformedObjectNameException(objectName); |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_CLASSNAME", |
| |
"$0, reason:\"class name $1 not a legal CIM name\"", |
| |
objectName, |
| |
className); |
| |
throw MalformedObjectNameException(mlParms); |
| } | } |
| _rep->_className = className; | _rep->_className = className; |
| | |
|
|
|
| | |
| CIMObjectPath& CIMObjectPath::operator=(const String& objectName) | CIMObjectPath& CIMObjectPath::operator=(const String& objectName) |
| { | { |
| |
// set will call clear, which will cause copyOnWrite if necessary |
| set(objectName); | set(objectName); |
| return *this; | return *this; |
| } | } |
|
|
|
| | |
| void CIMObjectPath::setHost(const String& host) | void CIMObjectPath::setHost(const String& host) |
| { | { |
| |
if ((host != String::EMPTY) && |
| |
(host != System::getHostName()) && |
| |
!CIMObjectPathRep::isValidHostname(host)) |
| |
{ |
| |
MessageLoaderParms mlParms( |
| |
"Common.CIMObjectPath.INVALID_HOSTNAME", |
| |
"$0, reason:\"invalid hostname\"", |
| |
host); |
| |
throw MalformedObjectNameException(mlParms); |
| |
} |
| |
_rep = _copyOnWriteCIMObjectPathRep(_rep); |
| |
|
| _rep->_host = host; | _rep->_host = host; |
| } | } |
| | |
|
|
|
| | |
| void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace) | void CIMObjectPath::setNameSpace(const CIMNamespaceName& nameSpace) |
| { | { |
| |
_rep = _copyOnWriteCIMObjectPathRep(_rep); |
| _rep->_nameSpace = nameSpace; | _rep->_nameSpace = nameSpace; |
| } | } |
| | |
|
|
|
| | |
| void CIMObjectPath::setClassName(const CIMName& className) | void CIMObjectPath::setClassName(const CIMName& className) |
| { | { |
| |
_rep = _copyOnWriteCIMObjectPathRep(_rep); |
| _rep->_className = className; | _rep->_className = className; |
| } | } |
| | |
|
|
|
| | |
| void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings) | void CIMObjectPath::setKeyBindings(const Array<CIMKeyBinding>& keyBindings) |
| { | { |
| |
_rep = _copyOnWriteCIMObjectPathRep(_rep); |
| _rep->_keyBindings = keyBindings; | _rep->_keyBindings = keyBindings; |
| _BubbleSort(_rep->_keyBindings); |
_Sort(_rep->_keyBindings); |
| } | } |
| | |
| String CIMObjectPath::toString() const | String CIMObjectPath::toString() const |
|
|
|
| // ATTN-CAKG-P2-20020726: The following condition does not correctly | // ATTN-CAKG-P2-20020726: The following condition does not correctly |
| // distinguish instanceNames from classNames in every case | // distinguish instanceNames from classNames in every case |
| // The instanceName of a singleton instance of a keyless class has no | // The instanceName of a singleton instance of a keyless class has no |
| // key bindings |
// key bindings. See BUG_3302 |
| // | // |
| if (_rep->_keyBindings.size () != 0) | if (_rep->_keyBindings.size () != 0) |
| { | { |
|
|
|
| | |
| CIMKeyBinding::Type type = keyBindings[i].getType(); | CIMKeyBinding::Type type = keyBindings[i].getType(); |
| | |
| if (type == CIMKeyBinding::REFERENCE) |
if (type == CIMKeyBinding::STRING || |
| objectName.append('R'); |
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) |
|
|
|
| | |
| String CIMObjectPath::_toStringCanonical() const | String CIMObjectPath::_toStringCanonical() const |
| { | { |
| CIMObjectPath ref = *this; |
CIMObjectPath ref; |
| |
*ref._rep = *this->_rep; |
| |
|
| |
// Normalize hostname by changing to lower case |
| |
ref._rep->_host.toLower(); // ICU_TODO: |
| | |
| // ATTN-RK-P2-20020510: Need to make hostname and namespace lower case? |
// 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(); |
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 (StringConversion::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 (StringConversion::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(); |
| } | } |
|
|
|
| Boolean CIMObjectPath::identical(const CIMObjectPath& x) const | Boolean CIMObjectPath::identical(const CIMObjectPath& x) const |
| { | { |
| return | return |
| String::equal(_rep->_host, x._rep->_host) && |
(_rep == x._rep) || |
| |
(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)); |
| } | } |
| | |
| Uint32 CIMObjectPath::makeHashCode() const | Uint32 CIMObjectPath::makeHashCode() const |
|
|
|
| return !operator==(x, y); | return !operator==(x, y); |
| } | } |
| | |
| PEGASUS_STD(ostream)& operator<<( |
|
| PEGASUS_STD(ostream)& os, |
|
| const CIMObjectPath& x) |
|
| { |
|
| return os << x.toString(); |
|
| } |
|
| |
|
| PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
Return to
CIMObjectPath.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common