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.110 and 1.136

version 1.110, 2005/03/09 21:02:26

version 1.136, 2008/12/01 17:49:57

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

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

// License.

// EMC Corporation; VERITAS Software 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"),

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

// to deal in the Software without restriction, including without limitation

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

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// deal in the Software without restriction, including without limitation the

// and/or sell copies of the Software, and to permit persons to whom the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// Software is furnished to do so, subject to the following conditions:

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

//////////////////////////////////////////////////////////////////////////

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

// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)

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

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Constants.h>

#include <errno.h>

#include <cctype>

#include <cstdio>

#include <cstdlib>

Line 44

Line 38

#include <errno.h>

#endif

#include "CIMName.h"

#include "CIMNameCast.h"

#include "XmlReader.h"

#include "XmlWriter.h"

#include "CIMQualifier.h"

Line 54

Line 49

#include "CIMParamValue.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))

#include <Pegasus/Common/MessageLoader.h>

#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)

#include <Pegasus/Common/StringConversion.h>

#include <Pegasus/Common/AutoPtr.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

Line 87

Line 78

entry.type != XmlEntry::XML_DECLARATION ||

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_XML_STYLE",

// throw XmlValidationError(parser.getLine(),

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

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",

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

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

}

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_XML_ATTRIBUTE",

// throw XmlValidationError(

// parser.getLine(), "missing xml.version attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_XML_ATTRIBUTE",

"missing xml.version attribute");

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

}

Line 155

Line 134

entry.type != XmlEntry::START_TAG ||

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_OPEN",

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

}

Line 183

Line 156

entry.type != XmlEntry::END_TAG ||

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CLOSE",

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

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

}

Line 215

Line 180

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_OPENCLOSE",

// char message[MESSAGE_SIZE];

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

}

Line 244

Line 202

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

entry.type != XmlEntry::CDATA))

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CDATA",

// throw XmlValidationError(parser.getLine(),

// "Expected content of CDATA");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",

"Expected content of CDATA");

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

}

return true;

Line 386

Line 338

XmlEntry entry;

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

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",

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

Line 369

const char* elementName,

Boolean acceptNull)

{

String name;

const char* 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];

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

if (acceptNull && name.size() == 0)

if (acceptNull && *name == '\0')

return CIMName ();

Uint32 size = CIMNameLegalASCII(name);

if (size)

{

String tmp(name, size);

return CIMName(CIMNameCast(tmp));

}

if (!CIMName::legal(name))

{

#ifdef PEGASUS_SNIA_INTEROP_TEST

Line 458

Line 402

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

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

Line 475

Line 414

#endif

}

return CIMName (name);

return CIMNameCast(name);

}

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

Line 495

Line 435

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

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

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

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return name;

Line 557

Line 481

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

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

// The CIMName was already checked with legal() + String()

return name;

return CIMNameCast(name);

}

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

// getEmbeddedObjectAttribute()

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

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

// EmbeddedObjectAttributeType:

// NO_EMBEDDED_OBJECT = 0,

// EMBEDDED_OBJECT_ATTR = 1,

// EMBEDDED_INSTANCE_ATTR = 2

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

String XmlReader::getEmbeddedObjectAttribute(

XmlReader::EmbeddedObjectAttributeType XmlReader::getEmbeddedObjectAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

const char* tagName)

{

String embeddedObject;

const char* embeddedObject;

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

// Check for both upper case and mixed case "EmbeddedObject"

return String();

// because of an error in an earlier pegasus version where we

// used upper case in the generation of the attribute name

// whereas the DMTF spec calls for mixed case.

if (!entry.getAttributeValue("EmbeddedObject", embeddedObject) &&

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

return NO_EMBEDDED_OBJECT;

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

// value "object" or "instance".

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

if (strcmp(embeddedObject, "object") == 0)

String::equal(embeddedObject, "instance")

{

)

return EMBEDDED_OBJECT_ATTR;

)

}

{

// l10n

if (strcmp(embeddedObject, "instance") == 0)

{

// char buffer[MESSAGE_SIZE];

return EMBEDDED_INSTANCE_ATTR;

// sprintf(buffer,

}

// "Illegal value for %s.EMBEDDEDOBJECT attribute", elementName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

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

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return NO_EMBEDDED_OBJECT;

return embeddedObject;

}

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

Line 648

Line 571

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

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

// The CIMName was already checked with legal() + String()

return name;

return CIMNameCast(name);

}

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

Line 688

Line 604

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

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

// The CIMName was already checked with legal() + String()

return superClass;

return CIMNameCast(superClass);

}

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

Line 741

Line 649

{

if (required)

{

// l10n

// char message[MESSAGE_SIZE];

// sprintf(message, "missing %s.%s attribute", tagName, attributeName);

// throw XmlValidationError(lineNumber, message);

char message[MESSAGE_SIZE];

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

message);

throw XmlValidationError(lineNumber, mlParms);

}

else

{

Line 799

Line 699

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.

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

{

// l10n

// char message[MESSAGE_SIZE];

// 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",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

Line 848

Line 743

if (!required)

return defaultValue;

// l10n

char buffer[MESSAGE_SIZE];

// char buffer[62];

// sprintf(buffer, "missing required %s.%s attribute",

// attributeName, tagName);

// throw XmlValidationError(lineNumber, buffer);

char buffer[62];

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",

"missing required $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

Line 871

Line 758

else if (strcmp(tmp, "false") == 0)

return false;

// l10n

char buffer[MESSAGE_SIZE];

// char buffer[62];

// sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[62];

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_ATTRIBUTE",

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_ATTRIBUTE",

"Invalid $0 attribute value",

buffer);

Line 889

Line 771

return false;

}

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

// SringToReal()

// [ "+" | "-" ] *decimalDigit "." 1*decimalDigit

// [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]

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

Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)

{

// Check the string against the DMTF-defined grammar

const char* p = stringValue;

if (!*p)

return false;

// Skip optional sign:

if (*p == '+' || *p == '-')

p++;

// Skip optional first set of digits:

while (isdigit(*p))

p++;

// Test required dot:

if (*p++ != '.')

return false;

// One or more digits required:

if (!isdigit(*p++))

return false;

while (isdigit(*p))

p++;

// If there is an exponent now:

if (*p)

{

// Test exponent:

if (*p != 'e' && *p != 'E')

return false;

p++;

// Skip optional sign:

if (*p == '+' || *p == '-')

p++;

// One or more digits required:

if (!isdigit(*p++))

return false;

while (isdigit(*p))

p++;

}

if (*p)

return false;

// Do the conversion

char* end;

errno = 0;

x = strtod(stringValue, &end);

if (*end || (errno == ERANGE))

{

return false;

}

return true;

}

inline Uint8 _xmlReader_hexCharToNumeric(const char c)

{

Uint8 n;

if (isdigit(c))

n = (c - '0');

else if (isupper(c))

n = (c - 'A' + 10);

else // if (islower(c))

n = (c - 'a' + 10);

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

Line 1003

Line 787

{

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_URI_ENCODING",

// 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 digit1 =

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

StringConversion::hexCharToNumeric(char(uriString[++i]));

Uint8 digit2 =

StringConversion::hexCharToNumeric(char(uriString[++i]));

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_URI_ENCODING",

// throw ParseError("Invalid URI encoding");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",

"Invalid URI encoding");

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

}

Line 1064

Line 841

const char* stringValue,

Sint64& x)

{

x = 0;

return (StringConversion::stringToSint64(

const char* p = stringValue;

stringValue, StringConversion::decimalStringToUint64, x) ||

StringConversion::stringToSint64(

if (!p || !*p)

stringValue, StringConversion::hexStringToUint64, x));

return false;

// Skip optional sign:

Boolean negative = *p == '-';

if (negative || *p == '+')

p++;

if (*p == '0')

{

if ( (p[1] == 'x') || (p[1] == 'X') )

{

// Convert a hexadecimal string

// Skip over the "0x"

p+=2;

// At least one hexadecimal digit is required

if (!isxdigit(*p))

return false;

// Build the Sint64 as a negative number, regardless of the

// eventual sign (negative numbers can be bigger than positive ones)

// Add on each digit, checking for overflow errors

while (isxdigit(*p))

{

// Make sure we won't overflow when we multiply by 16

if (x < PEGASUS_SINT64_MIN/16)

{

return false;

}

x = x << 4;

// Make sure we don't overflow when we add the next digit

Sint64 newDigit = Sint64(_xmlReader_hexCharToNumeric(*p++));

if (PEGASUS_SINT64_MIN - x > -newDigit)

{

return false;

}

x = x - newDigit;

}

// If we found a non-hexadecimal digit, report an error

if (*p)

return false;

// Return the integer to positive, if necessary, checking for an

// overflow error

if (!negative)

{

if (x == PEGASUS_SINT64_MIN)

{

return false;

}

x = -x;

}

return true;

}

else

{

// A decimal string that starts with '0' must be exactly "0".

return p[1] == '\0';

}

// Expect a positive decimal digit:

// At least one decimal digit is required

if (!isdigit(*p))

return false;

// Build the Sint64 as a negative number, regardless of the

// eventual sign (negative numbers can be bigger than positive ones)

// Add on each digit, checking for overflow errors

while (isdigit(*p))

{

// Make sure we won't overflow when we multiply by 10

if (x < PEGASUS_SINT64_MIN/10)

{

return false;

}

x = 10 * x;

// Make sure we won't overflow when we add the next digit

Sint64 newDigit = (*p++ - '0');

if (PEGASUS_SINT64_MIN - x > -newDigit)

{

return false;

}

x = x - newDigit;

}

// If we found a non-decimal digit, report an error

if (*p)

return false;

// Return the integer to positive, if necessary, checking for an

// overflow error

if (!negative)

{

if (x == PEGASUS_SINT64_MIN)

{

return false;

}

x = -x;

}

return true;

}

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

Line 1194

Line 861

const char* stringValue,

Uint64& x)

{

x = 0;

return (StringConversion::decimalStringToUint64(stringValue, x) ||

const char* p = stringValue;

StringConversion::hexStringToUint64(stringValue, x));

if (!p || !*p)

return false;

if (*p == '0')

{

if ( (p[1] == 'x') || (p[1] == 'X') )

{

// Convert a hexadecimal string

// Skip over the "0x"

p+=2;

// At least one hexadecimal digit is required

if (!*p)

return false;

// Add on each digit, checking for overflow errors

while (isxdigit(*p))

{

// Make sure we won't overflow when we multiply by 16

if (x > PEGASUS_UINT64_MAX/16)

{

return false;

}

x = x << 4;

// We can't overflow when we add the next digit

Uint64 newDigit = Uint64(_xmlReader_hexCharToNumeric(*p++));

if (PEGASUS_UINT64_MAX - x < newDigit)

{

return false;

}

x = x + newDigit;

}

// If we found a non-hexadecimal digit, report an error

if (*p)

return false;

return true;

}

else

{

// A decimal string that starts with '0' must be exactly "0".

return p[1] == '\0';

}

// Expect a positive decimal digit:

// Add on each digit, checking for overflow errors

while (isdigit(*p))

{

// Make sure we won't overflow when we multiply by 10

if (x > PEGASUS_UINT64_MAX/10)

{

return false;

}

x = 10 * x;

// Make sure we won't overflow when we add the next digit

Uint64 newDigit = (*p++ - '0');

if (PEGASUS_UINT64_MAX - x < newDigit)

{

return false;

}

x = x + newDigit;

}

// If we found a non-decimal digit, report an error

if (*p)

return false;

return true;

}

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

Line 1300

Line 892

return CIMValue(true);

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

return CIMValue(false);

else {

else

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_BOOLEAN_VALUE",

// throw XmlSemanticError(

// lineNumber, "Invalid boolean value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_BOOLEAN_VALUE",

"Invalid boolean value");

throw XmlSemanticError(lineNumber, mlParms);

}

Line 1322

Line 908

case CIMTYPE_CHAR16:

{

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

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_CHAR16_VALUE",

// throw XmlSemanticError(lineNumber, "Invalid char16 value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",

"Invalid char16 value");

throw XmlSemanticError(lineNumber, mlParms);

}

Line 1362

Line 930

if (!stringToUnsignedInteger(valueString, x))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.INVALID_UI_VALUE",

// throw XmlSemanticError(

// lineNumber, "Invalid unsigned integer value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_UI_VALUE",

"Invalid unsigned integer value");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

{

case CIMTYPE_UINT8:

{

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

if (!StringConversion::checkUintBounds(x, type))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.U8_VALUE_OUT_OF_RANGE",

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

}

case CIMTYPE_UINT16:

{

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

if (!StringConversion::checkUintBounds(x, type))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.U16_VALUE_OUT_OF_RANGE",

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

}

case CIMTYPE_UINT32:

{

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

if (!StringConversion::checkUintBounds(x, type))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.U32_VALUE_OUT_OF_RANGE",

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

Line 1443

Line 985

if (!stringToSignedInteger(valueString, x))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.INVALID_SI_VALUE",

// throw XmlSemanticError(

// lineNumber, "Invalid signed integer value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_SI_VALUE",

"Invalid signed integer value");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

{

case CIMTYPE_SINT8:

{

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

if (!StringConversion::checkSintBounds(x, type))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.S8_VALUE_OUT_OF_RANGE",

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

}

case CIMTYPE_SINT16:

{

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

if (!StringConversion::checkSintBounds(x, type))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.S16_VALUE_OUT_OF_RANGE",

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

}

case CIMTYPE_SINT32:

{

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

if (!StringConversion::checkSintBounds(x, type))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.S32_VALUE_OUT_OF_RANGE",

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

Line 1520

Line 1037

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 1531

Line 1048

}

catch (InvalidDateTimeFormatException&)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.INVALID_DATETIME_VALUE",

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_DATETIME_VALUE",

"Invalid datetime value");

throw XmlSemanticError(lineNumber, mlParms);

}

Line 1549

Line 1061

{

Real64 x;

if (!stringToReal(valueString, x)) {

if (!StringConversion::stringToReal64(valueString, x))

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_RN_VALUE",

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

Line 1075

{

Real64 x;

if (!stringToReal(valueString, x)) {

if (!StringConversion::stringToReal64(valueString, x))

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_RN_VALUE",

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

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

// Pegasus internal representation of an embedded object. However, this case is

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

// used when decoding string representations of embedded objects.

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

case CIMTYPE_OBJECT:

case CIMTYPE_INSTANCE:

{

CIMObject x;

if (*valueString == '\0')

{

x = CIMObject();

return CIMValue(type, false, 0);

}

else

{

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

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

// CIMInstance or a CIMClass).

// either a CIMInstance or a CIMClass).

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

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

// just the value of the Embedded Object in String representation.

// just the value of the Embedded Object in String

char* tmp_buffer = new char[strlen(valueString) + 1];

// representation.

strcpy(tmp_buffer, valueString);

AutoArrayPtr<char> tmp_buffer(

XmlParser tmp_parser(tmp_buffer);

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

delete [] tmp_buffer;

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

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

{

if (type == CIMTYPE_INSTANCE)

return CIMValue(cimInstance);

x = CIMObject(cimInstance);

}

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

Line 1620

Line 1129

}

else

{

// l10n

if (type == CIMTYPE_OBJECT)

{

// throw XmlValidationError(parser.getLine(),

// change "element" to "embedded object"

// "Expected INSTANCE or CLASS element");

MessageLoaderParms mlParms(

"Common.XmlReader."

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element"); // change "element" to "embedded object"

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

}

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

// XmlParser.

tmp_buffer.reset();

}

return CIMValue(x);

}

Line 1639

Line 1158

break;

}

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MALFORMED_XML",

// throw XmlSemanticError(lineNumber, "malformed XML");

MessageLoaderParms mlParms("Common.XmlReader.MALFORMED_XML",

"malformed XML");

throw XmlSemanticError(lineNumber, mlParms);

return false;

Line 1700

Line 1215

XmlEntry entry;

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

return false;

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

// Since stringToValue() takes a char* as input, we handle CIMTYPE_OBJECT separately.

if (type == CIMTYPE_OBJECT)

{

CIMObject cimObject;

if (empty)

{

cimObject = CIMObject();

}

else

{

// Convert the non-empty value to a CIMObject (containing either a

// CIMInstance or a CIMClass).

// 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(parser, cimInstance))

{

cimObject = CIMObject(cimInstance);

return false;

}

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

{

cimObject = CIMObject(cimClass);

}

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

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

// "Expected INSTANCE or CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element"); // change "element" to "embedded object"

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

}

expectEndTag(parser, "VALUE");

}

value = CIMValue(cimObject);

}

else

{

const char* valueString = "";

if (!empty)

{

if (testContentOrCData(parser, entry))

{

valueString = entry.text;

}

expectEndTag(parser, "VALUE");

}

Line 1766

Line 1240

if (!empty)

#endif

value = stringToValue(parser.getLine(), valueString,type);

}

return true;

}

Line 1788

Line 1261

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

{

if (required) {

if (required)

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

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

Line 1412

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 1954

Line 1422

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

// PEP 194:

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

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

// Pegasus internal representation of an embedded object. However, this case is

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

// used when decoding string representations of embedded objects.

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

case CIMTYPE_OBJECT:

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

return StringArrayToValueAux(

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

case CIMTYPE_INSTANCE:

return StringArrayToValueAux(

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

default:

break;

}

Line 1989

Line 1460

// Get VALUE.ARRAY open tag:

XmlEntry entry;

Array<const char*> stringArray;

// If no VALUE.ARRAY start tag, return false

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

Line 1996

Line 1468

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

{

if (type == CIMTYPE_OBJECT)

{

Array<CIMObject> objectArray;

// For each VALUE element:

while (testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

CIMObject cimObject;

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

{

cimObject = CIMObject();

}

else

{

// Convert the non-empty value to a CIMObject (containing either a

// CIMInstance or a CIMClass).

// 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(parser, cimInstance))

{

cimObject = CIMObject(cimInstance);

}

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

{

cimObject = CIMObject(cimClass);

}

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE or CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element"); // change "element" to "embedded object"

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

}

expectEndTag(parser, "VALUE");

}

objectArray.append(cimObject);

}

value = CIMValue(objectArray);

}

else

{

Array<const char*> stringArray;

// For each VALUE element:

while (testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

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

Line 2065

Line 1485

expectEndTag(parser, "VALUE");

}

value = stringArrayToValue(parser.getLine(), stringArray, type);

}

expectEndTag(parser, "VALUE.ARRAY");

}

value = stringArrayToValue(parser.getLine(), stringArray, type);

return true;

}

Line 2290

Line 1709

}

catch (AlreadyExistsException&)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.DUPLICATE_QUALIFIER",

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

MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER",

"duplicate qualifier");

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

}

Line 2340

Line 1754

Boolean propagated = getCimBooleanAttribute(

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

// Get PROPERTY.EMBEDDEDOBJECT attribute:

// Get PROPERTY.EmbeddedObject attribute:

String embeddedObject = getEmbeddedObjectAttribute(

EmbeddedObjectAttributeType embeddedObject =

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

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

// Get PROPERTY.TYPE attribute:

Line 2357

Line 1771

if (!empty)

{

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

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

// embedded object, because we need to also check for the EmbeddedObject qualifier.

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

// for the EmbeddedObject qualifier.

getQualifierElements(parser, property);

}

Boolean embeddedObjectQualifierValue = false;

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

Uint32 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT);

if (ix != PEG_NOT_FOUND)

{

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

}

String embeddedInstanceQualifierValue;

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

ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);

if (ix != PEG_NOT_FOUND)

{

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

embeddedInstanceQualifierValue);

}

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

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

// then

// then convert the EmbeddedObject-encoded string into a CIMObject

// Convert the EmbeddedObject-encoded string into a CIMObject

Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||

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

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

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

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

CIMProperty new_property = CIMProperty(

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

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

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

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

// property.

{

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

// All properties are copied, including the EmbeddedObject qualifier.

{

// This way we don't have to keep track to know that the EmbeddedObject

// All properties are copied, including the EmbeddedObject

// qualifier needs to be added back during the encode step.

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

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

// that the EmbeddedObject qualifier needs to be added back

// during the encode step.

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

}

value = new_value; // does this leak?

value = new_value;

property = new_property; // does this leak?

property = new_property;

}

else

{

// Error -- throw exception

MessageLoaderParms mlParms(

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

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

if (!empty)

{

Line 2446

Line 1868

Uint64 arraySize;

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

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

!StringConversion::checkUintBounds(arraySize, CIMTYPE_UINT32))

{

// l10n

// char message[128];

// sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");

// throw XmlSemanticError(lineNumber, message);

char message[128];

sprintf(message, "%s.%s", tagName, "ARRAYSIZE");

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE",

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE",

"Illegal value for $0",

message);

throw XmlSemanticError(lineNumber, mlParms);

}

Line 2513

Line 1930

// Get PROPERTY.CLASSORIGIN attribute:

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

CIMName classOrigin =

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

// Get PROPERTY.ARRAY.PROPAGATED

Boolean propagated = getCimBooleanAttribute(parser.getLine()

Boolean propagated = getCimBooleanAttribute(

,entry

parser.getLine(),

,"PROPERTY.ARRAY"

entry,

,"PROPAGATED"

"PROPERTY.ARRAY",

,false

"PROPAGATED",

,false);

false,

false);

// Get PROPERTY.EMBEDDEDOBJECT attribute:

// Get PROPERTY.EmbeddedObject attribute:

String embeddedObject = getEmbeddedObjectAttribute(parser.getLine()

,entry

EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(

,"PROPERTY.ARRAY");

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

// Create property:

CIMValue value(type, true, arraySize);

property = CIMProperty(name, value, arraySize, CIMName(), classOrigin, propagated);

property = CIMProperty(

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

if (!empty)

{

Line 2542

Line 1961

}

Boolean embeddedObjectQualifierValue = false;

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

Uint32 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT);

if (ix != PEG_NOT_FOUND)

{

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

}

String embeddedInstanceQualifierValue;

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

ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);

if (ix != PEG_NOT_FOUND)

{

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

embeddedInstanceQualifierValue);

}

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

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

Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

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

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

CIMProperty new_property = CIMProperty(

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

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

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

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

// property.

{

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

// All properties are copied, including the EmbeddedObject qualifier.

{

// This way we don't have to keep track to know that the EmbeddedObject

// All properties are copied, including the EmbeddedObject

// qualifier needs to be added back during the encode step.

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

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

// that the EmbeddedObject qualifier needs to be added back

// during the encode step.

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

}

value = new_value; // does this leak?

value = new_value;

property = new_property; // does this leak?

property = new_property;

}

else

{

// Error -- throw exception

MessageLoaderParms mlParms(

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

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

Line 2598

Line 2025

{

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.ARRAY_SIZE_DIFFERENT",

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

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

}

Line 2653

Line 2074

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CONTENT_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected content of HOST element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",

"expected content of HOST element");

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

}

host = String(entry.text);

Line 2730

Line 2144

if (!nameSpace.size())

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",

"Expected one or more NAMESPACE elements within "

// throw XmlValidationError(parser.getLine(),

"LOCALNAMESPACEPATH element");

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

Line 2770

Line 2176

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

return false;

if (!getHostElement(parser, host)) {

if (!getHostElement(parser, host))

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_HOST_ELEMENT",

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

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

}

Line 2821

Line 2217

{

if (required)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

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

}

else

Line 2859

Line 2249

const XmlEntry& entry,

const char* elementName)

{

String tmp;

const char* tmp;

if (!entry.getAttributeValue("VALUETYPE", tmp))

return CIMKeyBinding::STRING;

if (String::equal(tmp, "string"))

if (strcmp(tmp, "string") == 0)

return CIMKeyBinding::STRING;

else if (String::equal(tmp, "boolean"))

else if (strcmp(tmp, "boolean") == 0)

return CIMKeyBinding::BOOLEAN;

else if (String::equal(tmp, "numeric"))

else if (strcmp(tmp, "numeric") == 0)

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

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",

MessageLoaderParms mlParms(

"Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer);

"Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",

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

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

buffer);

throw XmlSemanticError(lineNumber, mlParms);

return CIMKeyBinding::BOOLEAN;

Line 2963

Line 2345

if (!getValueReferenceElement(parser, reference))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",

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

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

}

Line 3082

Line 2458

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected NAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

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

}

String className;

Line 3100

Line 2469

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

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

}

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

Line 3141

Line 2502

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

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

}

String className;

Line 3159

Line 2513

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

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

}

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

Line 3200

Line 2547

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected NAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

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

}

CIMName className;

if (!getClassNameElement(parser, className))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

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

}

reference.set(host, nameSpace, className);

Line 3257

Line 2590

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

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

}

CIMName className;

if (!getClassNameElement(parser, className))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

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

}

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

Line 3319

Line 2638

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

entry.type != XmlEntry::EMPTY_TAG)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_START_TAGS",

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

// throw XmlValidationError(parser.getLine(),

"LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, "

// "Expected one of the following start tags: "

"INSTANCENAME");

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

Line 3500

Line 2812

}

catch (AlreadyExistsException&)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.DUPLICATE_PROPERTY",

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

MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY",

"duplicate property");

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

}

Line 3691

Line 2998

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

Line 3037

}

catch (AlreadyExistsException&)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.DUPLICATE_PARAMETER",

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

MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER",

"duplicate parameter");

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

}

Line 3813

Line 3115

{

if (!isArray)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.ARRAY_WITHOUT_ISARRAY",

"VALUE.ARRAY element encountered without ISARRAY "

// throw XmlSemanticError(parser.getLine(),

"attribute");

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.ARRAY_SIZE_NOT_SAME",

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

}

Line 3847

Line 3136

{

if (isArray)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",

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

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

}

Line 3902

Line 3185

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 3947

Line 3230

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 4040

Line 3323

if (!getInstanceNameElement(parser, instanceName))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

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

}

Line 4056

Line 3333

if (!getInstanceElement(parser, namedInstance))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

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

}

Line 4088

Line 3358

{

if (!getClassElement(parser, x))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"expected CLASS element");

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

}

Line 4111

Line 3375

{

if (!getInstanceElement(parser, x))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

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

}

Line 4134

Line 3392

{

if (!getQualifierDeclElement(parser, x))

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected QUALIFIER.DECLARATION element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",

"expected QUALIFIER.DECLARATION element");

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

}

Line 4165

Line 3417

// Get MESSAGE.ID:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",

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

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

}

// Get MESSAGE.PROTOCOLVERSION:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",

"Invalid or missing MESSAGE.PROTOCOLVERSION attribute");

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

}

Line 4215

Line 3457

// Get IMETHODCALL.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing IMETHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",

"Missing IMETHODCALL.NAME attribute");

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

}

Line 4252

Line 3489

// Get IMETHODRESPONSE.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing IMETHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",

"Missing IMETHODRESPONSE.NAME attribute");

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

}

Line 4289

Line 3521

// Get IPARAMVALUE.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing IPARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",

"Missing IPARAMVALUE.NAME attribute");

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

}

Line 4344

Line 3571

{

if (required)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

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

Line 3585

result = true;

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

result = false;

else {

else

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",

// 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\"");

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

}

Line 4402

Line 3618

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

{

if (required) {

if (required)

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_ERROR_ELEMENT",

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

Line 3634

Uint32 tmpCode;

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

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",

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

Line 3648

entry.getAttributeValue("DESCRIPTION", tmpDescription);

cimException =

PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);

if (!empty)

{

while (testStartTagOrEmptyTag(parser, entry))

CIMInstance instance;

while (getInstanceElement(parser, instance))

{

skipElement(parser, entry);

cimException.addError(instance);

}

expectEndTag(parser, "ERROR");

}

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

return true;

}

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

// getValueObjectElement()

Line 4488

Line 3695

}

else

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE or CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element");

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

}

expectEndTag(parser, "VALUE.OBJECT");

Line 4529

Line 3729

isInstance = true;

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

{

MessageLoaderParms mlParms(

// l10n 485

"Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCEPATH or CLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"Expected INSTANCEPATH or CLASSPATH element");

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

}

Line 4547

Line 3741

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

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

}

objectWithPath = CIMObject (cimInstance);

Line 4567

Line 3755

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "Expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

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

}

objectWithPath = CIMObject (cimClass);

Line 4611

Line 3793

isInstance = true;

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",

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

Line 4631

Line 3805

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

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

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

Line 4652

Line 3819

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

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "Expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

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

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

Line 4728

Line 3887

objectName.set(String(), CIMNamespaceName(), className);

return true;

}

else if (getInstanceNameElement(parser, objectName))

return true;

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

if (!getInstanceNameElement(parser, objectName))

// "expected CLASSNAME or INSTANCENAME element");

{

MessageLoaderParms mlParms(

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",

"Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",

"Expected CLASSNAME or INSTANCENAME element");

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

}

PEGASUS_UNREACHABLE( return false; )

return true;

}

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

Line 4763

Line 3914

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

return false;

if (getClassPathElement(parser, objectPath))

if (!getClassPathElement(parser, objectPath) &&

{

!getInstancePathElement(parser, objectPath))

expectEndTag(parser, "OBJECTPATH");

return true;

}

else if (getInstancePathElement(parser, objectPath))

{

expectEndTag(parser, "OBJECTPATH");

return true;

}

else

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCEPATH or CLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"expected INSTANCEPATH or CLASSPATH element");

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

}

PEGASUS_UNREACHABLE ( return false; )

expectEndTag(parser, "OBJECTPATH");

return true;

}

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

Line 4808

Line 3945

// Get EXPMETHODCALL.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing EXPMETHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",

"Missing EXPMETHODCALL.NAME attribute");

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

}

Line 4845

Line 3977

// Get EXPMETHODRESPONSE.NAME attribute:

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

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

// l10n

{

MessageLoaderParms mlParms(

// throw XmlValidationError(

"Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",

// parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",

"Missing EXPMETHODRESPONSE.NAME attribute");

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

}

Line 4878

Line 4006

// Get EXPPARAMVALUE.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing EXPPARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",

"Missing EXPPARAMVALUE.NAME attribute");

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

}

Line 4914

Line 4037

// Get METHODCALL.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing METHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",

"Missing METHODCALL.NAME attribute");

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

}

Line 4952

Line 4070

// Get METHODRESPONSE.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing METHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",

"Missing METHODRESPONSE.NAME attribute");

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

}

Line 4996

Line 4109

// Get PARAMVALUE.NAME attribute:

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

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

{

// l10n

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",

// throw XmlValidationError(parser.getLine(),

// "Missing PARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",

"Missing PARAMVALUE.NAME attribute");

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

}

// Get PROPERTY.EMBEDDEDOBJECT

// Get PROPERTY.EmbeddedObject

String embeddedObject = getEmbeddedObjectAttribute(

EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(

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

// Get PARAMVALUE.PARAMTYPE attribute:

Line 5019

Line 4127

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 5036

Line 4148

type = CIMTYPE_REFERENCE;

gotType = true;

}

// If type==reference but no VALUE.REFERENCE found, use null value

else

{

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

}

// Parse non-reference value

Line 5053

Line 4168

effectiveType = type;

}

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

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

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

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

if (embeddedObject != NO_EMBEDDED_OBJECT)

{

// The EMBEDDEDOBJECT attribute is only valid on Parameters of type string

// The EmbeddedObject attribute is only valid on Parameters

// of type string

// The type must have been specified.

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

{

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

if (embeddedObject == EMBEDDED_OBJECT_ATTR)

// Used below by getValueElement() or

// getValueArrayElement()

effectiveType = CIMTYPE_OBJECT;

else

effectiveType = CIMTYPE_INSTANCE;

}

else

{

// Error -- throw exception

MessageLoaderParms mlParms(

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EmbeddedObject attribute is only valid on "

// l10n

"string types.");

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

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

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

!XmlReader::getValueElement(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

}

expectEndTag(parser, "PARAMVALUE");

}

paramValue = CIMParamValue(name, value, gotType);

return true;

Line 5120

Line 4233

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

return false;

// Get PROPERTY.EMBEDDEDOBJECT

// Get PROPERTY.EmbeddedObject

String embeddedObject = getEmbeddedObjectAttribute(

EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(

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

// Get RETURNVALUE.PARAMTYPE attribute:

Line 5143

Line 4256

}

else if (type == CIMTYPE_REFERENCE)

{

MessageLoaderParms mlParms(

// l10n

"Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",

// throw XmlValidationError(parser.getLine(),

// "expected VALUE.REFERENCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",

"expected VALUE.REFERENCE element");

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

}

Line 5164

Line 4271

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

type = CIMTYPE_STRING;

}

if (embeddedObject != NO_EMBEDDED_OBJECT)

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

{

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

{

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

if (embeddedObject == EMBEDDED_OBJECT_ATTR)

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

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

}

else

{

// Error -- throw exception

MessageLoaderParms mlParms(

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EmbeddedObject attribute is only valid on string "

"types.");

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

}

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"expected VALUE element");

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

}

// l10n

expectEndTag(parser, "RETURNVALUE");

// throw XmlValidationError(parser.getLine(),

return true;

// "expected string type");

}

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

// 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++;

}

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

if (cimVersion[index] == 0)

{

cimVersionAccepted = true;

}

return cimVersionAccepted;

}

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

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

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

// l10n

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

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

// throw XmlValidationError(parser.getLine(),

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

// "expected VALUE element");

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

{

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",

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

"expected VALUE element");

Uint32 index = 2;

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

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

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

{

index++;

}

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

if (index == protocolVersion.size())

{

protocolVersionAccepted = true;

}

return protocolVersionAccepted;

}

expectEndTag(parser, "RETURNVALUE");

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

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

return true;

//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.110
changed lines
	Added in v.1.136

No CVS admin address has been configured