version 1.136, 2008/12/01 17:49:57
|
version 1.144.4.3, 2012/02/21 17:22:10
|
|
|
{ | { |
MessageLoaderParms mlParms( | MessageLoaderParms mlParms( |
"Common.XmlReader.EXPECTED_CDATA", | "Common.XmlReader.EXPECTED_CDATA", |
"Expected content of CDATA"); |
"Expected content or CDATA"); |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
|
|
XmlEntry& entry, | XmlEntry& entry, |
const char* tagName) | const char* tagName) |
{ | { |
if (!parser.next(entry) || |
if (!parser.next(entry)) |
(entry.type != XmlEntry::START_TAG && |
{ |
|
return false; |
|
} |
|
if ((entry.type != XmlEntry::START_TAG && |
entry.type != XmlEntry::EMPTY_TAG) || | entry.type != XmlEntry::EMPTY_TAG) || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
|
|
if (!entry.getAttributeValue("CLASSORIGIN", name)) | if (!entry.getAttributeValue("CLASSORIGIN", name)) |
return CIMName(); | return CIMName(); |
| |
|
/* Interoperability hack to make the C++ client of OpenPegasus able |
|
to deal with the wbemservices CIMOM delivered with Sun Solaris. |
|
The issue is that the wbemservices delivers Xml responses with |
|
CLASSORIGIN="" |
|
Originally this had been reported with Bug#537. |
|
*/ |
|
if (name.size()==0) |
|
{ |
|
return CIMName(); |
|
} |
|
|
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
|
|
{ | { |
Uint32 i; | Uint32 i; |
| |
Array<Uint8> utf8Chars; |
Buffer utf8Chars; |
| |
for (i=0; i<uriString.size(); i++) | for (i=0; i<uriString.size(); i++) |
{ | { |
|
|
} | } |
| |
Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); | Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); |
utf8Chars.append((Uint8)decodedChar); |
utf8Chars.append((char)decodedChar); |
} | } |
else | else |
{ | { |
utf8Chars.append((Uint8)uriString[i]); |
utf8Chars.append((char)uriString[i]); |
} | } |
} | } |
| |
|
|
if (uriString.size() > 0) | if (uriString.size() > 0) |
{ | { |
// Convert UTF-8 to UTF-16 and return the String | // Convert UTF-8 to UTF-16 and return the String |
utf8Chars.append('\0'); |
return String(utf8Chars.getData(), utf8Chars.size()); |
return String((char *)utf8Chars.getData()); |
|
} | } |
else | else |
{ | { |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// stringToSignedInteger |
|
// |
|
// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" ) |
|
// or |
|
// [ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::stringToSignedInteger( |
|
const char* stringValue, |
|
Sint64& x) |
|
{ |
|
return (StringConversion::stringToSint64( |
|
stringValue, StringConversion::decimalStringToUint64, x) || |
|
StringConversion::stringToSint64( |
|
stringValue, StringConversion::hexStringToUint64, x)); |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// stringToUnsignedInteger |
|
// |
|
// ( positiveDecimalDigit *decimalDigit | "0" ) |
|
// or |
|
// ( "0x" | "0X" ) 1*hexDigit |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::stringToUnsignedInteger( |
|
const char* stringValue, |
|
Uint64& x) |
|
{ |
|
return (StringConversion::decimalStringToUint64(stringValue, x) || |
|
StringConversion::hexStringToUint64(stringValue, x)); |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// stringToValue() | // stringToValue() |
// | // |
// Return: CIMValue. If the string input is zero length creates a CIMValue | // Return: CIMValue. If the string input is zero length creates a CIMValue |
|
|
const char* valueString, | const char* valueString, |
CIMType type) | CIMType type) |
{ | { |
|
return stringToValue(lineNumber, valueString, strlen(valueString), type); |
|
} |
|
|
|
CIMValue XmlReader::stringToValue( |
|
Uint32 lineNumber, |
|
const char* valueString, |
|
Uint32 valueStringLen, |
|
CIMType type) |
|
{ |
// ATTN-B: accepting only UTF-8 for now! (affects string and char16): | // ATTN-B: accepting only UTF-8 for now! (affects string and char16): |
| |
|
// Char string must have been null terminated. |
|
PEGASUS_ASSERT (!valueString[valueStringLen]); |
|
|
// Create value per type | // Create value per type |
switch (type) | switch (type) |
{ | { |
|
|
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
{ | { |
return CIMValue(String(valueString)); |
return CIMValue(String(valueString, valueStringLen)); |
} | } |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
{ | { |
// Converts UTF-8 to UTF-16 | // Converts UTF-8 to UTF-16 |
String tmp(valueString); |
String tmp(valueString, valueStringLen); |
if (tmp.size() != 1) | if (tmp.size() != 1) |
{ | { |
MessageLoaderParms mlParms( | MessageLoaderParms mlParms( |
|
|
{ | { |
Uint64 x; | Uint64 x; |
| |
if (!stringToUnsignedInteger(valueString, x)) |
if (!StringConversion::stringToUnsignedInteger(valueString, x)) |
{ | { |
MessageLoaderParms mlParms( | MessageLoaderParms mlParms( |
"Common.XmlReader.INVALID_UI_VALUE", | "Common.XmlReader.INVALID_UI_VALUE", |
|
|
{ | { |
Sint64 x; | Sint64 x; |
| |
if (!stringToSignedInteger(valueString, x)) |
if (!StringConversion::stringToSignedInteger(valueString, x)) |
{ | { |
MessageLoaderParms mlParms( | MessageLoaderParms mlParms( |
"Common.XmlReader.INVALID_SI_VALUE", | "Common.XmlReader.INVALID_SI_VALUE", |
|
|
// Bugzilla 137 Adds the following if line. | // Bugzilla 137 Adds the following if line. |
// Expect this to become permanent but test only for now | // Expect this to become permanent but test only for now |
#ifdef PEGASUS_SNIA_INTEROP_TEST | #ifdef PEGASUS_SNIA_INTEROP_TEST |
if (strlen(valueString) != 0) |
if (valueStringLen != 0) |
#endif | #endif |
tmp.set(valueString); | tmp.set(valueString); |
} | } |
|
|
// just the value of the Embedded Object in String | // just the value of the Embedded Object in String |
// representation. | // representation. |
AutoArrayPtr<char> tmp_buffer( | AutoArrayPtr<char> tmp_buffer( |
new char[strlen(valueString) + 1]); |
new char[valueStringLen + 1]); |
strcpy(tmp_buffer.get(), valueString); |
memcpy(tmp_buffer.get(), valueString, valueStringLen + 1); |
XmlParser tmp_parser(tmp_buffer.get()); | XmlParser tmp_parser(tmp_buffer.get()); |
| |
// The next bit of logic constructs a CIMObject from the | // The next bit of logic constructs a CIMObject from the |
|
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; | Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
| |
const char* valueString = ""; | const char* valueString = ""; |
|
Uint32 valueStringLen = 0; |
if (!empty) | if (!empty) |
{ | { |
if (testContentOrCData(parser, entry)) | if (testContentOrCData(parser, entry)) |
{ | { |
valueString = entry.text; | valueString = entry.text; |
|
valueStringLen = entry.textLen; |
} | } |
| |
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
|
|
// Bugzilla tbd | // Bugzilla tbd |
if (!empty) | if (!empty) |
#endif | #endif |
value = stringToValue(parser.getLine(), valueString,type); |
value = stringToValue( |
|
parser.getLine(), |
|
valueString, |
|
valueStringLen, |
|
type); |
| |
return true; | return true; |
} | } |
|
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; | Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
| |
const char* valueString = ""; | const char* valueString = ""; |
|
Uint32 valueStringLen = 0; |
|
|
|
if (!empty) |
|
{ |
|
if (testContentOrCData(parser, entry)) |
|
{ |
|
valueString = entry.text; |
|
valueStringLen = entry.textLen; |
|
} |
|
|
|
expectEndTag(parser, "VALUE"); |
|
} |
|
|
|
str = String(valueString, valueStringLen); |
|
return true; |
|
} |
|
|
|
// EXP_PULL_BEGIN |
|
//------------------------------------------------------------------------------ |
|
// |
|
// getUint32ValueElement() |
|
// |
|
// <!ELEMENT VALUE (#PCDATA)> |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::getUint32ValueElement( |
|
XmlParser& parser, |
|
Uint32Arg& val, |
|
Boolean required) |
|
{ |
|
XmlEntry entry; |
|
|
|
if (!testStartTagOrEmptyTag(parser, entry, "VALUE")) |
|
{ |
|
if (required) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
|
"Expected VALUE element"); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
return false; |
|
} |
|
|
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
|
|
|
const char* valueString = ""; |
| |
if (!empty) | if (!empty) |
{ | { |
|
|
| |
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
} | } |
|
else |
|
{ |
|
// create the arg object with the NULL value in it. |
|
val = Uint32Arg(); |
|
return true; |
|
} |
|
|
|
//convert to Uint32. Note error if overflow. |
|
|
|
Uint64 x; |
|
if (!StringConversion::stringToUnsignedInteger(valueString, x)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.INVALID_UI_VALUE", |
|
"Invalid unsigned integer value"); |
|
throw XmlSemanticError(parser.getLine(), mlParms); |
|
} |
|
|
|
if (!StringConversion::checkUintBounds(x, CIMTYPE_UINT32)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.U32_VALUE_OUT_OF_RANGE", |
|
"Uint32 value out of range"); |
|
throw XmlSemanticError(parser.getLine(), mlParms); |
|
} |
|
// create the arg object with the value in it. |
|
val = Uint32Arg(x); |
|
|
|
return true; |
|
} |
|
//------------------------------------------------------------------------------ |
|
// |
|
// getUint64ValueElement() |
|
// |
|
// <!ELEMENT VALUE (#PCDATA)> |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::getUint64ValueElement( |
|
XmlParser& parser, |
|
Uint64Arg& val, |
|
Boolean required) |
|
{ |
|
XmlEntry entry; |
|
|
|
if (!testStartTagOrEmptyTag(parser, entry, "VALUE")) |
|
{ |
|
if (required) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
|
"Expected VALUE element"); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
return false; |
|
} |
|
|
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
|
|
|
const char* valueString = ""; |
|
|
|
if (!empty) |
|
{ |
|
if (testContentOrCData(parser, entry)) |
|
valueString = entry.text; |
|
|
|
expectEndTag(parser, "VALUE"); |
|
} |
|
else |
|
{ |
|
// create the arg object with the NULL value in it. |
|
val = Uint64Arg(); |
|
return true; |
|
} |
|
|
|
Uint64 x; |
|
// EXP_PULL clean this up |
|
if (!StringConversion::stringToUnsignedInteger(valueString, x)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.INVALID_UI_VALUE", |
|
"Invalid unsigned integer value"); |
|
throw XmlSemanticError(parser.getLine(), mlParms); |
|
} |
|
//EXP_PULL_QUESTION- Is there even a check for 64 bit too large |
|
|
|
if (!StringConversion::checkUintBounds(x, CIMTYPE_UINT64)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.U64_VALUE_OUT_OF_RANGE", |
|
"Uint64 value out of range"); |
|
throw XmlSemanticError(parser.getLine(), mlParms); |
|
} |
|
// create the arg object with the value in it. |
|
val = Uint64Arg(x); |
| |
str = String(valueString); |
|
return true; | return true; |
} | } |
|
//EXP_PULL_END |
| |
//---------------------------------------------------------------------------- | //---------------------------------------------------------------------------- |
// | // |
|
|
template<class T> | template<class T> |
CIMValue StringArrayToValueAux( | CIMValue StringArrayToValueAux( |
Uint32 lineNumber, | Uint32 lineNumber, |
const Array<const char*>& stringArray, |
const Array<CharString>& stringArray, |
CIMType type, | CIMType type, |
T*) | T*) |
{ | { |
|
|
for (Uint32 i = 0, n = stringArray.size(); i < n; i++) | for (Uint32 i = 0, n = stringArray.size(); i < n; i++) |
{ | { |
CIMValue value = XmlReader::stringToValue( | CIMValue value = XmlReader::stringToValue( |
lineNumber, stringArray[i], type); |
lineNumber, |
|
stringArray[i].value, |
|
stringArray[i].length, |
|
type); |
| |
T x; | T x; |
value.get(x); | value.get(x); |
|
|
const Array<const char*>& array, | const Array<const char*>& array, |
CIMType type) | CIMType type) |
{ | { |
|
Array<CharString> strArray; |
|
|
|
for (Uint32 i = 0, n = array.size() ; i < n ; ++i) |
|
{ |
|
strArray.append(CharString(array[i], strlen(array[i]))); |
|
} |
|
|
|
return _stringArrayToValue(lineNumber, strArray, type); |
|
} |
|
|
|
CIMValue XmlReader::_stringArrayToValue( |
|
Uint32 lineNumber, |
|
const Array<CharString> &array, |
|
CIMType type) |
|
{ |
switch (type) | switch (type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
|
|
// Get VALUE.ARRAY open tag: | // Get VALUE.ARRAY open tag: |
| |
XmlEntry entry; | XmlEntry entry; |
Array<const char*> stringArray; |
Array<CharString> stringArray; |
| |
// If no VALUE.ARRAY start tag, return false | // If no VALUE.ARRAY start tag, return false |
if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY")) | if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY")) |
|
|
| |
while (testStartTagOrEmptyTag(parser, entry, "VALUE")) | while (testStartTagOrEmptyTag(parser, entry, "VALUE")) |
{ | { |
|
// ATTN: NULL values in array will have VALUE.NULL subelement |
|
// See DSP0201 Version 2.3.0, Section 5.2.3.2 |
if (entry.type == XmlEntry::EMPTY_TAG) | if (entry.type == XmlEntry::EMPTY_TAG) |
{ | { |
stringArray.append(""); |
stringArray.append(CharString("", 0)); |
continue; | continue; |
} | } |
| |
if (testContentOrCData(parser, entry)) | if (testContentOrCData(parser, entry)) |
stringArray.append(entry.text); |
{ |
|
stringArray.append(CharString(entry.text, entry.textLen)); |
|
} |
else | else |
stringArray.append(""); |
{ |
|
stringArray.append(CharString("", 0)); |
|
} |
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
} | } |
| |
expectEndTag(parser, "VALUE.ARRAY"); | expectEndTag(parser, "VALUE.ARRAY"); |
} | } |
| |
value = stringArrayToValue(parser.getLine(), stringArray, type); |
value = _stringArrayToValue(parser.getLine(), stringArray, type); |
return true; | return true; |
} | } |
| |
|
|
| |
Uint64 arraySize; | Uint64 arraySize; |
| |
if (!stringToUnsignedInteger(tmp, arraySize) || (arraySize == 0) || |
if (!StringConversion::stringToUnsignedInteger(tmp, arraySize) || |
|
(arraySize == 0) || |
!StringConversion::checkUintBounds(arraySize, CIMTYPE_UINT32)) | !StringConversion::checkUintBounds(arraySize, CIMTYPE_UINT32)) |
{ | { |
char message[128]; | char message[128]; |
|
|
return true; | return true; |
} | } |
| |
|
|
|
//EXP_PULL_BEGIN |
|
//------------------------------------------------------------------------------ |
|
// getInstanceWithPathElement() |
|
// |
|
// <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)> |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::getInstanceWithPathElement( |
|
XmlParser& parser, |
|
CIMInstance& namedInstance) |
|
{ |
|
XmlEntry entry; |
|
if (!testStartTag(parser, entry, "VALUE.INSTANCEWITHPATH")) |
|
return false; |
|
|
|
CIMObjectPath instanceName; |
|
|
|
// Get INSTANCENAME elements: |
|
//EXP_PULL_ISSUE Should we have new getInstancePathElement??? |
|
if (!getInstancePathElement(parser, instanceName)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.EXPECTED_INSTANCEPATH_ELEMENT", |
|
"expected INSTANCEPATH element"); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
// Get INSTANCE elements: |
|
|
|
if (!getInstanceElement(parser, namedInstance)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
|
"expected INSTANCE element"); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
// Get VALUE.NAMEDINSTANCE end tag: |
|
|
|
expectEndTag(parser, "VALUE.INSTANCEWITHPATH"); |
|
|
|
namedInstance.setPath (instanceName); |
|
|
|
return true; |
|
} |
|
|
|
//EXP_PULL_END |
|
|
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// getObject() | // getObject() |
|
|
return true; | return true; |
} | } |
| |
|
//EXP_PULL_BEGIN |
|
//------------------------------------------------------------------------------ |
|
// |
|
// getIParamValueTag() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::getParamValueTag( |
|
XmlParser& parser, |
|
const char*& name, |
|
Boolean& isEmptyTag) |
|
{ |
|
XmlEntry entry; |
|
|
|
if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE")) |
|
{ |
|
|
|
return false; |
|
} |
|
|
|
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG); |
|
|
|
// Get PARAMVALUE.NAME attribute: |
|
|
|
if (!entry.getAttributeValue("NAME", name)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE", |
|
"Missing PARAMVALUE.NAME attribute"); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
return true; |
|
} |
|
//------------------------------------------------------------------------------ |
|
// |
|
// getIReturnValueTag() |
|
// |
|
//------------------------------------------------------------------------------ |
|
////EXP_PULL Think we can get rid of this TBD |
|
Boolean XmlReader::getIReturnValueTag( |
|
XmlParser& parser, |
|
const char*& name, |
|
Boolean& isEmptyTag) |
|
{ |
|
XmlEntry entry; |
|
if (!testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE")) |
|
return false; |
|
//entry.print(); |
|
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG); |
|
|
|
if (!entry.getAttributeValue("NAME", name)) |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.MISSING_IRETURNVALUE_ATTRIBUTE", |
|
"Missing IRETURNVALUE.NAME attribute"); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
// EXP_PULL_TBD Add new msg above to msg bundle. |
|
return true; |
|
} |
|
|
|
//EXP_PULL_END |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// rejectNullIParamValue() | // rejectNullIParamValue() |
|
|
} | } |
} | } |
| |
|
// EXP_PULL_BEGIN |
|
//------------------------------------------------------------------------------ |
|
// |
|
// rejectNullIReturnParamValue() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void XmlReader::rejectNullIReturnValue( |
|
XmlParser& parser, |
|
Boolean isEmptyTag, |
|
const char* paramName) |
|
{ |
|
if (isEmptyTag) |
|
{ |
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IRETURNVALUE", |
|
"A null value is not valid for IRETURNVALUE \"$0\".", |
|
paramName); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
|
|
void XmlReader::rejectNullParamValue( |
|
XmlParser& parser, |
|
Boolean isEmptyTag, |
|
const char* paramName) |
|
{ |
|
if (isEmptyTag) |
|
{ |
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_PARAMVALUE", |
|
"A null value is not valid for PARAMVALUE \"$0\".", |
|
paramName); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
// EXP_PULL_TODO_TBD add above message to bundle |
|
// EXP_PULL_END |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// getBooleanValueElement() | // getBooleanValueElement() |