pegasus/src/Pegasus/Common/XmlReader.cpp - diff

Return to XmlReader.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlReader.cpp between version 1.81.4.1 and 1.124

version 1.81.4.1, 2003/03/11 19:56:55

version 1.124, 2007/03/20 17:22:59

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 21

Line 29

//==============================================================================

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>

#include <errno.h>

#include <cctype>

#include <cstdio>

#include <cstdlib>

#if defined(PEGASUS_OS_TYPE_UNIX)

#if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)

#include <errno.h>

#endif

#include "CIMName.h"

Line 46

Line 48

#include "CIMObject.h"

#include "CIMParamValue.h"

#include "System.h"

#include "XmlConstants.h"

#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM

# include "EBCDIC_OS400.h"

#endif

#include <Pegasus/Common/MessageLoader.h>

#include <Pegasus/Common/AutoPtr.h>

#include "CIMNameUnchecked.h"

#define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))

#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)

Line 74

Line 84

entry.type != XmlEntry::XML_DECLARATION ||

strcmp(entry.text, "xml") != 0)

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_XML_STYLE",

"Expected <?xml ... ?> style declaration");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (!entry.getAttributeValue("version", xmlVersion))

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))

{

Line 124

Line 140

entry.type != XmlEntry::START_TAG ||

strcmp(entry.text, tagName) != 0)

{

char message[MESSAGE_SIZE];

MessageLoaderParms mlParms(

sprintf(message, "Expected open of %s element", tagName);

"Common.XmlReader.EXPECTED_OPEN",

throw XmlValidationError(parser.getLine(), message);

"Expected open of $0 element",

tagName);

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 144

Line 162

entry.type != XmlEntry::END_TAG ||

strcmp(entry.text, tagName) != 0)

{

char message[MESSAGE_SIZE];

MessageLoaderParms mlParms(

sprintf(message, "Expected close of %s element, got %s instead",

"Common.XmlReader.EXPECTED_CLOSE",

"Expected close of $0 element, got $1 instead",

tagName,entry.text);

throw XmlValidationError(parser.getLine(), message);

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 167

Line 186

entry.type != XmlEntry::EMPTY_TAG) ||

strcmp(entry.text, tagName) != 0)

{

char message[MESSAGE_SIZE];

MessageLoaderParms mlParms(

sprintf(message,

"Common.XmlReader.EXPECTED_OPENCLOSE",

"Expected either open or open/close %s element", tagName);

"Expected either open or open/close $0 element",

throw XmlValidationError(parser.getLine(), message);

tagName);

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 188

Line 208

(entry.type != XmlEntry::CONTENT &&

entry.type != XmlEntry::CDATA))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CDATA",

"Expected content of CDATA");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

Line 263

Line 285

//------------------------------------------------------------------------------

// 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()

//------------------------------------------------------------------------------

Line 302

Line 345

XmlReader::expectStartTag(parser, entry, "CIM");

if (!entry.getAttributeValue("CIMVERSION", cimVersion))

throw XmlValidationError(

{

parser.getLine(), "missing CIM.CIMVERSION attribute");

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",

"missing CIM.CIMVERSION attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (!entry.getAttributeValue("DTDVERSION", dtdVersion))

throw XmlValidationError(

{

parser.getLine(), "missing CIM.DTDVERSION attribute");

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",

"missing CIM.DTDVERSION attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

//------------------------------------------------------------------------------

Line 329

Line 380

if (!entry.getAttributeValue("NAME", name))

{

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)

Line 339

Line 395

if (!CIMName::legal(name))

{

#ifdef PEGASUS_SNIA_INTEROP_TEST

// This is not a Pegasus BUG. It is a hack to protect against an error

// from some servers. In particular, the SNIA IBM server seems to be

// sending a namespace component with "" as the string. We cannot handle

// this. This is probably because they are using the form /root/...

// In testing, replace illegal CIMName with this value to avoid the

// exception and let xml parsing continue. THIS IS TEMP.

name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT";

#else

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 CIMNameUnchecked(name);

}

//------------------------------------------------------------------------------

Line 373

Line 433

if (!entry.getAttributeValue("CLASSNAME", name))

{

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))

{

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;

Line 406

Line 476

if (!entry.getAttributeValue("CLASSORIGIN", name))

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))

{

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;

Line 425

Line 493

//------------------------------------------------------------------------------

// getEmbeddedObjectAttribute()

// <!ENTITY % EmbeddedObject "EMBEDDEDOBJECT (object | instance) #IMPLIED">

//------------------------------------------------------------------------------

String XmlReader::getEmbeddedObjectAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

{

String embeddedObject;

if (!entry.getAttributeValue("EMBEDDEDOBJECT", embeddedObject))

return String();

// The embeddedObject attribute, if present, must have the string

// value "object" or "instance".

if (!(String::equal(embeddedObject, "object") ||

String::equal(embeddedObject, "instance")))

{

char buffer[MESSAGE_SIZE];

sprintf(buffer, "%s.EMBEDDEDOBJECT", elementName);

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return embeddedObject;

}

//------------------------------------------------------------------------------

// getReferenceClassAttribute()

// <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">

Line 447

Line 551

name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";

return name;

#endif

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;

Line 477

Line 586

if (!CIMName::legal(superClass))

{

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;

Line 518

Line 631

if (required)

{

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

{

Line 560

Line 678

type = CIMTYPE_REAL64;

else if (strcmp(typeName, "reference") == 0)

type = CIMTYPE_REFERENCE;

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a

// Pegasus internal representation of an embedded object, so it won't be

// found here.

else unrecognizedType = true;

if (unrecognizedType ||

((type == CIMTYPE_REFERENCE) &&

(strcmp(attributeName, "PARAMTYPE") != 0)))

{

char message[MESSAGE_SIZE];

char buffer[MESSAGE_SIZE];

sprintf(message, "Illegal value for %s.%s attribute", tagName,

sprintf(buffer, "%s.%s", tagName, attributeName);

attributeName);

throw XmlSemanticError(lineNumber, message);

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

cimType = type;

Line 598

Line 725

return defaultValue;

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)

Line 610

Line 740

return false;

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;

}

Line 699

Line 836

return true;

}

inline Uint8 _hexCharToNumeric(const char c)

inline Uint8 _xmlReader_hexCharToNumeric(const char c)

{

Uint8 n;

Line 714

Line 851

}

// 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)

{

String decodedString;

Uint32 i;

Array<Uint8> utf8Chars;

for (i=0; i<uriString.size(); i++)

{

if (uriString[i] == '%')

{

if (i+2 >= uriString.size())

{

throw ParseError("Invalid URI encoding");

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_URI_ENCODING",

"Invalid URI encoding");

throw ParseError(MessageLoader::getMessage(mlParms));

}

Uint8 digit1 = _hexCharToNumeric(char(uriString[++i]));

Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i]));

Uint8 digit2 = _hexCharToNumeric(char(uriString[++i]));

Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i]));

if ( (digit1 > 15) || (digit2 > 15) )

{

throw ParseError("Invalid URI encoding");

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_URI_ENCODING",

"Invalid URI encoding");

throw ParseError(MessageLoader::getMessage(mlParms));

}

// ATTN: Handle non-UTF-8 character sets

Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);

decodedString.append(Char16(decodedChar));

utf8Chars.append((Uint8)decodedChar);

}

else

{

decodedString.append(uriString[i]);

utf8Chars.append((Uint8)uriString[i]);

}

return decodedString;

// 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();

}

//------------------------------------------------------------------------------

Line 802

Line 958

x = x << 4;

// 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)

{

return false;

Line 922

Line 1078

x = x << 4;

// 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)

{

return false;

Line 999

Line 1155

else if (System::strcasecmp(valueString, "FALSE") == 0)

return CIMValue(false);

else

throw XmlSemanticError(

{

lineNumber, "Invalid boolean value");

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_BOOLEAN_VALUE",

"Invalid boolean value");

throw XmlSemanticError(lineNumber, mlParms);

}

case CIMTYPE_STRING:

Line 1010

Line 1170

case CIMTYPE_CHAR16:

{

// remove this test, utf-8 can be up to 6 bytes per char

if (strlen(valueString) != 1)

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)

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_CHAR16_VALUE",

"Invalid char16 value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Char16(valueString[0]));

return CIMValue(tmp[0]);

}

case CIMTYPE_UINT8:

Line 1025

Line 1203

if (!stringToUnsignedInteger(valueString, x))

{

char message[128];

MessageLoaderParms mlParms(

sprintf(message, "Illegal unsigned integer value - %s", valueString);

"Common.XmlReader.INVALID_UI_VALUE",

throw XmlSemanticError(

"Invalid unsigned integer value");

lineNumber, message);

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

Line 1037

Line 1215

{

if (x >= (Uint64(1)<<8))

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Uint8 value out of range");

"Common.XmlReader.U8_VALUE_OUT_OF_RANGE",

"Uint8 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint8(x));

}

Line 1046

Line 1226

{

if (x >= (Uint64(1)<<16))

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Uint16 value out of range");

"Common.XmlReader.U16_VALUE_OUT_OF_RANGE",

"Uint16 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint16(x));

}

Line 1055

Line 1237

{

if (x >= (Uint64(1)<<32))

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Uint32 value out of range");

"Common.XmlReader.U32_VALUE_OUT_OF_RANGE",

"Uint32 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint32(x));

}

Line 1074

Line 1258

if (!stringToSignedInteger(valueString, x))

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Invalid signed integer value");

"Common.XmlReader.INVALID_SI_VALUE",

"Invalid signed integer value");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

Line 1084

Line 1270

{

if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Sint8 value out of range");

"Common.XmlReader.S8_VALUE_OUT_OF_RANGE",

"Sint8 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint8(x));

}

Line 1093

Line 1281

{

if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Sint16 value out of range");

"Common.XmlReader.S16_VALUE_OUT_OF_RANGE",

"Sint16 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint16(x));

}

Line 1102

Line 1292

{

if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Sint32 value out of range");

"Common.XmlReader.S32_VALUE_OUT_OF_RANGE",

"Sint32 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint32(x));

}

Line 1118

Line 1310

try

{

// KS 20021002 - Exception if no datatime value. Test for

// KS 20021002 - Exception if no datetime value. Test for

// zero length and leave the NULL value in the variable

// Bugzilla 137 Adds the following if line.

// Expect this to become permanent but test only for now

Line 1129

Line 1321

}

catch (InvalidDateTimeFormatException&)

{

throw XmlSemanticError(lineNumber, "Invalid datetime value");

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_DATETIME_VALUE",

"Invalid datetime value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(tmp);

Line 1140

Line 1335

Real64 x;

if (!stringToReal(valueString, x))

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));

}

Line 1150

Line 1349

Real64 x;

if (!stringToReal(valueString, x))

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);

}

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but

// just a Pegasus internal representation of an embedded object. However,

// this case is used when decoding string representations of embedded objects.

case CIMTYPE_OBJECT:

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

{

CIMObject x;

if (*valueString == '\0')

{

return CIMValue(type, false, 0);

}

else

{

// Convert the non-NULL string to a CIMObject (containing

// either a CIMInstance or a CIMClass).

// First we need to create a new "temporary" XmlParser that is

// just the value of the Embedded Object in String

// representation.

AutoArrayPtr<char> tmp_buffer(

new char[strlen(valueString) + 1]);

strcpy(tmp_buffer.get(), valueString);

XmlParser tmp_parser(tmp_buffer.get());

// The next bit of logic constructs a CIMObject from the

// Embedded Object String. It is similar to the method

// XmlReader::getValueObjectElement().

CIMInstance cimInstance;

CIMClass cimClass;

if (XmlReader::getInstanceElement(tmp_parser, cimInstance))

{

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if (type == CIMTYPE_INSTANCE)

return CIMValue(cimInstance);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

x = CIMObject(cimInstance);

}

else if (XmlReader::getClassElement(tmp_parser, cimClass))

{

x = CIMObject(cimClass);

}

else

{

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if (type == CIMTYPE_OBJECT)

{

// change "element" to "embedded object"

MessageLoaderParms mlParms(

"Common.XmlReader."

"EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element");

throw XmlValidationError(lineNumber, mlParms);

}

else

{

// change "element" to "embedded object"

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

throw XmlValidationError(lineNumber, mlParms);

}

#else

// change "element" to "embedded object"

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element");

throw XmlValidationError(lineNumber, mlParms);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

}

// Ok, now we can delete the storage for the temporary

// XmlParser.

tmp_buffer.reset();

}

return CIMValue(x);

}

Line 1159

Line 1443

break;

}

throw XmlSemanticError(lineNumber, "malformed XML");

MessageLoaderParms mlParms(

"Common.XmlReader.MALFORMED_XML",

"malformed XML");

throw XmlSemanticError(lineNumber, mlParms);

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()

// <!ELEMENT VALUE (#PCDATA)>

Line 1182

Line 1500

XmlEntry entry;

if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

return false;

}

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

Line 1191

Line 1511

if (!empty)

{

if (testContentOrCData(parser, entry))

{

valueString = entry.text;

}

expectEndTag(parser, "VALUE");

}

Line 1225

Line 1547

if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

if (required)

throw XmlValidationError(parser.getLine(),"Expected VALUE element");

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

}

Line 1241

Line 1568

expectEndTag(parser, "VALUE");

}

str = valueString;

str = String(valueString);

return true;

}

Line 1370

Line 1697

return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);

case CIMTYPE_DATETIME:

return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);

return StringArrayToValueAux(

lineNumber, array, type, (CIMDateTime*)0);

case CIMTYPE_REAL32:

return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);

Line 1378

Line 1706

case CIMTYPE_REAL64:

return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but

// just a Pegasus internal representation of an embedded object. However,

// this case is used when decoding string representations of embedded objects.

case CIMTYPE_OBJECT:

return StringArrayToValueAux(

lineNumber, array, type, (CIMObject*)0);

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

return StringArrayToValueAux(

lineNumber, array, type, (CIMInstance*)0);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

break;

}

Line 1587

Line 1928

// Get QUALIFIER element:

XmlEntry entry;

if (!testStartTag(parser, entry, "QUALIFIER"))

if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER"))

return false;

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

// Get QUALIFIER.NAME attribute:

CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");

Line 1612

Line 1955

CIMValue value;

if (empty)

{

value.setNullValue(type, false);

}

else

{

if (!getValueElement(parser, type, value) &&

!getValueArrayElement(parser, type, value))

{

Line 1621

Line 1970

// Expect </QUALIFIER>:

expectEndTag(parser, "QUALIFIER");

}

// Build qualifier:

Line 1647

Line 1997

}

catch (AlreadyExistsException&)

{

throw XmlSemanticError(parser.getLine(), "duplicate qualifier");

MessageLoaderParms mlParms(

"Common.XmlReader.DUPLICATE_QUALIFIER",

"duplicate qualifier");

throw XmlSemanticError(parser.getLine(), mlParms);

}

Line 1661

Line 2014

// %CIMName;

// %ClassOrigin;

// %Propagated;

// %EmbeddedObject; #IMPLIED

// %CIMType; #REQUIRED>

//------------------------------------------------------------------------------

Line 1688

Line 2042

Boolean propagated = getCimBooleanAttribute(

parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);

// Get PROPERTY.EMBEDDEDOBJECT attribute:

String embeddedObject = getEmbeddedObjectAttribute(

parser.getLine(), entry, "PROPERTY");

// Get PROPERTY.TYPE attribute:

CIMType type;

Line 1700

Line 2059

if (!empty)

{

// Get qualifiers:

// Get qualifiers. We need to do this before checking for the

// property as an embedded object, because we need to also check

// for the EmbeddedObject qualifier.

getQualifierElements(parser, property);

}

// Get value: Insert value if getValueElement exists (returns True)

Boolean embeddedObjectQualifierValue = false;

Uint32 ix = property.findQualifier(CIMName("EmbeddedObject"));

if (ix != PEG_NOT_FOUND)

{

property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

String embeddedInstanceQualifierValue;

ix = property.findQualifier(CIMName("EmbeddedInstance"));

if (ix != PEG_NOT_FOUND)

{

property.getQualifier(ix).getValue().get(

embeddedInstanceQualifierValue);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

// If the EMBEDDEDOBJECT attribute is present with value "object"

// or the EmbeddedObject qualifier exists on this property with value "true"

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

// The EMBEDDEDOBJECT attribute is only valid on Properties of type

// string

if (type == CIMTYPE_STRING)

{

if (isEmbeddedObject)

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

CIMValue new_value(type, false);

CIMProperty new_property = CIMProperty(

name, new_value, 0, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject

// property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject

// qualifier. This way we don't have to keep track to know

// that the EmbeddedObject qualifier needs to be added back

// during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#else

if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)

{

// The EMBEDDEDOBJECT attribute is only valid on Properties of type

// string

if (type == CIMTYPE_STRING)

{

type = CIMTYPE_OBJECT;

CIMValue new_value(type, false);

CIMProperty new_property = CIMProperty(

name, new_value, 0, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject

// property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject

// qualifier. This way we don't have to keep track to know

// that the EmbeddedObject qualifier needs to be added back

// during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

// Continue on to get property value, if not empty.

if (!empty)

{

if (getValueElement(parser, type, value))

property.setValue(value);

expectEndTag(parser, "PROPERTY");

}

Line 1742

Line 2198

if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)

{

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);

Line 1760

Line 2221

// %CIMType; #REQUIRED

// %ArraySize;

// %ClassOrigin;

// %Propagated;>

// %Propagated;

// %EmbeddedObject; #IMPLIED>

//------------------------------------------------------------------------------

Line 1794

Line 2256

// Get PROPERTY.CLASSORIGIN attribute:

CIMName classOrigin

CIMName classOrigin =

= getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

// Get PROPERTY.ARRAY.PROPAGATED

Boolean propagated = getCimBooleanAttribute(

parser.getLine(), entry, "PROPERTY.ARRAY", "PROPAGATED", false, false);

parser.getLine(),

entry,

"PROPERTY.ARRAY",

"PROPAGATED",

false,

false);

// Get PROPERTY.EMBEDDEDOBJECT attribute:

String embeddedObject = getEmbeddedObjectAttribute(

parser.getLine(), entry, "PROPERTY.ARRAY");

// Create property:

Line 1811

Line 2283

if (!empty)

{

// Get qualifiers:

getQualifierElements(parser, property);

}

Boolean embeddedObjectQualifierValue = false;

Uint32 ix = property.findQualifier(CIMName("EmbeddedObject"));

if (ix != PEG_NOT_FOUND)

{

property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

String embeddedInstanceQualifierValue;

ix = property.findQualifier(CIMName("EmbeddedInstance"));

if (ix != PEG_NOT_FOUND)

{

property.getQualifier(ix).getValue().get(

embeddedInstanceQualifierValue);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

// If the EMBEDDEDOBJECT attribute is present with value "object"

// or the EmbeddedObject qualifier exists on this property with value "true"

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

// The EMBEDDEDOBJECT attribute is only valid on Properties of type

// string

if (type == CIMTYPE_STRING)

{

if (isEmbeddedObject)

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

CIMValue new_value(type, true, arraySize);

CIMProperty new_property = CIMProperty(

name, new_value, arraySize, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject

// property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject

// qualifier. This way we don't have to keep track to know

// that the EmbeddedObject qualifier needs to be added back

// during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

// Get value:

value = new_value;

property = new_property;

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#else

if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)

{

// The EMBEDDEDOBJECT attribute is only valid on Properties of type

// string

if (type == CIMTYPE_STRING)

{

type = CIMTYPE_OBJECT;

CIMValue new_value(type, true, arraySize);

CIMProperty new_property = CIMProperty(

name, new_value, arraySize, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject

// property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject

// qualifier. This way we don't have to keep track to know

// that the EmbeddedObject qualifier needs to be added back

// during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

// Continue on to get property array value, if not empty.

// Else not an embedded object, if not empty, get the property array value.

if (!empty)

{

if (getValueArrayElement(parser, type, value))

{

if (arraySize && arraySize != value.getArraySize())

{

throw XmlSemanticError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.ARRAY_SIZE_DIFFERENT",

"ARRAYSIZE attribute and value-array size are different");

throw XmlSemanticError(parser.getLine(), mlParms);

}

property.setValue(value);

}

expectEndTag(parser, "PROPERTY.ARRAY");

}

Line 1857

Line 2427

throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());

if (entry.type == XmlEntry::CONTENT)

host = entry.text;

host = String(entry.text);

else

{

parser.putBack(entry);

Line 1868

Line 2438

if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CONTENT_ELEMENT",

"expected content of HOST element");

throw XmlValidationError(parser.getLine(), mlParms);

}

host = entry.text;

host = String(entry.text);

#endif

expectEndTag(parser, "HOST");

return true;

Line 1936

Line 2508

if (!nameSpace.size())

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",

"Expected one or more NAMESPACE elements within "

"LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

expectEndTag(parser, "LOCALNAMESPACEPATH");

Line 1967

Line 2541

return false;

if (!getHostElement(parser, host))

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))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

expectEndTag(parser, "NAMESPACEPATH");

Line 2000

Line 2581

{

if (required)

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

else

return false;

Line 2043

Line 2626

return CIMKeyBinding::NUMERIC;

char buffer[MESSAGE_SIZE];

sprintf(buffer, "%s.VALUETYPE", elementName);

sprintf(buffer,

MessageLoaderParms mlParms(

"Illegal value for %s.VALUETYPE attribute; "

"Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",

"CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",

"Illegal value for $0 attribute; CIMValue must be one of \"string\", "

elementName);

"\"boolean\", or \"numeric\"",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

throw XmlSemanticError(lineNumber, buffer);

return CIMKeyBinding::BOOLEAN;

}

Line 2085

Line 2670

throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());

if (entry.type == XmlEntry::CONTENT)

value = entry.text;

value = String(entry.text);

else

parser.putBack(entry);

Line 2124

Line 2709

if (!getValueReferenceElement(parser, reference))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",

"Expected KEYVALUE or VALUE.REFERENCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

type = CIMKeyBinding::REFERENCE;

Line 2235

Line 2822

if (!getNameSpacePathElement(parser, host, nameSpace))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

String className;

Line 2244

Line 2833

if (!getInstanceNameElement(parser, className, keyBindings))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(host, nameSpace, className, keyBindings);

Line 2275

Line 2866

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

String className;

Line 2284

Line 2877

if (!getInstanceNameElement(parser, className, keyBindings))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(String(), nameSpace, className, keyBindings);

Line 2316

Line 2911

if (!getNameSpacePathElement(parser, host, nameSpace))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

CIMName className;

if (!getClassNameElement(parser, className))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(host, nameSpace, className);

Line 2355

Line 2954

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

CIMName className;

if (!getClassNameElement(parser, className))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(String(), nameSpace, className);

Line 2399

Line 3002

if (entry.type != XmlEntry::START_TAG &&

entry.type != XmlEntry::EMPTY_TAG)

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Expected one of the following start tags: "

"Common.XmlReader.EXPECTED_START_TAGS",

"CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "

"Expected one of the following start tags: CLASSPATH, "

"LOCALINSTANCEPATH, INSTANCENAME");

"LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, "

"INSTANCENAME");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (strcmp(entry.text, "CLASSPATH") == 0)

Line 2571

Line 3176

}

catch (AlreadyExistsException&)

{

throw XmlSemanticError(parser.getLine(), "duplicate property");

MessageLoaderParms mlParms(

"Common.XmlReader.DUPLICATE_PROPERTY",

"duplicate property");

throw XmlSemanticError(parser.getLine(), mlParms);

}

Line 2754

Line 3362

// Get PARAMETER.ARRAYSIZE attribute:

Uint32 arraySize = 0;

getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.REFARRAY",

getArraySizeAttribute(

arraySize);

parser.getLine(), entry, "PARAMETER.REFARRAY", arraySize);

// Create parameter:

parameter = CIMParameter(name, CIMTYPE_REFERENCE, true, arraySize,

parameter = CIMParameter(

referenceClass);

name, CIMTYPE_REFERENCE, true, arraySize, referenceClass);

if (!empty)

{

Line 2793

Line 3401

}

catch (AlreadyExistsException&)

{

throw XmlSemanticError(parser.getLine(), "duplicate parameter");

MessageLoaderParms mlParms(

"Common.XmlReader.DUPLICATE_PARAMETER",

"duplicate parameter");

throw XmlSemanticError(parser.getLine(), mlParms);

}

Line 2868

Line 3479

{

if (!isArray)

{

throw XmlSemanticError(parser.getLine(),

MessageLoaderParms mlParms(

"VALUE.ARRAY element encountered without "

"Common.XmlReader.ARRAY_WITHOUT_ISARRAY",

"ISARRAY attribute");

"VALUE.ARRAY element encountered without ISARRAY "

"attribute");

throw XmlSemanticError(parser.getLine(), mlParms);

}

if (arraySize && arraySize != value.getArraySize())

{

throw XmlSemanticError(parser.getLine(),

MessageLoaderParms mlParms(

"VALUE.ARRAY size is not the same as "

"Common.XmlReader.ARRAY_SIZE_NOT_SAME",

"ARRAYSIZE attribute");

"VALUE.ARRAY size is not the same as ARRAYSIZE attribute");

throw XmlSemanticError(parser.getLine(), mlParms);

}

gotValue = true;

Line 2886

Line 3500

{

if (isArray)

{

throw XmlSemanticError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",

"ISARRAY attribute used but VALUE element encountered");

throw XmlSemanticError(parser.getLine(), mlParms);

}

gotValue = true;

Line 2933

Line 3549

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");

CIMName name = getCimNameAttribute(parser.getLine(), entry, "METHOD");

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");

getCimTypeAttribute(parser.getLine(), entry, type, "METHOD");

CIMName classOrigin =

getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");

getClassOriginAttribute(parser.getLine(), entry, "METHOD");

Boolean propagated = getCimBooleanAttribute(

parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);

parser.getLine(), entry, "METHOD", "PROPAGATED", false, false);

method = CIMMethod(name, type, classOrigin, propagated);

Line 2973

Line 3589

{

XmlEntry entry;

if (!testStartTag(parser, entry, "CLASS"))

if (!testStartTagOrEmptyTag(parser, entry, "CLASS"))

return false;

CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");

CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");

CIMName superClass =

getSuperClassAttribute(parser.getLine(), entry,"CLASS");

cimClass = CIMClass(name, superClass);

if (entry.type != XmlEntry::EMPTY_TAG)

{

// Get QUALIFIER elements:

getQualifierElements(parser, cimClass);

Line 3000

Line 3619

// Get CLASS end tag:

expectEndTag(parser, "CLASS");

}

return true;

}

Line 3020

Line 3640

{

XmlEntry entry;

if (!testStartTag(parser, entry, "INSTANCE"))

if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))

return false;

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

String className = getClassNameAttribute(

parser.getLine(), entry, "INSTANCE");

cimInstance = CIMInstance(className);

if (!empty)

{

// Get QUALIFIER elements:

getQualifierElements(parser, cimInstance);

// Get PROPERTY elements:

GetPropertyElements(parser, cimInstance);

// Get INSTANCE end tag:

expectEndTag(parser, "INSTANCE");

}

return true;

}

Line 3065

Line 3687

if (!getInstanceNameElement(parser, instanceName))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get INSTANCE elements:

if (!getInstanceElement(parser, namedInstance))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get VALUE.NAMEDINSTANCE end tag:

Line 3096

Line 3722

{

if (!getClassElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"expected CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3111

Line 3739

{

if (!getInstanceElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3126

Line 3756

{

if (!getQualifierDeclElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",

"expected QUALIFIER.DECLARATION element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3150

Line 3782

// Get MESSAGE.ID:

if (!entry.getAttributeValue("ID", id))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",

"Invalid or missing MESSAGE.ID attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get MESSAGE.PROTOCOLVERSION:

if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",

"Invalid or missing MESSAGE.PROTOCOLVERSION attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3179

Line 3820

// Get IMETHODCALL.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",

"Missing IMETHODCALL.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3194

Line 3841

Boolean XmlReader::getIMethodResponseStartTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "IMETHODRESPONSE"))

if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get IMETHODRESPONSE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",

"Missing IMETHODRESPONSE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3218

Line 3873

Boolean XmlReader::getIParamValueTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "IPARAMVALUE"))

if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get IPARAMVALUE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",

"Missing IPARAMVALUE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

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()

// Get an elements like: "<VALUE>FALSE</VALUE>"

Line 3253

Line 3935

{

if (required)

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

}

Line 3266

Line 3950

else if (System::strcasecmp(entry.text, "FALSE") == 0)

result = false;

else

throw XmlSemanticError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",

"Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");

throw XmlSemanticError(parser.getLine(), mlParms);

}

expectEndTag(parser, "VALUE");

Line 3276

Line 3964

//------------------------------------------------------------------------------

// getErrorElement()

// DMTF CR Pending

// <!ELEMENT ERROR EMPTY>

// <!ELEMENT ERROR (INSTANCE*)>

// <!ATTLIST ERROR

// CODE CDATA #REQUIRED

// DESCRIPTION CDATA #IMPLIED>

Line 3295

Line 3983

if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))

{

if (required)

throw XmlValidationError(parser.getLine(),"Expected ERROR element");

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_ERROR_ELEMENT",

"Expected ERROR element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

}

Line 3306

Line 3999

Uint32 tmpCode;

if (!entry.getAttributeValue("CODE", tmpCode))

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:

Line 3315

Line 4012

entry.getAttributeValue("DESCRIPTION", tmpDescription);

cimException =

PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);

if (!empty)

{

CIMInstance instance;

while (getInstanceElement(parser, instance))

{

cimException.addError(instance);

}

expectEndTag(parser, "ERROR");

}

cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);

return true;

}

//------------------------------------------------------------------------------

// getValueObjectElement()

Line 3346

Line 4053

{

object = CIMObject(cimInstance);

}

else if (!XmlReader::getClassElement(parser, cimClass))

else if (XmlReader::getClassElement(parser, cimClass))

{

object = CIMObject(cimClass);

}

else

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

expectEndTag(parser, "VALUE.OBJECT");

Line 3384

Line 4093

isInstance = true;

else if (!XmlReader::getClassPathElement(parser, reference))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"Expected INSTANCEPATH or CLASSPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (isInstance)

Line 3394

Line 4105

if (!XmlReader::getInstanceElement(parser, cimInstance))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

Line 3406

Line 4119

if (!XmlReader::getClassElement(parser, cimClass))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

Line 3442

Line 4157

isInstance = true;

else if (!XmlReader::getLocalClassPathElement(parser, reference))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");

"Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",

MISSING_ELEMENT_LOCALPATH);

throw XmlValidationError(parser.getLine(), mlParms);

}

if (isInstance)

Line 3452

Line 4169

if (!XmlReader::getInstanceElement(parser, cimInstance))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

Line 3464

Line 4183

if (!XmlReader::getClassElement(parser, cimClass))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

Line 3534

Line 4255

return true;

else

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected CLASSNAME or INSTANCENAME element");

"Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",

"Expected CLASSNAME or INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

PEGASUS_UNREACHABLE( return false; )

}

//------------------------------------------------------------------------------

Line 3568

Line 4291

}

else

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"expected INSTANCEPATH or CLASSPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

PEGASUS_UNREACHABLE ( return false; )

Line 3592

Line 4317

// Get EXPMETHODCALL.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",

"Missing EXPMETHODCALL.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3607

Line 4337

Boolean XmlReader::getEMethodResponseStartTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "EXPMETHODRESPONSE"))

if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get EXPMETHODRESPONSE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",

"Missing EXPMETHODRESPONSE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3640

Line 4378

// Get EXPPARAMVALUE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",

"Missing EXPPARAMVALUE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3664

Line 4409

// Get METHODCALL.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",

"Missing METHODCALL.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3679

Line 4430

Boolean XmlReader::getMethodResponseStartTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "METHODRESPONSE"))

if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get METHODRESPONSE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",

"Missing METHODRESPONSE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3702

Line 4461

// <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>

// <!ATTLIST PARAMVALUE

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

//------------------------------------------------------------------------------

Line 3712

Line 4472

{

XmlEntry entry;

const char* name;

CIMType type;

CIMType type=CIMTYPE_BOOLEAN;

CIMValue value;

if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))

Line 3723

Line 4483

// Get PARAMVALUE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",

"Missing PARAMVALUE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get PROPERTY.EMBEDDEDOBJECT

String embeddedObject = getEmbeddedObjectAttribute(

parser.getLine(), entry, "PARAMVALUE");

// Get PARAMVALUE.PARAMTYPE attribute:

Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,

"PARAMVALUE", "PARAMTYPE", false);

if (!empty)

if (empty)

{

gotType = false; // Can't distinguish array and non-array types

}

else

{

// Parse VALUE.REFERENCE and VALUE.REFARRAY type

if ( (type == CIMTYPE_REFERENCE) || !gotType )

Line 3765

Line 4538

effectiveType = type;

}

if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&

// If the EMBEDDEDOBJECT attribute is present with value "object"

!XmlReader::getValueElement(parser, effectiveType, value) )

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object");

Boolean isEmbeddedInstance =

String::equal(embeddedObject, "instance");

if (isEmbeddedObject || isEmbeddedInstance)

{

// The EMBEDDEDOBJECT attribute is only valid on Parameters

// of type string

// The type must have been specified.

if (gotType && (type == CIMTYPE_STRING))

{

if (isEmbeddedObject)

// Used below by getValueElement() or

// getValueArrayElement()

effectiveType = CIMTYPE_OBJECT;

else

effectiveType = CIMTYPE_INSTANCE;

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on "

"string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#else

if (String::equal(embeddedObject, "object"))

{

// The EMBEDDEDOBJECT attribute is only valid on Parameters

// of type string

// The type must have been specified.

if (gotType && (type == CIMTYPE_STRING))

{

// Used below by getValueElement() or getValueArrayElement()

effectiveType = CIMTYPE_OBJECT;

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on "

"string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if (!XmlReader::getValueArrayElement(parser, effectiveType, value)

&& !XmlReader::getValueElement(parser, effectiveType, value))

{

gotType = false; // Can't distinguish array and non-array types

value.clear(); // Isn't necessary; should already be cleared

}

Line 3786

Line 4612

// <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

//------------------------------------------------------------------------------

Line 3801

Line 4628

if (!testStartTag(parser, entry, "RETURNVALUE"))

return false;

// Get PROPERTY.EMBEDDEDOBJECT

String embeddedObject = getEmbeddedObjectAttribute(

parser.getLine(), entry, "RETURNVALUE");

// Get RETURNVALUE.PARAMTYPE attribute:

// NOTE: Array type return values are not allowed (2/20/02)

Line 3819

Line 4651

}

else if (type == CIMTYPE_REFERENCE)

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",

"expected VALUE.REFERENCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3832

Line 4666

// If we don't know what type the value is, read it as a String

type = CIMTYPE_STRING;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object");

Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance");

if (isEmbeddedObject || isEmbeddedInstance)

{

if (gotType && (type == CIMTYPE_STRING))

{

if (isEmbeddedObject)

// Used below by getValueElement() or getValueArrayElement()

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string "

"types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#else

if (String::equal(embeddedObject, "object"))

{

if (gotType && (type == CIMTYPE_STRING))

{

type = CIMTYPE_OBJECT; // Used below by getValueElement()

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string "

"types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if ( !XmlReader::getValueElement(parser, type, returnValue) )

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"expected VALUE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3845

Line 4719

return true;

}

//-----------------------------------------------------------------------------

// The following is a common set of version tests used by the different

// Pegasus Request and Response Decoders

//------------------------------------------------------------------------------

// isSupportedCIMVersion()

// tests for valid CIMVersion number

// Reject cimVersion not in 2.[0-9]+

// CIMXML Secification, Version 2.2 Final, Sect 3.2.1.1

// The CIMVERSION attribute defines the version of the CIM Specification to

// which the XML Document conforms. It MUST be in the form of "M.N". Where

// M is the Major Version of the specification in numeric form and N is the

// minor version of the specification in numeric form. For example, "2.0",

// "2.1". Implementations must only validate the major version as all minor

// versions are backward compatible. Implementations may look at the minor

// version to determine additional capabilites.

//------------------------------------------------------------------------------

Boolean XmlReader::isSupportedCIMVersion(

const char* cimVersion)

{

Boolean cimVersionAccepted = false;

//printf("testCIMVersion %s \n", cimVersion);

if ((cimVersion[0] == '2') &&

(cimVersion[1] == '.') &&

(cimVersion[2] != 0))

{

// Verify that all characters after the '.' are digits

Uint32 index = 2;

while (isdigit(cimVersion[index]))

{

index++;

}

if (cimVersion[index] == 0)

{

cimVersionAccepted = true;

}

return cimVersionAccepted;

}

//------------------------------------------------------------------------------

// isSupportedProtocolVersion()

// tests for valid ProtocolVersion number

// Reject ProtocolVersion not 1.[0-9]

// cimxml spec 2.2 Final Section 3261

// The PROTOCOLVERSION attribute defines the version of the CIM Operations to

// which this message conforms. It MUST be in the form of "M.N". Where M is

// the Major Version of the specification in numeric form and N is the minor

// version of the specification in numeric form. For example, "1.0", "1.1".

// Implementations must only validate the major version as all minor versions

// are backward compatible. Implementations may look at the minor version to

// determine additional capabilites.

//------------------------------------------------------------------------------

Boolean XmlReader::isSupportedProtocolVersion(

const String& protocolVersion)

{

Boolean protocolVersionAccepted = false;

//cout << "testProtocolVersion " << protocolVersion << endl;

if ((protocolVersion.size() >= 3) &&

(protocolVersion[0] == '1') &&

(protocolVersion[1] == '.'))

{

// Verify that all characters after the '.' are digits

Uint32 index = 2;

while ((index < protocolVersion.size()) &&

(protocolVersion[index] >= '0') &&

(protocolVersion[index] <= '9'))

{

index++;

}

if (index == protocolVersion.size())

{

protocolVersionAccepted = true;

}

return protocolVersionAccepted;

}

//------------------------------------------------------------------------------

// isSupportedDTDVersion()

// Tests for Valid dtdVersion number

// We accept DTD version 2.[0-9]+ (see Bugzilla 1556)//

// CIM/XML Specification, V 2.2 Final, Section 3.2.1.1

// The DTDVERSION attribute defines the version of the CIM XML Mapping to

// which the XML Document conforms. It MUST be in the form of "M.N". Where

// M is the Major Version of the specification in numeric form and N is the

// minor version of the specification in numeric form. For example, "2.0",

// "2.1". Implementations must only validate the major version as all minor

// versions are backward compatible. Implementations may look at the minor

// version to determine additional capabilites.

//------------------------------------------------------------------------------

Boolean XmlReader::isSupportedDTDVersion(

const char* dtdVersion)

{

Boolean dtdVersionAccepted = false;

//printf("testDTDVersion %s \n", dtdVersion);

if ((dtdVersion[0] == '2') &&

(dtdVersion[1] == '.') &&

(dtdVersion[2] != 0))

{

// Verify that all characters after the '.' are digits

Uint32 index = 2;

while (isdigit(dtdVersion[index]))

{

index++;

}

if (dtdVersion[index] == 0)

{

dtdVersionAccepted = true;

}

return dtdVersionAccepted;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.81.4.1
changed lines
	Added in v.1.124

No CVS admin address has been configured