version 1.76, 2002/10/02 20:35:06
|
version 1.104, 2004/09/22 18:59:41
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2003//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// 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.; |
|
// IBM Corp.; EMC 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 |
|
|
#include "CIMObject.h" | #include "CIMObject.h" |
#include "CIMParamValue.h" | #include "CIMParamValue.h" |
#include "System.h" | #include "System.h" |
|
#include "XmlConstants.h" |
|
#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM |
|
#include "OS400ConvertChar.h" |
|
#endif |
|
// l10n |
|
#include <Pegasus/Common/MessageLoader.h> |
| |
#define PEGASUS_SINT64_MIN (-PEGASUS_SINT64_LITERAL(0x8000000000000000)) |
#define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000)) |
#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF) | #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF) |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
|
|
entry.type != XmlEntry::XML_DECLARATION || | entry.type != XmlEntry::XML_DECLARATION || |
strcmp(entry.text, "xml") != 0) | strcmp(entry.text, "xml") != 0) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected <?xml ... ?> style declaration"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE", |
"Expected <?xml ... ?> style declaration"); | "Expected <?xml ... ?> style declaration"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
if (!entry.getAttributeValue("version", xmlVersion)) |
if (!entry.getAttributeValue("version", xmlVersion)) { |
throw XmlValidationError( |
|
parser.getLine(), "missing xml.version attribute"); |
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "missing xml.version attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_XML_ATTRIBUTE", |
|
"missing xml.version attribute"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
if (!entry.getAttributeValue("encoding", xmlEncoding)) | if (!entry.getAttributeValue("encoding", xmlEncoding)) |
{ | { |
|
|
entry.type != XmlEntry::START_TAG || | entry.type != XmlEntry::START_TAG || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
char message[MESSAGE_SIZE]; |
// l10n |
sprintf(message, "Expected open of %s element", tagName); |
|
throw XmlValidationError(parser.getLine(), message); |
// char message[MESSAGE_SIZE]; |
|
// sprintf(message, "Expected open of %s element", tagName); |
|
// throw XmlValidationError(parser.getLine(), message); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN", |
|
"Expected open of $0 element", |
|
tagName); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
entry.type != XmlEntry::END_TAG || | entry.type != XmlEntry::END_TAG || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
char message[MESSAGE_SIZE]; |
|
sprintf(message, "Expected close of %s element, got %s instead", |
// l10n |
|
|
|
// char message[MESSAGE_SIZE]; |
|
// sprintf(message, "Expected close of %s element, got %s instead", |
|
// tagName,entry.text); |
|
// throw XmlValidationError(parser.getLine(), message); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLOSE", |
|
"Expected close of $0 element, got $1 instead", |
tagName,entry.text); | tagName,entry.text); |
throw XmlValidationError(parser.getLine(), message); |
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
entry.type != XmlEntry::EMPTY_TAG) || | entry.type != XmlEntry::EMPTY_TAG) || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
char message[MESSAGE_SIZE]; |
// l10n |
sprintf(message, |
|
"Expected either open or open/close %s element", tagName); |
// char message[MESSAGE_SIZE]; |
throw XmlValidationError(parser.getLine(), message); |
// sprintf(message, |
|
// "Expected either open or open/close %s element", tagName); |
|
// throw XmlValidationError(parser.getLine(), message); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPENCLOSE", |
|
"Expected either open or open/close $0 element", |
|
tagName); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
(entry.type != XmlEntry::CONTENT && | (entry.type != XmlEntry::CONTENT && |
entry.type != XmlEntry::CDATA)) | entry.type != XmlEntry::CDATA)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected content of CDATA"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA", |
"Expected content of CDATA"); | "Expected content of CDATA"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
return true; | return true; |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// testStartTagOrEmptyTag() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::testStartTagOrEmptyTag( |
|
XmlParser& parser, |
|
XmlEntry& entry) |
|
{ |
|
if (!parser.next(entry) || |
|
(entry.type != XmlEntry::START_TAG && |
|
entry.type != XmlEntry::EMPTY_TAG)) |
|
{ |
|
parser.putBack(entry); |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
// testContentOrCData() | // testContentOrCData() |
// | // |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
XmlEntry entry; | XmlEntry entry; |
XmlReader::expectStartTag(parser, entry, "CIM"); | XmlReader::expectStartTag(parser, entry, "CIM"); |
| |
if (!entry.getAttributeValue("CIMVERSION", cimVersion)) |
if (!entry.getAttributeValue("CIMVERSION", cimVersion)) { |
throw XmlValidationError( |
|
parser.getLine(), "missing CIM.CIMVERSION attribute"); |
// l10n |
|
|
if (!entry.getAttributeValue("DTDVERSION", dtdVersion)) |
// throw XmlValidationError( |
throw XmlValidationError( |
// parser.getLine(), "missing CIM.CIMVERSION attribute"); |
parser.getLine(), "missing CIM.DTDVERSION attribute"); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE", |
|
"missing CIM.CIMVERSION attribute"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
if (!entry.getAttributeValue("DTDVERSION", dtdVersion)){ |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "missing CIM.DTDVERSION attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE", |
|
"missing CIM.DTDVERSION attribute"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
| |
if (!entry.getAttributeValue("NAME", name)) | if (!entry.getAttributeValue("NAME", name)) |
{ | { |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, "missing %s.NAME attribute", elementName); |
|
// throw XmlValidationError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, "missing %s.NAME attribute", elementName); |
sprintf(buffer, "%s.NAME", elementName); |
throw XmlValidationError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
buffer); |
|
|
|
throw XmlValidationError(lineNumber, mlParms); |
} | } |
| |
if (acceptNull && name.size() == 0) | if (acceptNull && name.size() == 0) |
|
|
| |
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
// In testing, replace illegal CIMName with this value to avoid the |
|
// exception and let xml parsing continue. THIS IS TEMP. |
|
name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT"; |
|
#else |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, "Illegal value for %s.NAME attribute", elementName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, "Illegal value for %s.NAME attribute", elementName); |
sprintf(buffer, "%s.NAME", elementName); |
throw XmlSemanticError(lineNumber, buffer); |
|
} |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
| |
|
#endif |
|
} |
return CIMName (name); | return CIMName (name); |
} | } |
| |
|
|
| |
if (!entry.getAttributeValue("CLASSNAME", name)) | if (!entry.getAttributeValue("CLASSNAME", name)) |
{ | { |
|
|
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, "missing %s.CLASSNAME attribute", elementName); |
|
// throw XmlValidationError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, "missing %s.CLASSNAME attribute", elementName); |
sprintf(buffer, "%s.CLASSNAME", elementName); |
throw XmlValidationError(lineNumber, buffer); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
buffer); |
|
|
|
throw XmlValidationError(lineNumber, mlParms); |
|
|
} | } |
| |
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, |
|
// "Illegal value for %s.CLASSNAME attribute", elementName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, |
sprintf(buffer, "%s.CLASSNAME", elementName); |
"Illegal value for %s.CLASSNAME attribute", elementName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
| |
return name; | return name; |
|
|
if (!entry.getAttributeValue("CLASSORIGIN", name)) | if (!entry.getAttributeValue("CLASSORIGIN", name)) |
return CIMName(); | return CIMName(); |
| |
// KS 200209 This may be temp but we are adding test for form |
|
// CLASSNAME = "" for Wbemservices interoperability. Returns same |
|
// as if attribute did not exist. |
|
if (name.size() == 0) |
|
return CIMName(); |
|
|
|
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, |
|
// "Illegal value for %s.CLASSORIGIN attribute", tagName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, |
sprintf(buffer, "%s.CLASSORIGIN", tagName); |
"Illegal value for %s.CLASSORIGIN attribute", tagName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return name; | return name; |
|
|
| |
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME"; |
|
return name; |
|
#endif |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, |
|
// "Illegal value for %s.REFERENCECLASS attribute", elementName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, |
sprintf(buffer, "%s.REFERENCECLASS", elementName); |
"Illegal value for %s.REFERENCECLASS attribute", elementName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return name; | return name; |
|
|
| |
if (!CIMName::legal(superClass)) | if (!CIMName::legal(superClass)) |
{ | { |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf( |
|
// buffer, "Illegal value for %s.SUPERCLASS attribute", tagName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf( |
sprintf(buffer, "%s.SUPERCLASS", tagName); |
buffer, "Illegal value for %s.SUPERCLASS attribute", tagName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return superClass; | return superClass; |
|
|
{ | { |
if (required) | if (required) |
{ | { |
|
|
|
// l10n |
|
|
|
// char message[MESSAGE_SIZE]; |
|
// sprintf(message, "missing %s.%s attribute", tagName, attributeName); |
|
// throw XmlValidationError(lineNumber, message); |
|
|
char message[MESSAGE_SIZE]; | char message[MESSAGE_SIZE]; |
sprintf(message, "missing %s.%s attribute", tagName, attributeName); |
sprintf(message, "%s.%s", tagName, attributeName); |
throw XmlValidationError(lineNumber, message); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
message); |
|
|
|
throw XmlValidationError(lineNumber, mlParms); |
|
|
} | } |
else | else |
{ | { |
|
|
((type == CIMTYPE_REFERENCE) && | ((type == CIMTYPE_REFERENCE) && |
(strcmp(attributeName, "PARAMTYPE") != 0))) | (strcmp(attributeName, "PARAMTYPE") != 0))) |
{ | { |
char message[MESSAGE_SIZE]; |
// l10n |
sprintf(message, "Illegal value for %s.%s attribute", tagName, |
|
attributeName); |
// char message[MESSAGE_SIZE]; |
throw XmlSemanticError(lineNumber, message); |
// sprintf(message, "Illegal value for %s.%s attribute", tagName, |
|
// attributeName); |
|
// throw XmlSemanticError(lineNumber, message); |
|
|
|
char buffer[MESSAGE_SIZE]; |
|
sprintf(buffer, "%s.%s", tagName, attributeName); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
cimType = type; | cimType = type; |
|
|
if (!required) | if (!required) |
return defaultValue; | return defaultValue; |
| |
|
// l10n |
|
|
|
// char buffer[62]; |
|
// sprintf(buffer, "missing required %s.%s attribute", |
|
// attributeName, tagName); |
|
|
|
// throw XmlValidationError(lineNumber, buffer); |
|
|
char buffer[62]; | char buffer[62]; |
sprintf(buffer, "missing required %s.%s attribute", |
sprintf(buffer, "%s.%s", attributeName, tagName); |
attributeName, tagName); |
|
| |
throw XmlValidationError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE", |
|
"missing required $0 attribute", |
|
buffer); |
|
|
|
throw XmlValidationError(lineNumber, mlParms); |
} | } |
| |
if (strcmp(tmp, "true") == 0) | if (strcmp(tmp, "true") == 0) |
|
|
else if (strcmp(tmp, "false") == 0) | else if (strcmp(tmp, "false") == 0) |
return false; | return false; |
| |
|
// l10n |
|
|
|
// char buffer[62]; |
|
// sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[62]; | char buffer[62]; |
sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName); |
sprintf(buffer, "%s.%s", attributeName, tagName); |
throw XmlSemanticError(lineNumber, buffer); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_ATTRIBUTE", |
|
"Invalid $0 attribute value", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
return false; | return false; |
} | } |
| |
|
|
return true; | return true; |
} | } |
| |
inline Uint8 _hexCharToNumeric(const char c) |
inline Uint8 _xmlReader_hexCharToNumeric(const char c) |
{ | { |
Uint8 n; | Uint8 n; |
| |
|
|
return n; | return n; |
} | } |
| |
|
// See http://www.ietf.org/rfc/rfc2396.txt section 2 |
|
// |
|
// Also see the "CIM Operations over HTTP" spec, section 3.3.2 and |
|
// 3.3.3, for the treatment of non US-ASCII chars (UTF-8) |
|
String XmlReader::decodeURICharacters(String uriString) |
|
{ |
|
Uint32 i; |
|
|
|
Array<Uint8> utf8Chars; |
|
|
|
for (i=0; i<uriString.size(); i++) |
|
{ |
|
if (uriString[i] == '%') |
|
{ |
|
if (i+2 >= uriString.size()) |
|
{ |
|
// l10n |
|
|
|
// throw ParseError("Invalid URI encoding"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING", |
|
"Invalid URI encoding"); |
|
|
|
throw ParseError(MessageLoader::getMessage(mlParms)); |
|
|
|
} |
|
|
|
Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i])); |
|
Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i])); |
|
if ( (digit1 > 15) || (digit2 > 15) ) |
|
{ |
|
// l10n |
|
|
|
// throw ParseError("Invalid URI encoding"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING", |
|
"Invalid URI encoding"); |
|
|
|
throw ParseError(MessageLoader::getMessage(mlParms)); |
|
} |
|
|
|
Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); |
|
utf8Chars.append((Uint8)decodedChar); |
|
} |
|
else |
|
{ |
|
utf8Chars.append((Uint8)uriString[i]); |
|
} |
|
} |
|
|
|
// If there was a string to decode... |
|
if (uriString.size() > 0) |
|
{ |
|
// Convert UTF-8 to UTF-16 and return the String |
|
utf8Chars.append('\0'); |
|
return String((char *)utf8Chars.getData()); |
|
} |
|
else |
|
{ |
|
return String(); |
|
} |
|
} |
|
|
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// stringToSignedInteger | // stringToSignedInteger |
|
|
x = x << 4; | x = x << 4; |
| |
// Make sure we don't overflow when we add the next digit | // Make sure we don't overflow when we add the next digit |
Sint64 newDigit = Sint64(_hexCharToNumeric(*p++)); |
Sint64 newDigit = Sint64(_xmlReader_hexCharToNumeric(*p++)); |
if (PEGASUS_SINT64_MIN - x > -newDigit) | if (PEGASUS_SINT64_MIN - x > -newDigit) |
{ | { |
return false; | return false; |
|
|
x = x << 4; | x = x << 4; |
| |
// We can't overflow when we add the next digit | // We can't overflow when we add the next digit |
Uint64 newDigit = Uint64(_hexCharToNumeric(*p++)); |
Uint64 newDigit = Uint64(_xmlReader_hexCharToNumeric(*p++)); |
if (PEGASUS_UINT64_MAX - x < newDigit) | if (PEGASUS_UINT64_MAX - x < newDigit) |
{ | { |
return false; | return false; |
|
|
return CIMValue(true); | return CIMValue(true); |
else if (System::strcasecmp(valueString, "FALSE") == 0) | else if (System::strcasecmp(valueString, "FALSE") == 0) |
return CIMValue(false); | return CIMValue(false); |
else |
else { |
throw XmlSemanticError( |
|
lineNumber, "Invalid boolean value"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Invalid boolean value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_BOOLEAN_VALUE", |
|
"Invalid boolean value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
|
} |
} | } |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
|
|
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
{ | { |
if (strlen(valueString) != 1) |
|
throw XmlSemanticError(lineNumber, "Invalid char16 value"); |
|
| |
return CIMValue(Char16(valueString[0])); |
// remove this test, utf-8 can be up to 6 bytes per char |
|
/* |
|
if (strlen(valueString) != 1) { |
|
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid char16 value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE", |
|
"Invalid char16 value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
|
*/ |
|
// Converts UTF-8 to UTF-16 |
|
String tmp(valueString); |
|
if (tmp.size() != 1) |
|
{ |
|
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid char16 value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE", |
|
"Invalid char16 value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
|
|
|
return CIMValue(tmp[0]); |
} | } |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
|
|
| |
if (!stringToUnsignedInteger(valueString, x)) | if (!stringToUnsignedInteger(valueString, x)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Invalid unsigned integer value"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Invalid unsigned integer value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_UI_VALUE", |
|
"Invalid unsigned integer value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
| |
switch (type) | switch (type) |
|
|
{ | { |
if (x >= (Uint64(1)<<8)) | if (x >= (Uint64(1)<<8)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Uint8 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Uint8 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.U8_VALUE_OUT_OF_RANGE", |
|
"Uint8 value out of range"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Uint8(x)); | return CIMValue(Uint8(x)); |
} | } |
|
|
{ | { |
if (x >= (Uint64(1)<<16)) | if (x >= (Uint64(1)<<16)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Uint16 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Uint16 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.U16_VALUE_OUT_OF_RANGE", |
|
"Uint16 value out of range"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
return CIMValue(Uint16(x)); | return CIMValue(Uint16(x)); |
} | } |
|
|
{ | { |
if (x >= (Uint64(1)<<32)) | if (x >= (Uint64(1)<<32)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Uint32 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Uint32 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.U32_VALUE_OUT_OF_RANGE", |
|
"Uint32 value out of range"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Uint32(x)); | return CIMValue(Uint32(x)); |
} | } |
|
|
| |
if (!stringToSignedInteger(valueString, x)) | if (!stringToSignedInteger(valueString, x)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Invalid signed integer value"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Invalid signed integer value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_SI_VALUE", |
|
"Invalid signed integer value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
| |
switch (type) | switch (type) |
|
|
{ | { |
if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) ) | if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) ) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Sint8 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Sint8 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.S8_VALUE_OUT_OF_RANGE", |
|
"Sint8 value out of range"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Sint8(x)); | return CIMValue(Sint8(x)); |
} | } |
|
|
{ | { |
if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) ) | if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) ) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Sint16 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Sint16 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.S16_VALUE_OUT_OF_RANGE", |
|
"Sint16 value out of range"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Sint16(x)); | return CIMValue(Sint16(x)); |
} | } |
|
|
{ | { |
if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) ) | if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) ) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Sint32 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Sint32 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.S32_VALUE_OUT_OF_RANGE", |
|
"Sint32 value out of range"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Sint32(x)); | return CIMValue(Sint32(x)); |
} | } |
|
|
// KS 20021002 - Exception if no datatime value. Test for | // KS 20021002 - Exception if no datatime value. Test for |
// zero length and leave the NULL value in the variable | // zero length and leave the NULL value in the variable |
// Bugzilla 137 Adds the following if line. | // Bugzilla 137 Adds the following if line. |
|
// 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 (strlen(valueString) != 0) |
#endif | #endif |
|
|
} | } |
catch (InvalidDateTimeFormatException&) | catch (InvalidDateTimeFormatException&) |
{ | { |
cout << "KSTESTSNIA Invalid date time" << strlen(valueString) << "xx" << valueString << endl; |
|
throw XmlSemanticError(lineNumber, "Invalid datetime value"); |
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid datetime value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_DATETIME_VALUE", |
|
"Invalid datetime value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return CIMValue(tmp); | return CIMValue(tmp); |
|
|
{ | { |
Real64 x; | Real64 x; |
| |
if (!stringToReal(valueString, x)) |
if (!stringToReal(valueString, x)) { |
throw XmlSemanticError(lineNumber, "Invalid real number value"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid real number value"); |
| |
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE", |
|
"Invalid real number value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
return CIMValue(Real32(x)); | return CIMValue(Real32(x)); |
} | } |
| |
|
|
{ | { |
Real64 x; | Real64 x; |
| |
if (!stringToReal(valueString, x)) |
if (!stringToReal(valueString, x)) { |
throw XmlSemanticError(lineNumber, "Invalid real number value"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid real number value"); |
| |
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE", |
|
"Invalid real number value"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
return CIMValue(x); | return CIMValue(x); |
} | } |
| |
|
|
break; | break; |
} | } |
| |
throw XmlSemanticError(lineNumber, "malformed XML"); |
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "malformed XML"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MALFORMED_XML", |
|
"malformed XML"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
return false; | return false; |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// skipElement() |
|
// |
|
//------------------------------------------------------------------------------ |
|
void XmlReader::skipElement( |
|
XmlParser& parser, |
|
XmlEntry& entry) |
|
{ |
|
const char * tag_name = entry.text; |
|
|
|
if (entry.type == XmlEntry::EMPTY_TAG) |
|
{ |
|
return; |
|
} |
|
|
|
while (testStartTagOrEmptyTag(parser, entry)) |
|
{ |
|
skipElement(parser, entry); |
|
} |
|
|
|
if (testContentOrCData(parser, entry)) |
|
{ |
|
; // skip |
|
} |
|
|
|
expectEndTag(parser, tag_name); |
|
return; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
// getValueElement() | // getValueElement() |
// | // |
// <!ELEMENT VALUE (#PCDATA)> | // <!ELEMENT VALUE (#PCDATA)> |
|
|
| |
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
} | } |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
// KS 20021004 - tries to put value in even if empty. |
|
// Think this is general problem with empty value |
|
// Need to check meaning of (#PCDATA) - Does it allow empty. |
|
// Bugzilla tbd |
|
if (!empty) |
|
#endif |
value = stringToValue(parser.getLine(), valueString,type); | value = stringToValue(parser.getLine(), valueString,type); |
| |
return true; | return true; |
|
|
| |
if (!testStartTagOrEmptyTag(parser, entry, "VALUE")) | if (!testStartTagOrEmptyTag(parser, entry, "VALUE")) |
{ | { |
if (required) |
if (required) { |
throw XmlValidationError(parser.getLine(),"Expected VALUE element"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(),"Expected VALUE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
|
"Expected VALUE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
|
|
} |
return false; | return false; |
} | } |
| |
|
|
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
} | } |
| |
str = valueString; |
str = String(valueString); |
return true; | return true; |
} | } |
| |
|
|
// Get QUALIFIER element: | // Get QUALIFIER element: |
| |
XmlEntry entry; | XmlEntry entry; |
if (!testStartTag(parser, entry, "QUALIFIER")) |
if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER")) |
return false; | return false; |
| |
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
|
|
// Get QUALIFIER.NAME attribute: | // Get QUALIFIER.NAME attribute: |
| |
CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER"); | CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER"); |
|
|
| |
CIMValue value; | CIMValue value; |
| |
|
if (empty) |
|
{ |
|
value.setNullValue(type, false); |
|
} |
|
else |
|
{ |
if (!getValueElement(parser, type, value) && | if (!getValueElement(parser, type, value) && |
!getValueArrayElement(parser, type, value)) | !getValueArrayElement(parser, type, value)) |
{ | { |
|
|
// Expect </QUALIFIER>: | // Expect </QUALIFIER>: |
| |
expectEndTag(parser, "QUALIFIER"); | expectEndTag(parser, "QUALIFIER"); |
|
} |
| |
// Build qualifier: | // Build qualifier: |
| |
|
|
} | } |
catch (AlreadyExistsException&) | catch (AlreadyExistsException&) |
{ | { |
throw XmlSemanticError(parser.getLine(), "duplicate qualifier"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), "duplicate qualifier"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER", |
|
"duplicate qualifier"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
} | } |
} | } |
|
|
| |
if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0) | if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0) |
{ | { |
|
// l10n |
|
|
|
// char message[128]; |
|
// sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE"); |
|
// throw XmlSemanticError(lineNumber, message); |
|
|
char message[128]; | char message[128]; |
sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE"); |
sprintf(message, "%s.%s", tagName, "ARRAYSIZE"); |
throw XmlSemanticError(lineNumber, message); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE", |
|
"Illegal value for $0", |
|
message); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
value = Uint32(arraySize); | value = Uint32(arraySize); |
|
|
{ | { |
if (arraySize && arraySize != value.getArraySize()) | if (arraySize && arraySize != value.getArraySize()) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "ARRAYSIZE attribute and value-array size are different"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT", |
"ARRAYSIZE attribute and value-array size are different"); | "ARRAYSIZE attribute and value-array size are different"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
property.setValue(value); | property.setValue(value); |
|
|
| |
if (!testStartTag(parser, entry, "HOST")) | if (!testStartTag(parser, entry, "HOST")) |
return false; | return false; |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
// Temp code to allow empty HOST field. |
|
// SNIA CIMOMs return empty field particularly on enumerateinstance. |
|
// Simply substitute a string for the empty. |
|
if (!parser.next(entry)) |
|
throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine()); |
|
|
|
if (entry.type == XmlEntry::CONTENT) |
|
host = String(entry.text); |
|
else |
|
{ |
|
parser.putBack(entry); |
|
host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT"; |
|
} |
|
|
|
#else |
| |
if (!parser.next(entry) || entry.type != XmlEntry::CONTENT) | if (!parser.next(entry) || entry.type != XmlEntry::CONTENT) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected content of HOST element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT", |
"expected content of HOST element"); | "expected content of HOST element"); |
} |
|
| |
host = entry.text; |
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
} |
| |
|
host = String(entry.text); |
|
#endif |
expectEndTag(parser, "HOST"); | expectEndTag(parser, "HOST"); |
return true; | return true; |
} | } |
|
|
| |
if (!nameSpace.size()) | if (!nameSpace.size()) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected one or more NAMESPACE elements within " |
// l10n |
"LOCALNAMESPACEPATH element"); |
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected one or more NAMESPACE elements within " |
|
// "LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS", |
|
"Expected one or more NAMESPACE elements within LOCALNAMESPACEPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
|
} | } |
| |
expectEndTag(parser, "LOCALNAMESPACEPATH"); | expectEndTag(parser, "LOCALNAMESPACEPATH"); |
|
|
if (!testStartTag(parser, entry, "NAMESPACEPATH")) | if (!testStartTag(parser, entry, "NAMESPACEPATH")) |
return false; | return false; |
| |
if (!getHostElement(parser, host)) |
if (!getHostElement(parser, host)) { |
throw XmlValidationError(parser.getLine(), "expected HOST element"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), "expected HOST element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_HOST_ELEMENT", |
|
"expected HOST element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
if (!getLocalNameSpacePathElement(parser, nameSpace)) | if (!getLocalNameSpacePathElement(parser, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT", |
"expected LOCALNAMESPACEPATH element"); | "expected LOCALNAMESPACEPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
expectEndTag(parser, "NAMESPACEPATH"); | expectEndTag(parser, "NAMESPACEPATH"); |
|
|
{ | { |
if (required) | if (required) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT", |
"expected CLASSNAME element"); | "expected CLASSNAME element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
else | else |
return false; | return false; |
} | } |
|
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; | Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
| |
className = getCimNameAttribute( | className = getCimNameAttribute( |
parser.getLine(), entry, "CLASSNAME", true); |
parser.getLine(), entry, "CLASSNAME", false); |
| |
if (!empty) | if (!empty) |
expectEndTag(parser, "CLASSNAME"); | expectEndTag(parser, "CLASSNAME"); |
|
|
else if (String::equal(tmp, "numeric")) | else if (String::equal(tmp, "numeric")) |
return CIMKeyBinding::NUMERIC; | return CIMKeyBinding::NUMERIC; |
| |
|
// char buffer[MESSAGE_SIZE]; |
|
|
|
// sprintf(buffer, |
|
// "Illegal value for %s.VALUETYPE attribute; " |
|
// "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", |
|
// elementName); |
|
|
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
|
sprintf(buffer, "%s.VALUETYPE", elementName); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE", |
|
"Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer); |
| |
sprintf(buffer, |
throw XmlSemanticError(lineNumber, mlParms); |
"Illegal value for %s.VALUETYPE attribute; " |
|
"CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", |
|
elementName); |
|
| |
throw XmlSemanticError(lineNumber, buffer); |
|
return CIMKeyBinding::BOOLEAN; | return CIMKeyBinding::BOOLEAN; |
} | } |
| |
|
|
throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine()); | throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine()); |
| |
if (entry.type == XmlEntry::CONTENT) | if (entry.type == XmlEntry::CONTENT) |
value = entry.text; |
value = String(entry.text); |
else | else |
parser.putBack(entry); | parser.putBack(entry); |
| |
|
|
| |
if (!getValueReferenceElement(parser, reference)) | if (!getValueReferenceElement(parser, reference)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected KEYVALUE or VALUE.REFERENCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT", |
"Expected KEYVALUE or VALUE.REFERENCE element"); | "Expected KEYVALUE or VALUE.REFERENCE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
type = CIMKeyBinding::REFERENCE; | type = CIMKeyBinding::REFERENCE; |
|
|
| |
if (!getNameSpacePathElement(parser, host, nameSpace)) | if (!getNameSpacePathElement(parser, host, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected NAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT", |
"expected NAMESPACEPATH element"); | "expected NAMESPACEPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
String className; | String className; |
|
|
| |
if (!getInstanceNameElement(parser, className, keyBindings)) | if (!getInstanceNameElement(parser, className, keyBindings)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCENAME element"); |
|
|
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT", |
"expected INSTANCENAME element"); | "expected INSTANCENAME element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(host, nameSpace, className, keyBindings); | reference.set(host, nameSpace, className, keyBindings); |
|
|
| |
if (!getLocalNameSpacePathElement(parser, nameSpace)) | if (!getLocalNameSpacePathElement(parser, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT", |
"expected LOCALNAMESPACEPATH element"); | "expected LOCALNAMESPACEPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
String className; | String className; |
|
|
| |
if (!getInstanceNameElement(parser, className, keyBindings)) | if (!getInstanceNameElement(parser, className, keyBindings)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCENAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT", |
"expected INSTANCENAME element"); | "expected INSTANCENAME element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(String(), nameSpace, className, keyBindings); | reference.set(String(), nameSpace, className, keyBindings); |
|
|
| |
if (!getNameSpacePathElement(parser, host, nameSpace)) | if (!getNameSpacePathElement(parser, host, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected NAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT", |
"expected NAMESPACEPATH element"); | "expected NAMESPACEPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
CIMName className; | CIMName className; |
| |
if (!getClassNameElement(parser, className)) | if (!getClassNameElement(parser, className)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT", |
"expected CLASSNAME element"); | "expected CLASSNAME element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(host, nameSpace, className); | reference.set(host, nameSpace, className); |
|
|
| |
if (!getLocalNameSpacePathElement(parser, nameSpace)) | if (!getLocalNameSpacePathElement(parser, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT", |
"expected LOCALNAMESPACEPATH element"); | "expected LOCALNAMESPACEPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
CIMName className; | CIMName className; |
| |
if (!getClassNameElement(parser, className)) | if (!getClassNameElement(parser, className)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT", |
"expected CLASSNAME element"); | "expected CLASSNAME element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(String(), nameSpace, className); | reference.set(String(), nameSpace, className); |
|
|
if (entry.type != XmlEntry::START_TAG && | if (entry.type != XmlEntry::START_TAG && |
entry.type != XmlEntry::EMPTY_TAG) | entry.type != XmlEntry::EMPTY_TAG) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected one of the following start tags: " |
// l10n |
"CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, " |
|
"LOCALINSTANCEPATH, INSTANCENAME"); |
// throw XmlValidationError(parser.getLine(), |
|
// "Expected one of the following start tags: " |
|
// "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, " |
|
// "LOCALINSTANCEPATH, INSTANCENAME"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS", |
|
"Expected one of the following start tags: CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
if (strcmp(entry.text, "CLASSPATH") == 0) | if (strcmp(entry.text, "CLASSPATH") == 0) |
|
|
} | } |
catch (AlreadyExistsException&) | catch (AlreadyExistsException&) |
{ | { |
throw XmlSemanticError(parser.getLine(), "duplicate property"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), "duplicate property"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY", |
|
"duplicate property"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
} | } |
} | } |
|
|
} | } |
catch (AlreadyExistsException&) | catch (AlreadyExistsException&) |
{ | { |
throw XmlSemanticError(parser.getLine(), "duplicate parameter"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), "duplicate parameter"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER", |
|
"duplicate parameter"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
} | } |
} | } |
|
|
{ | { |
if (!isArray) | if (!isArray) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
"VALUE.ARRAY element encountered without " |
// l10n |
"ISARRAY attribute"); |
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "VALUE.ARRAY element encountered without " |
|
// "ISARRAY attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY", |
|
"VALUE.ARRAY element encountered without ISARRAY attribute"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
if (arraySize && arraySize != value.getArraySize()) | if (arraySize && arraySize != value.getArraySize()) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
"VALUE.ARRAY size is not the same as " |
// l10n |
"ARRAYSIZE attribute"); |
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "VALUE.ARRAY size is not the same as " |
|
// "ARRAYSIZE attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME", |
|
"VALUE.ARRAY size is not the same as ARRAYSIZE attribute"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
gotValue = true; | gotValue = true; |
|
|
{ | { |
if (isArray) | if (isArray) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "ISARRAY attribute used but VALUE element encountered"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT", |
"ISARRAY attribute used but VALUE element encountered"); | "ISARRAY attribute used but VALUE element encountered"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
gotValue = true; | gotValue = true; |
|
|
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "CLASS")) |
if (!testStartTagOrEmptyTag(parser, entry, "CLASS")) |
return false; | return false; |
| |
CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS"); | CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS"); |
|
|
| |
cimClass = CIMClass(name, superClass); | cimClass = CIMClass(name, superClass); |
| |
|
if(entry.type != XmlEntry::EMPTY_TAG) |
|
{ |
|
|
// Get QUALIFIER elements: | // Get QUALIFIER elements: |
| |
getQualifierElements(parser, cimClass); | getQualifierElements(parser, cimClass); |
|
|
// Get CLASS end tag: | // Get CLASS end tag: |
| |
expectEndTag(parser, "CLASS"); | expectEndTag(parser, "CLASS"); |
|
} |
| |
return true; | return true; |
} | } |
|
|
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "INSTANCE")) |
if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE")) |
return false; | return false; |
| |
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
|
|
String className = getClassNameAttribute( | String className = getClassNameAttribute( |
parser.getLine(), entry, "INSTANCE"); | parser.getLine(), entry, "INSTANCE"); |
| |
cimInstance = CIMInstance(className); | cimInstance = CIMInstance(className); |
| |
|
if (!empty) |
|
{ |
// Get QUALIFIER elements: | // Get QUALIFIER elements: |
|
|
getQualifierElements(parser, cimInstance); | getQualifierElements(parser, cimInstance); |
| |
// Get PROPERTY elements: | // Get PROPERTY elements: |
|
|
GetPropertyElements(parser, cimInstance); | GetPropertyElements(parser, cimInstance); |
| |
// Get INSTANCE end tag: | // Get INSTANCE end tag: |
|
|
expectEndTag(parser, "INSTANCE"); | expectEndTag(parser, "INSTANCE"); |
|
} |
| |
return true; | return true; |
} | } |
|
|
| |
if (!getInstanceNameElement(parser, instanceName)) | if (!getInstanceNameElement(parser, instanceName)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCENAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT", |
"expected INSTANCENAME element"); | "expected INSTANCENAME element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
// Get INSTANCE elements: | // Get INSTANCE elements: |
| |
if (!getInstanceElement(parser, namedInstance)) | if (!getInstanceElement(parser, namedInstance)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCE element"); |
|
|
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"expected INSTANCE element"); | "expected INSTANCE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
// Get VALUE.NAMEDINSTANCE end tag: | // Get VALUE.NAMEDINSTANCE end tag: |
|
|
{ | { |
if (!getClassElement(parser, x)) | if (!getClassElement(parser, x)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT", |
"expected CLASS element"); | "expected CLASS element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
{ | { |
if (!getInstanceElement(parser, x)) | if (!getInstanceElement(parser, x)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"expected INSTANCE element"); | "expected INSTANCE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
{ | { |
if (!getQualifierDeclElement(parser, x)) | if (!getQualifierDeclElement(parser, x)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected QUALIFIER.DECLARATION element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT", |
"expected QUALIFIER.DECLARATION element"); | "expected QUALIFIER.DECLARATION element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
| |
// Get MESSAGE.ID: | // Get MESSAGE.ID: |
| |
if (!entry.getAttributeValue("ID", id)) |
if (!entry.getAttributeValue("ID", id)) { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Invalid or missing MESSAGE.ID attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE", |
"Invalid or missing MESSAGE.ID attribute"); | "Invalid or missing MESSAGE.ID attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
|
// Get MESSAGE.PROTOCOLVERSION: | // Get MESSAGE.PROTOCOLVERSION: |
| |
if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) |
if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE", |
"Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); | "Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
return true; | return true; |
} | } |
| |
|
|
| |
// Get IMETHODCALL.NAME attribute: | // Get IMETHODCALL.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing IMETHODCALL.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE", |
"Missing IMETHODCALL.NAME attribute"); | "Missing IMETHODCALL.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
|
return true; | return true; |
} | } |
| |
|
|
| |
Boolean XmlReader::getIMethodResponseStartTag( | Boolean XmlReader::getIMethodResponseStartTag( |
XmlParser& parser, | XmlParser& parser, |
const char*& name) |
const char*& name, |
|
Boolean& isEmptyTag) |
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "IMETHODRESPONSE")) |
if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE")) |
return false; | return false; |
| |
|
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG); |
|
|
// Get IMETHODRESPONSE.NAME attribute: | // Get IMETHODRESPONSE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
if (!entry.getAttributeValue("NAME", name)) { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing IMETHODRESPONSE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE", |
"Missing IMETHODRESPONSE.NAME attribute"); | "Missing IMETHODRESPONSE.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
|
return true; | return true; |
} | } |
| |
|
|
| |
Boolean XmlReader::getIParamValueTag( | Boolean XmlReader::getIParamValueTag( |
XmlParser& parser, | XmlParser& parser, |
const char*& name) |
const char*& name, |
|
Boolean& isEmptyTag) |
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "IPARAMVALUE")) |
if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE")) |
return false; | return false; |
| |
|
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG); |
|
|
// Get IPARAMVALUE.NAME attribute: | // Get IPARAMVALUE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
if (!entry.getAttributeValue("NAME", name)) { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing IPARAMVALUE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE", |
"Missing IPARAMVALUE.NAME attribute"); | "Missing IPARAMVALUE.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
return true; | return true; |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// rejectNullIParamValue() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void XmlReader::rejectNullIParamValue( |
|
XmlParser& parser, |
|
Boolean isEmptyTag, |
|
const char* paramName) |
|
{ |
|
if (isEmptyTag) |
|
{ |
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE", |
|
"A null value is not valid for IPARAMVALUE \"$0\".", |
|
paramName); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
// getBooleanValueElement() | // getBooleanValueElement() |
// | // |
// Get an elements like: "<VALUE>FALSE</VALUE>" | // Get an elements like: "<VALUE>FALSE</VALUE>" |
|
|
{ | { |
if (required) | if (required) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected VALUE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
"Expected VALUE element"); | "Expected VALUE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
return false; | return false; |
} | } |
|
|
result = true; | result = true; |
else if (System::strcasecmp(entry.text, "FALSE") == 0) | else if (System::strcasecmp(entry.text, "FALSE") == 0) |
result = false; | result = false; |
else |
else { |
throw XmlSemanticError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT", |
"Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); | "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); |
| |
|
throw XmlSemanticError(parser.getLine(), mlParms); |
|
} |
|
|
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
| |
return true; | return true; |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// getErrorElement() |
// DMTF CR Pending |
// | // |
// <!ELEMENT ERROR EMPTY> |
// <!ELEMENT ERROR (INSTANCE*)> |
// <!ATTLIST ERROR | // <!ATTLIST ERROR |
// CODE CDATA #REQUIRED | // CODE CDATA #REQUIRED |
// DESCRIPTION CDATA #IMPLIED> | // DESCRIPTION CDATA #IMPLIED> |
|
|
| |
if (!testStartTagOrEmptyTag(parser, entry, "ERROR")) | if (!testStartTagOrEmptyTag(parser, entry, "ERROR")) |
{ | { |
if (required) |
if (required) { |
throw XmlValidationError(parser.getLine(),"Expected ERROR element"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(),"Expected ERROR element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ERROR_ELEMENT", |
|
"Expected ERROR element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
} |
return false; | return false; |
} | } |
| |
|
|
| |
Uint32 tmpCode; | Uint32 tmpCode; |
| |
if (!entry.getAttributeValue("CODE", tmpCode)) |
if (!entry.getAttributeValue("CODE", tmpCode)) { |
throw XmlValidationError( |
|
parser.getLine(), "missing ERROR.CODE attribute"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "missing ERROR.CODE attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE", |
|
"missing ERROR.CODE attribute"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
} |
| |
// Get ERROR.DESCRIPTION: | // Get ERROR.DESCRIPTION: |
| |
|
|
entry.getAttributeValue("DESCRIPTION", tmpDescription); | entry.getAttributeValue("DESCRIPTION", tmpDescription); |
| |
if (!empty) | if (!empty) |
|
{ |
|
while (testStartTagOrEmptyTag(parser, entry)) |
|
{ |
|
skipElement(parser, entry); |
|
} |
|
|
expectEndTag(parser, "ERROR"); | expectEndTag(parser, "ERROR"); |
|
} |
| |
cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription); | cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription); |
return true; | return true; |
|
|
{ | { |
object = CIMObject(cimInstance); | object = CIMObject(cimInstance); |
} | } |
else if (!XmlReader::getClassElement(parser, cimClass)) |
else if (XmlReader::getClassElement(parser, cimClass)) |
{ | { |
object = CIMObject(cimClass); | object = CIMObject(cimClass); |
} | } |
else | else |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCE or CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT", |
"Expected INSTANCE or CLASS element"); | "Expected INSTANCE or CLASS element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
expectEndTag(parser, "VALUE.OBJECT"); | expectEndTag(parser, "VALUE.OBJECT"); |
|
|
isInstance = true; | isInstance = true; |
else if (!XmlReader::getClassPathElement(parser, reference)) | else if (!XmlReader::getClassPathElement(parser, reference)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n 485 |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCEPATH or CLASSPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT", |
"Expected INSTANCEPATH or CLASSPATH element"); | "Expected INSTANCEPATH or CLASSPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
if (isInstance) | if (isInstance) |
|
|
| |
if (!XmlReader::getInstanceElement(parser, cimInstance)) | if (!XmlReader::getInstanceElement(parser, cimInstance)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"Expected INSTANCE element"); | "Expected INSTANCE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
objectWithPath = CIMObject (cimInstance); | objectWithPath = CIMObject (cimInstance); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
| |
if (!XmlReader::getClassElement(parser, cimClass)) | if (!XmlReader::getClassElement(parser, cimClass)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT", |
"Expected CLASS element"); | "Expected CLASS element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
objectWithPath = CIMObject (cimClass); | objectWithPath = CIMObject (cimClass); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
isInstance = true; | isInstance = true; |
else if (!XmlReader::getLocalClassPathElement(parser, reference)) | else if (!XmlReader::getLocalClassPathElement(parser, reference)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected LOCALINSTANCEPATH or LOCALCLASSPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element"); |
|
|
|
//l10n updated |
|
MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH", |
|
MISSING_ELEMENT_LOCALPATH); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
if (isInstance) | if (isInstance) |
|
|
| |
if (!XmlReader::getInstanceElement(parser, cimInstance)) | if (!XmlReader::getInstanceElement(parser, cimInstance)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"Expected INSTANCE element"); | "Expected INSTANCE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
objectWithPath = CIMObject (cimInstance); | objectWithPath = CIMObject (cimInstance); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
| |
if (!XmlReader::getClassElement(parser, cimClass)) | if (!XmlReader::getClassElement(parser, cimClass)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT", |
"Expected CLASS element"); | "Expected CLASS element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
|
} | } |
objectWithPath = CIMObject (cimClass); | objectWithPath = CIMObject (cimClass); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
return true; | return true; |
else | else |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected CLASSNAME or INSTANCENAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME or INSTANCENAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT", |
|
"Expected CLASSNAME or INSTANCENAME element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
return false; | return false; |
|
|
} | } |
else | else |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCEPATH or CLASSPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT", |
"expected INSTANCEPATH or CLASSPATH element"); | "expected INSTANCEPATH or CLASSPATH element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
PEGASUS_UNREACHABLE ( return false; ) | PEGASUS_UNREACHABLE ( return false; ) |
|
|
| |
// Get EXPMETHODCALL.NAME attribute: | // Get EXPMETHODCALL.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing EXPMETHODCALL.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE", |
"Missing EXPMETHODCALL.NAME attribute"); | "Missing EXPMETHODCALL.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
return true; | return true; |
} | } |
| |
|
|
| |
Boolean XmlReader::getEMethodResponseStartTag( | Boolean XmlReader::getEMethodResponseStartTag( |
XmlParser& parser, | XmlParser& parser, |
const char*& name) |
const char*& name, |
|
Boolean& isEmptyTag) |
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "EXPMETHODRESPONSE")) |
if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE")) |
return false; | return false; |
| |
|
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG); |
|
|
// Get EXPMETHODRESPONSE.NAME attribute: | // Get EXPMETHODRESPONSE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
|
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE", |
"Missing EXPMETHODRESPONSE.NAME attribute"); | "Missing EXPMETHODRESPONSE.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// getEParamValueTag() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::getEParamValueTag( |
|
XmlParser& parser, |
|
const char*& name) |
|
{ |
|
XmlEntry entry; |
|
|
|
if (!testStartTag(parser, entry, "EXPPARAMVALUE")) |
|
return false; |
|
|
|
// Get EXPPARAMVALUE.NAME attribute: |
|
|
|
|
|
if (!entry.getAttributeValue("NAME", name)) { |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing EXPPARAMVALUE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE", |
|
"Missing EXPPARAMVALUE.NAME attribute"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
|
|
|
return true; | return true; |
} | } |
| |
|
|
| |
// Get METHODCALL.NAME attribute: | // Get METHODCALL.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing METHODCALL.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE", |
"Missing METHODCALL.NAME attribute"); | "Missing METHODCALL.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
|
return true; | return true; |
} | } |
| |
|
|
| |
Boolean XmlReader::getMethodResponseStartTag( | Boolean XmlReader::getMethodResponseStartTag( |
XmlParser& parser, | XmlParser& parser, |
const char*& name) |
const char*& name, |
|
Boolean& isEmptyTag) |
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "METHODRESPONSE")) |
if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE")) |
return false; | return false; |
| |
|
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG); |
|
|
// Get METHODRESPONSE.NAME attribute: | // Get METHODRESPONSE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing METHODRESPONSE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE", |
"Missing METHODRESPONSE.NAME attribute"); | "Missing METHODRESPONSE.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
return true; | return true; |
} | } |
| |
|
|
{ | { |
XmlEntry entry; | XmlEntry entry; |
const char* name; | const char* name; |
CIMType type; |
CIMType type=CIMTYPE_BOOLEAN; |
CIMValue value; | CIMValue value; |
| |
if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE")) | if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE")) |
|
|
| |
// Get PARAMVALUE.NAME attribute: | // Get PARAMVALUE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
if (!entry.getAttributeValue("NAME", name)) { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing PARAMVALUE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE", |
"Missing PARAMVALUE.NAME attribute"); | "Missing PARAMVALUE.NAME attribute"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
|
// Get PARAMVALUE.PARAMTYPE attribute: | // Get PARAMVALUE.PARAMTYPE attribute: |
| |
Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type, | Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type, |
|
|
} | } |
else if (type == CIMTYPE_REFERENCE) | else if (type == CIMTYPE_REFERENCE) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected VALUE.REFERENCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT", |
"expected VALUE.REFERENCE element"); | "expected VALUE.REFERENCE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
| |
if ( !XmlReader::getValueElement(parser, type, returnValue) ) | if ( !XmlReader::getValueElement(parser, type, returnValue) ) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected VALUE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
"expected VALUE element"); | "expected VALUE element"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
|
|