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

Return to XmlWriter.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/XmlWriter.cpp between version 1.152 and 1.162

version 1.152, 2007/09/03 11:27:02

version 1.162, 2008/10/17 07:16:35

Line 53

#include "CIMQualifierDeclRep.h"

#include "CIMValue.h"

#include "XmlWriter.h"

#include "XmlParser.h"

#include "Tracer.h"

#include <Pegasus/Common/StatisticalData.h>

#include "CommonUTF.h"

#include "Buffer.h"

#include "StrLit.h"

#include "LanguageParser.h"

#include "IDFactory.h"

#include "StringConversion.h"

PEGASUS_NAMESPACE_BEGIN

// This is a shortcut macro for outputing content length. This

static StrLit _XmlWriterTypeStrings[] =

// pads the output number to the max characters representing a Uint32 number

// so that it can be overwritten easily with a transfer encoding line later

// on in HTTPConnection if required. This is strictly for performance since

// messages can be very large. This overwriting shortcut allows us to NOT have

// to repackage a large message later.

#define OUTPUT_CONTENTLENGTH \

{ \

char contentLengthP[11]; \

int n = sprintf(contentLengthP,"%.10u", contentLength); \

out << STRLIT("content-length: "); \

out.append(contentLengthP, n); \

out << STRLIT("\r\n"); \

}

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

// SpecialChar and table.

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

// Note: we cannot use StrLit here since it has a constructur (forbits

// structure initialization).

struct SpecialChar

{

const char* str;

Uint32 size;

};

// Defines encodings of special characters. Just use a 7-bit ASCII character

// as an index into this array to retrieve its string encoding and encoding

// length in bytes.

static const SpecialChar _specialChars[] =

{

{STRLIT_ARGS("")},

{STRLIT_ARGS("	")},

{STRLIT_ARGS("
")},

{STRLIT_ARGS("")},

{STRLIT_ARGS("")},

{STRLIT_ARGS("")},

{STRLIT_ARGS(" ")},

{STRLIT_ARGS("!")},

{STRLIT_ARGS(""")},

{STRLIT_ARGS("#")},

{STRLIT_ARGS("$")},

{STRLIT_ARGS("%")},

{STRLIT_ARGS("&")},

{STRLIT_ARGS("'")},

{STRLIT_ARGS("(")},

{STRLIT_ARGS(")")},

{STRLIT_ARGS("*")},

{STRLIT_ARGS("+")},

{STRLIT_ARGS(",")},

{STRLIT_ARGS("-")},

{STRLIT_ARGS(".")},

{STRLIT_ARGS("/")},

{STRLIT_ARGS("0")},

{STRLIT_ARGS("1")},

{STRLIT_ARGS("2")},

{STRLIT_ARGS("3")},

{STRLIT_ARGS("4")},

{STRLIT_ARGS("5")},

{STRLIT_ARGS("6")},

{STRLIT_ARGS("7")},

{STRLIT_ARGS("8")},

{STRLIT_ARGS("9")},

{STRLIT_ARGS(":")},

{STRLIT_ARGS(";")},

{STRLIT_ARGS("<")},

{STRLIT_ARGS("=")},

{STRLIT_ARGS(">")},

{STRLIT_ARGS("?")},

{STRLIT_ARGS("@")},

{STRLIT_ARGS("A")},

{STRLIT_ARGS("B")},

{STRLIT_ARGS("C")},

{STRLIT_ARGS("D")},

{STRLIT_ARGS("E")},

{STRLIT_ARGS("F")},

{STRLIT_ARGS("G")},

{STRLIT_ARGS("H")},

{STRLIT_ARGS("I")},

{STRLIT_ARGS("J")},

{STRLIT_ARGS("K")},

{STRLIT_ARGS("L")},

{STRLIT_ARGS("M")},

{STRLIT_ARGS("N")},

{STRLIT_ARGS("O")},

{STRLIT_ARGS("P")},

{STRLIT_ARGS("Q")},

{STRLIT_ARGS("R")},

{STRLIT_ARGS("S")},

{STRLIT_ARGS("T")},

{STRLIT_ARGS("U")},

{STRLIT_ARGS("V")},

{STRLIT_ARGS("W")},

{STRLIT_ARGS("X")},

{STRLIT_ARGS("Y")},

{STRLIT_ARGS("Z")},

{STRLIT_ARGS("[")},

{STRLIT_ARGS("\\")},

{STRLIT_ARGS("]")},

{STRLIT_ARGS("^")},

{STRLIT_ARGS("_")},

{STRLIT_ARGS("`")},

{STRLIT_ARGS("a")},

{STRLIT_ARGS("b")},

{STRLIT_ARGS("c")},

{STRLIT_ARGS("d")},

{STRLIT_ARGS("e")},

{STRLIT_ARGS("f")},

{STRLIT_ARGS("g")},

{STRLIT_ARGS("h")},

{STRLIT_ARGS("i")},

{STRLIT_ARGS("j")},

{STRLIT_ARGS("k")},

{STRLIT_ARGS("l")},

{STRLIT_ARGS("m")},

{STRLIT_ARGS("n")},

{STRLIT_ARGS("o")},

{STRLIT_ARGS("p")},

{STRLIT_ARGS("q")},

{STRLIT_ARGS("r")},

{STRLIT_ARGS("s")},

{STRLIT_ARGS("t")},

{STRLIT_ARGS("u")},

{STRLIT_ARGS("v")},

{STRLIT_ARGS("w")},

{STRLIT_ARGS("x")},

{STRLIT_ARGS("y")},

{STRLIT_ARGS("z")},

{STRLIT_ARGS("{")},

{STRLIT_ARGS("|")},

{STRLIT_ARGS("}")},

{STRLIT_ARGS("~")},

{STRLIT_ARGS("")},

};

// If _isSpecialChar7[ch] is true, then ch is a special character, which must

// have a special encoding in XML. But only use 7-bit ASCII characters to

// index this array.

static const int _isSpecialChar7[] =

{

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,

0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,

};

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

Buffer& operator<<(Buffer& out, const Char16& x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const String& x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const Indentor& x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const Buffer& x)

{

out.append(x.getData(), x.size());

return out;

}

Buffer& operator<<(Buffer& out, Uint32 x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const CIMName& name)

{

XmlWriter::append(out, name.getString ());

return out;

}

Buffer& operator<<(Buffer& out, const AcceptLanguageList& al)

{

XmlWriter::append(out, LanguageParser::buildAcceptLanguageHeader(al));

return out;

}

Buffer& operator<<(Buffer& out, const ContentLanguageList& cl)

{

XmlWriter::append(out, LanguageParser::buildContentLanguageHeader(cl));

return out;

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x)

{

return os << x.toString();

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMName& name)

{

os << name.getString();

return os;

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os,

const CIMNamespaceName& name)

{

os << name.getString();

return os;

}

static void _xmlWritter_appendChar(Buffer& out, const Char16& c)

{

// We need to convert the Char16 to UTF8 then append the UTF8

// character into the array.

// NOTE: The UTF8 character could be several bytes long.

// WARNING: This function will put in replacement character for

// all characters that have surogate pairs.

char str[6];

memset(str,0x00,sizeof(str));

Uint8* charIN = (Uint8 *)&c;

const Uint16 *strsrc = (Uint16 *)charIN;

Uint16 *endsrc = (Uint16 *)&charIN[1];

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[5];

UTF16toUTF8(

&strsrc,

endsrc,

&strtgt,

endtgt);

out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);

}

inline void _appendSpecialChar7(Buffer& out, char c)

{

if (_isSpecialChar7[int(c)])

out.append(_specialChars[int(c)].str, _specialChars[int(c)].size);

else

out.append(c);

}

inline void _xmlWritter_appendSpecialChar(Buffer& out, const Char16& c)

{

if (c < 128)

_appendSpecialChar7(out, char(c));

else

_xmlWritter_appendChar(out, c);

}

static void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)

{

if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )

{

char scratchBuffer[22];

Uint32 outputLength;

const char * output = Uint8ToString(scratchBuffer,

static_cast<Uint8>(c),

outputLength);

os << "&#" << output << ";";

}

else

{

switch (c)

{

case '&':

os << "&";

break;

case '<':

os << "<";

break;

case '>':

os << ">";

break;

case '"':

os << """;

break;

case '\'':

os << "'";

break;

default:

os << c;

}

void _xmlWritter_appendSurrogatePair(Buffer& out, Uint16 high, Uint16 low)

{

char str[6];

Uint8 charIN[5];

memset(str,0x00,sizeof(str));

memcpy(&charIN,&high,2);

memcpy(&charIN[2],&low,2);

const Uint16 *strsrc = (Uint16 *)charIN;

Uint16 *endsrc = (Uint16 *)&charIN[3];

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[5];

UTF16toUTF8(

&strsrc,

endsrc,

&strtgt,

endtgt);

Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;

out.append(str,number1);

}

inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str)

{

while (*str)

_xmlWritter_appendSpecialChar(os, *str++);

}

// On windows sprintf outputs 3 digit precision exponent prepending

// zeros. Make it 2 digit precision if first digit is zero in the exponent.

#ifdef PEGASUS_OS_TYPE_WINDOWS

inline void _xmlWriter_normalizeRealValueString(char *str)

{

// skip initial sign value...

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

{

++str;

}

while (*str && *str != '+' && *str != '-')

{

++str;

}

if (*str && * ++str == '0')

{

*str = *(str+1);

*(str+1) = *(str+2);

*(str+2) = 0;

}

#endif

void XmlWriter::append(Buffer& out, const Char16& x)

{

_xmlWritter_appendChar(out, x);

}

void XmlWriter::append(Buffer& out, Boolean x)

{

if (x)

out.append(STRLIT_ARGS("TRUE"));

else

out.append(STRLIT_ARGS("FALSE"));

}

void XmlWriter::append(Buffer& out, Uint32 x)

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Uint32ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

void XmlWriter::append(Buffer& out, Sint32 x)

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Sint32ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

void XmlWriter::append(Buffer& out, Uint64 x)

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Uint64ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

void XmlWriter::append(Buffer& out, Sint64 x)

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Sint64ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

void XmlWriter::append(Buffer& out, Real32 x)

{

char buffer[128];

// %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format

// given in the CIM/XML spec, and the precision required by the CIM 2.2 spec

// (4 byte IEEE floating point)

sprintf(buffer, "%.7e", x);

#ifdef PEGASUS_OS_TYPE_WINDOWS

_xmlWriter_normalizeRealValueString(buffer);

#endif

append(out, buffer);

}

void XmlWriter::append(Buffer& out, Real64 x)

{

char buffer[128];

// %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible

// with the format given in the CIM/XML spec, and the precision required

// by the CIM 2.2 spec (8 byte IEEE floating point)

sprintf(buffer, "%.16e", x);

#ifdef PEGASUS_OS_TYPE_WINDOWS

_xmlWriter_normalizeRealValueString(buffer);

#endif

append(out, buffer);

}

void XmlWriter::append(Buffer& out, const char* str)

{

size_t n = strlen(str);

out.append(str, n);

}

void XmlWriter::append(Buffer& out, const String& str)

{

const Uint16* p = (const Uint16*)str.getChar16Data();

size_t n = str.size();

// Handle leading ASCII 7 characers in these next two loops (use unrolling).

while (n >= 8 && ((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)

{

out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);

p += 8;

n -= 8;

}

while (n >= 4 && ((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)

{

out.append(p[0], p[1], p[2], p[3]);

p += 4;

n -= 4;

}

while (n--)

{

Uint16 c = *p++;

// Special processing for UTF8 case:

if (c < 128)

{

out.append(c);

continue;

}

// Handle UTF8 case (if reached).

if (((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||

((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))

{

Char16 highSurrogate = p[-1];

Char16 lowSurrogate = p[0];

p++;

n--;

_xmlWritter_appendSurrogatePair(

out, Uint16(highSurrogate),Uint16(lowSurrogate));

}

else

{

_xmlWritter_appendChar(out, c);

}

void XmlWriter::append(Buffer& out, const Indentor& x)

{

for (Uint32 i = 0; i < 4 * x.getLevel(); i++)

out.append(' ');

}

void XmlWriter::appendSpecial(Buffer& out, const Char16& x)

{

_xmlWritter_appendSpecialChar(out, x);

}

void XmlWriter::appendSpecial(Buffer& out, char x)

{

_appendSpecialChar7(out, x);

}

void XmlWriter::appendSpecial(Buffer& out, const char* str)

{

while (*str)

_appendSpecialChar7(out, *str++);

}

void XmlWriter::appendSpecial(Buffer& out, const String& str)

{

const Uint16* p = (const Uint16*)str.getChar16Data();

// prevCharIsSpace is true when the last character written to the Buffer

// is a space character (not a character reference).

Boolean prevCharIsSpace = false;

// If the first character is a space, use a character reference to avoid

// space compression.

if (*p == ' ')

{

out.append(STRLIT_ARGS(" "));

p++;

}

Uint16 c;

while ((c = *p++) != 0)

{

if (c < 128)

{

if (_isSpecialChar7[c])

{

// Write the character reference for the special character

out.append(

_specialChars[int(c)].str, _specialChars[int(c)].size);

prevCharIsSpace = false;

}

else if (prevCharIsSpace && (c == ' '))

{

// Write the character reference for the space character, to

// avoid compression

out.append(STRLIT_ARGS(" "));

prevCharIsSpace = false;

}

else

{

out.append(c);

prevCharIsSpace = (c == ' ');

}

else

{

// Handle UTF8 case

if ((((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||

((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE))) &&

*p)

{

_xmlWritter_appendSurrogatePair(out, c, *p++);

}

else

{

_xmlWritter_appendChar(out, c);

}

prevCharIsSpace = false;

}

// If the last character is a space, use a character reference to avoid

// space compression.

if (prevCharIsSpace)

{

out.remove(out.size() - 1);

STRLIT("TYPE=\"boolean\""), STRLIT("TYPE=\"uint8\""),

out.append(STRLIT_ARGS(" "));

STRLIT("TYPE=\"sint8\""), STRLIT("TYPE=\"uint16\""),

}

STRLIT("TYPE=\"sint16\""), STRLIT("TYPE=\"uint32\""),

}

STRLIT("TYPE=\"sint32\""), STRLIT("TYPE=\"uint64\""),

STRLIT("TYPE=\"sint64\""), STRLIT("TYPE=\"real32\""),

// See http://www.ietf.org/rfc/rfc2396.txt section 2

STRLIT("TYPE=\"real64\""), STRLIT("TYPE=\"char16\""),

// Reserved characters = ';' '/' '?' ':' '@' '&' '=' '+' '$' ','

STRLIT("TYPE=\"string\""), STRLIT("TYPE=\"datetime\""),

// Excluded characters:

STRLIT("TYPE=\"reference\""), STRLIT("TYPE=\"object\""),

// Control characters = 0x00-0x1f, 0x7f

STRLIT("TYPE=\"instance\"")

// Space character = 0x20

// Delimiters = '<' '>' '#' '%' '"'

// Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'

static const char _is_uri[128] =

{

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,

1,1,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,

};

// Perform the necessary URI encoding of characters in HTTP header values.

// This is required by the HTTP/1.1 specification and the CIM/HTTP

// Specification (section 3.3.2).

static void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)

{

Uint8 c = (Uint8)char8;

#ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING

if (c > 127 || _is_uri[int(c)])

{

char hexencoding[4];

int n = sprintf(hexencoding, "%%%X%X", c/16, c%16);

#ifdef PEGASUS_USE_STRING_EXTENSIONS

outString.append(hexencoding, n);

#else /* PEGASUS_USE_STRING_EXTENSIONS */

outString.append(hexencoding);

#endif /* PEGASUS_USE_STRING_EXTENSIONS */

}

else

#endif

{

outString.append((Uint16)c);

}

String XmlWriter::encodeURICharacters(const Buffer& uriString)

{

String encodedString;

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

{

_xmlWritter_encodeURIChar(encodedString, uriString[i]);

}

return encodedString;

}

String XmlWriter::encodeURICharacters(const String& uriString)

{

String encodedString;

/* i18n remove - did not handle surrogate pairs

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

{

_xmlWritter_encodeURIChar(encodedString, uriString[i]);

}

// See the "CIM Operations over HTTP" spec, section 3.3.2 and

// 3.3.3, for the treatment of non US-ASCII (UTF-8) chars

// First, convert to UTF-8 (include handling of surrogate pairs)

Buffer utf8;

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

{

Uint16 c = uriString[i];

if (((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||

((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))

{

Char16 highSurrogate = uriString[i];

Char16 lowSurrogate = uriString[++i];

_xmlWritter_appendSurrogatePair(

utf8, Uint16(highSurrogate),Uint16(lowSurrogate));

}

else

{

_xmlWritter_appendChar(utf8, uriString[i]);

}

// Second, escape the non HTTP-safe chars

for (Uint32 i=0; i<utf8.size(); i++)

{

_xmlWritter_encodeURIChar(encodedString, utf8[i]);

}

return encodedString;

}

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

// appendLocalNameSpacePathElement()

Line 809

Line 120

const String& host,

const CIMNamespaceName& nameSpace)

{

out << STRLIT("<NAMESPACEPATH>\n");

out << STRLIT("<NAMESPACEPATH>\n"

out << STRLIT("<HOST>") << host << STRLIT("</HOST>\n");

"<HOST>") << host << STRLIT("</HOST>\n");

appendLocalNameSpacePathElement(out, nameSpace);

out << STRLIT("</NAMESPACEPATH>\n");

}

Line 1249

Line 560

_xmlWritter_appendValueArray(out, a.getData(), a.size());

break;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

{

Array<CIMInstance> a;

Line 1257

Line 567

_xmlWritter_appendValueArray(out, a.getData(), a.size());

break;

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

PEGASUS_ASSERT(false);

}

Line 1394

Line 703

_xmlWritter_appendValue(out, v);

break;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

{

CIMInstance v;

Line 1402

Line 710

_xmlWritter_appendValue(out, v);

break;

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

PEGASUS_ASSERT(false);

}

Line 1548

Line 855

void XmlWriter::appendClassElement(

Buffer& out,

const CIMConstClass& cimclass)

const CIMConstClass& cimClass)

{

CheckRep(cimclass._rep);

CheckRep(cimClass._rep);

cimclass._rep->toXml(out);

const CIMClassRep* rep = cimClass._rep;

// Class opening element:

out << STRLIT("<CLASS NAME=\"")

<< rep->getClassName()

<< STRLIT("\" ");

if (!rep->getSuperClassName().isNull())

{

out << STRLIT(" SUPERCLASS=\"")

<< rep->getSuperClassName()

<< STRLIT("\" ");

}

out << STRLIT(">\n");

// Append Class Qualifiers:

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

// Append Property definitions:

for (Uint32 i = 0, n = rep->getPropertyCount(); i < n; i++)

XmlWriter::appendPropertyElement(out, rep->getProperty(i));

// Append Method definitions:

for (Uint32 i = 0, n = rep->getMethodCount(); i < n; i++)

XmlWriter::appendMethodElement(out, rep->getMethod(i));

// Class closing element:

out << STRLIT("</CLASS>\n");

}

void XmlWriter::printClassElement(

Line 1579

Line 920

const CIMConstInstance& instance)

{

CheckRep(instance._rep);

instance._rep->toXml(out);

const CIMInstanceRep* rep = instance._rep;

// Class opening element:

out << STRLIT("<INSTANCE CLASSNAME=\"")

<< rep->getClassName()

<< STRLIT("\" >\n");

// Append Instance Qualifiers:

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

// Append Properties:

for (Uint32 i = 0, n = rep->getPropertyCount(); i < n; i++)

XmlWriter::appendPropertyElement(out, rep->getProperty(i));

// Instance closing element:

out << STRLIT("</INSTANCE>\n");

}

void XmlWriter::printInstanceElement(

Line 1608

Line 969

CIMConstClass c(object);

appendClassElement(out, c);

}

else if (object.isInstance())

{

CIMConstInstance i(object);

appendInstanceElement(out, i);

}

// else PEGASUS_ASSERT(0);

}

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

// appendPropertyElement()

// <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>

// <!ATTLIST PROPERTY

// %CIMName;

// %CIMType; #REQUIRED

// %ClassOrigin;

// %Propagated;>

// <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>

// <!ATTLIST PROPERTY.ARRAY

// %CIMName;

// %CIMType; #REQUIRED

// %ArraySize;

// %ClassOrigin;

// %Propagated;>

// <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>

// <!ATTLIST PROPERTY.REFERENCE

// %CIMName;

// %ReferenceClass;

// %ClassOrigin;

// %Propagated;>

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

void XmlWriter::appendPropertyElement(

Buffer& out,

const CIMConstProperty& property)

{

CheckRep(property._rep);

const CIMPropertyRep* rep = property._rep;

if (rep->getValue().isArray())

{

out << STRLIT("<PROPERTY.ARRAY NAME=\"")

<< rep->getName()

<< STRLIT("\" ");

if (rep->getValue().getType() == CIMTYPE_OBJECT)

{

// If the property array type is CIMObject, then

// encode the property in CIM-XML as a string array with the

// EmbeddedObject attribute (there is not currently a CIM-XML

// "object" datatype)

Array<CIMObject> a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\"");

// If the Embedded Object is an instance, always add the

// EmbeddedObject attribute.

if (a.size() > 0 && a[0].isInstance())

{

out << STRLIT(" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

#ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY

else

#endif

{

// Else the Embedded Object is a class, always add the

// EmbeddedObject qualifier. Note that if the macro

// PEGASUS_SNIA_INTEROP_COMPATIBILITY is defined, then

// the EmbeddedObject qualifier will always be added,

// whether it's a class or an instance.

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT) ==

PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedObject qualifier, so we cast away the

// constness.

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(

CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,

true));

}

else if (rep->getValue().getType() == CIMTYPE_INSTANCE)

{

// If the property array type is CIMInstance, then

// encode the property in CIM-XML as a string array with the

// EmbeddedObject attribute (there is not currently a CIM-XML

// "instance" datatype)

Array<CIMInstance> a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\"");

// add the EmbeddedObject attribute

if (a.size() > 0)

{

out << STRLIT(" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

// Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY is

// defined, then the EmbeddedInstance qualifier will be added

# ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE ==

PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedInstance qualifier, so we cast away the

// constness.

// For now, we assume that all the embedded instances in

// the array are of the same type

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(CIMQualifier(

PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,

a[0].getClassName().getString()));

}

# endif

}

else

{

out.append(' ');

out << _XmlWriterTypeStrings[rep->getValue().getType()];

}

if (rep->getArraySize())

{

char buffer[32];

sprintf(buffer, "%u", rep->getArraySize());

out << STRLIT(" ARRAYSIZE=\"") << buffer;

out.append('"');

}

if (!rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</PROPERTY.ARRAY>\n");

}

else if (rep->getValue().getType() == CIMTYPE_REFERENCE)

{

out << STRLIT("<PROPERTY.REFERENCE"

" NAME=\"") << rep->getName() << STRLIT("\" ");

if (!rep->getReferenceClassName().isNull())

{

out << STRLIT(" REFERENCECLASS=\"") << rep->getReferenceClassName();

out.append('"');

}

if (!rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</PROPERTY.REFERENCE>\n");

}

else

{

out << STRLIT("<PROPERTY NAME=\"") << rep->getName() << STRLIT("\" ");

if (!rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

if (rep->getValue().getType() == CIMTYPE_OBJECT)

{

// If the property type is CIMObject, then

// encode the property in CIM-XML as a string with the

// EmbeddedObject attribute (there is not currently a CIM-XML

// "object" datatype)

CIMObject a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\"");

// If the Embedded Object is an instance, always add the

// EmbeddedObject attribute.

if (a.isInstance())

{

out << STRLIT(" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

// Else the Embedded Object is a class, always add the

// EmbeddedObject qualifier.

#ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY

else

#endif

{

// Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY

// is defined, then the EmbeddedObject qualifier will always

// be added, whether it's a class or an instance.

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT) ==

PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedObject qualifier, so we cast away the

// constness.

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(

CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,

true));

}

else if (rep->getValue().getType() == CIMTYPE_INSTANCE)

{

CIMInstance a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\""

" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

# ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)

== PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedInstance qualifier, so we cast away the

// constness.

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(CIMQualifier(

PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,

a.getClassName().getString()));

}

# endif

}

else

{

CIMConstInstance i(object);

out.append(' ');

appendInstanceElement(out, i);

out << _XmlWriterTypeStrings[rep->getValue().getType()];

}

// else PEGASUS_ASSERT(0);

}

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

out << STRLIT(">\n");

// appendPropertyElement()

// <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>

// <!ATTLIST PROPERTY

// %CIMName;

// %CIMType; #REQUIRED

// %ClassOrigin;

// %Propagated;>

// <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>

// <!ATTLIST PROPERTY.ARRAY

// %CIMName;

// %CIMType; #REQUIRED

// %ArraySize;

// %ClassOrigin;

// %Propagated;>

// <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>

// <!ATTLIST PROPERTY.REFERENCE

// %CIMName;

// %ReferenceClass;

// %ClassOrigin;

// %Propagated;>

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

void XmlWriter::appendPropertyElement(

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

Buffer& out,

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

const CIMConstProperty& property)

{

XmlWriter::appendValueElement(out, rep->getValue());

CheckRep(property._rep);

property._rep->toXml(out);

out << STRLIT("</PROPERTY>\n");

}

void XmlWriter::printPropertyElement(

Line 1680

Line 1285

const CIMConstMethod& method)

{

CheckRep(method._rep);

method._rep->toXml(out);

const CIMMethodRep* rep = method._rep;

out << STRLIT("<METHOD NAME=\"") << rep->getName();

out << STRLIT("\" ");

out << _XmlWriterTypeStrings[rep->getType()];

if (!rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

for (Uint32 i = 0, n = rep->getParameterCount(); i < n; i++)

XmlWriter::appendParameterElement(out, rep->getParameter(i));

out << STRLIT("</METHOD>\n");

}

void XmlWriter::printMethodElement(

Line 1725

Line 1356

const CIMConstParameter& parameter)

{

CheckRep(parameter._rep);

parameter._rep->toXml(out);

const CIMParameterRep* rep = parameter._rep;

if (rep->isArray())

{

if (rep->getType() == CIMTYPE_REFERENCE)

{

out << STRLIT("<PARAMETER.REFARRAY NAME=\"") << rep->getName();

out.append('"');

if (!rep->getReferenceClassName().isNull())

{

out << STRLIT(" REFERENCECLASS=\"");

out << rep->getReferenceClassName().getString();

out.append('"');

}

if (rep->getArraySize())

{

char buffer[32];

int n = sprintf(buffer, "%u", rep->getArraySize());

out << STRLIT(" ARRAYSIZE=\"");

out.append(buffer, n);

out.append('"');

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER.REFARRAY>\n");

}

else

{

out << STRLIT("<PARAMETER.ARRAY"

" NAME=\"") << rep->getName();

out << STRLIT("\" ") << _XmlWriterTypeStrings[rep->getType()];

if (rep->getArraySize())

{

char buffer[32];

sprintf(buffer, "%u", rep->getArraySize());

out << STRLIT(" ARRAYSIZE=\"") << buffer;

out.append('"');

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER.ARRAY>\n");

}

else if (rep->getType() == CIMTYPE_REFERENCE)

{

out << STRLIT("<PARAMETER.REFERENCE"

" NAME=\"") << rep->getName();

out.append('"');

if (!rep->getReferenceClassName().isNull())

{

out << STRLIT(" REFERENCECLASS=\"");

out << rep->getReferenceClassName().getString();

out.append('"');

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER.REFERENCE>\n");

}

else

{

out << STRLIT("<PARAMETER"

" NAME=\"") << rep->getName();

out << STRLIT("\" ") << _XmlWriterTypeStrings[rep->getType()];

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER>\n");

}

void XmlWriter::printParameterElement(

Line 1743

Line 1459

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

// <!ATTLIST PARAMVALUE

// %CIMName;>

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 1752

Line 1470

const CIMParamValue& paramValue)

{

CheckRep(paramValue._rep);

paramValue._rep->toXml(out);

const CIMParamValueRep* rep = paramValue._rep;

out << STRLIT("<PARAMVALUE NAME=\"") << rep->getParameterName();

out.append('"');

CIMType type = rep->getValue().getType();

if (rep->isTyped())

{

XmlWriter::appendParamTypeAndEmbeddedObjAttrib(out, type);

}

out << STRLIT(">\n");

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</PARAMVALUE>\n");

}

void XmlWriter::printParamValueElement(

Line 1782

Line 1515

const CIMConstQualifier& qualifier)

{

CheckRep(qualifier._rep);

qualifier._rep->toXml(out);

const CIMQualifierRep* rep = qualifier._rep;

out << STRLIT("<QUALIFIER NAME=\"") << rep->getName();

out << STRLIT("\" ") << _XmlWriterTypeStrings[rep->getValue().getType()];

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

XmlWriter::appendQualifierFlavorEntity(out, rep->getFlavor());

out << STRLIT(">\n");

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</QUALIFIER>\n");

}

void XmlWriter::printQualifierElement(

Line 1813

Line 1562

const CIMConstQualifierDecl& qualifierDecl)

{

CheckRep(qualifierDecl._rep);

qualifierDecl._rep->toXml(out);

const CIMQualifierDeclRep* rep = qualifierDecl._rep;

out << STRLIT("<QUALIFIER.DECLARATION NAME=\"") << rep->getName();

out << STRLIT("\" ") << _XmlWriterTypeStrings[rep->getValue().getType()];

if (rep->getValue().isArray())

{

out << STRLIT(" ISARRAY=\"true\"");

if (rep->getArraySize())

{

char buffer[64];

int n = sprintf(buffer, " ARRAYSIZE=\"%u\"", rep->getArraySize());

out.append(buffer, n);

}

XmlWriter::appendQualifierFlavorEntity(out, rep->getFlavor());

out << STRLIT(">\n");

XmlWriter::appendScopeElement(out, rep->getScope());

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</QUALIFIER.DECLARATION>\n");

}

void XmlWriter::printQualifierDeclElement(

Line 1940

Line 1713

{

out << STRLIT("POST /cimom HTTP/1.1\r\n");

}

out << STRLIT("HOST: ") << host << STRLIT("\r\n");

out << STRLIT("HOST: ") << host << STRLIT("\r\n"

out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");

"Content-Type: application/xml; charset=\"utf-8\"\r\n");

OUTPUT_CONTENTLENGTH;

OUTPUT_CONTENTLENGTH(out, contentLength);

if (acceptLanguages.size() > 0)

{

out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");

Line 1974

Line 1747

out << nn << STRLIT("-CIMOperation: MethodCall\r\n");

out << nn << STRLIT("-CIMMethod: ")

<< encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n");

out << nn << STRLIT("-CIMObject: ") << encodeURICharacters(cimObject)

out << nn << STRLIT("-CIMObject: ")

<< STRLIT("\r\n");

<< encodeURICharacters(cimObject) << STRLIT("\r\n");

}

else

{

out << STRLIT("CIMOperation: MethodCall\r\n");

out << STRLIT("CIMMethod: ")

<< encodeURICharacters(cimMethod.getString())

<< encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n");

<< STRLIT("\r\n");

out << STRLIT("CIMObject: ") << encodeURICharacters(cimObject)

<< STRLIT("\r\n");

}

Line 2015

Line 1787

#endif

out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");

OUTPUT_CONTENTLENGTH;

OUTPUT_CONTENTLENGTH(out, contentLength);

if (contentLanguages.size() > 0)

{

Line 2024

Line 1796

}

if (httpMethod == HTTP_METHOD_M_POST)

{

out << STRLIT("Ext:\r\n");

out << STRLIT("Ext:\r\n"

out << STRLIT("Cache-Control: no-cache\r\n");

"Cache-Control: no-cache\r\n"

out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");

"Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");

out << nn << STRLIT("\r\n");

out << nn << STRLIT("-CIMOperation: MethodResponse\r\n\r\n");

}

Line 2079

Line 1851

// Returns unauthorized message in the following format:

// HTTP/1.1 401 Unauthorized

// WWW-Authenticate: Basic "hostname:80"

// WWW-Authenticate: Basic realm="HostName"

// <HTML><HEAD>

// <TITLE>401 Unauthorized</TITLE>

// </HEAD><BODY BGCOLOR="#99cc99">

Line 2094

Line 1866

const String& content)

{

out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n");

out << content << STRLIT("\r\n");

OUTPUT_CONTENTLENGTH(out, 0);

out << STRLIT("\r\n");

out << content << STRLIT("\r\n\r\n");

//ATTN: We may need to include the following line, so that the browsers

// can display the error message.

Line 2137

Line 1909

// is usually intended to have content. But, for Kerberos this

// may not always be the case so we need to indicate that there

// is no content

Uint32 contentLength = 0;

OUTPUT_CONTENTLENGTH(out, 0);

OUTPUT_CONTENTLENGTH;

out << content << STRLIT("\r\n\r\n");

out << content << STRLIT("\r\n");

out << STRLIT("\r\n");

//ATTN: We may need to include the following line, so that the browsers

// can display the error message.

Line 2169

Line 1939

Buffer& out,

const String& messageId)

{

out << STRLIT("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");

out << STRLIT("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"

out << STRLIT("<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n");

"<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n"

out << STRLIT("<MESSAGE ID=\"") << messageId;

"<MESSAGE ID=\"") << messageId;

out << STRLIT("\" PROTOCOLVERSION=\"1.0\">\n");

}

void XmlWriter::_appendMessageElementEnd(

Buffer& out)

{

out << STRLIT("</MESSAGE>\n");

out << STRLIT("</MESSAGE>\n</CIM>\n");

out << STRLIT("</CIM>\n");

}

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

Line 2353

Line 2122

{

Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);

out << STRLIT("<ERROR");

out << STRLIT("<ERROR CODE=\"") << Uint32(cimException.getCode());

out << STRLIT(" CODE=\"") << Uint32(cimException.getCode());

out.append('"');

String description = TraceableCIMException(cimException).getDescription();

Line 2379

Line 2147

out << STRLIT("/>");

}

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

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

// appendReturnValueElement()

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

// appendParamTypeAndEmbeddedObjAttrib

// <!ATTLIST RETURNVALUE

// Appends the Param type and EmbeddedObject Info to the buffer

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

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

void XmlWriter::appendReturnValueElement(

void XmlWriter::appendParamTypeAndEmbeddedObjAttrib(

Buffer& out,

const CIMValue& value)

const CIMType& type)

{

out << STRLIT("<RETURNVALUE");

CIMType type = value.getType();

// If the property type is CIMObject, then

// encode the property in CIM-XML as a string with the EMBEDDEDOBJECT

// encode the property in CIM-XML as a string with the EmbeddedObject

// attribute (there is not currently a CIM-XML "object" datatype)

// attribute (there is not currently a CIM-XML "object"

// datatype).

// Because of an error in Pegasus we were earlier outputting

// upper case "EMBEDDEDOBJECT" as the attribute name. The

// spec calls for mixed case "EmbeddedObject. Fixed in

// bug 7131 to output EmbeddedObject attribute in upper

// case and mixed case. Receiver will ignore one or the

// other.

// else

// output the real type

if (type == CIMTYPE_OBJECT)

{

out << STRLIT(" PARAMTYPE=\"string\"");

out << STRLIT(" EMBEDDEDOBJECT=\"object\"");

out << STRLIT(" PARAMTYPE=\"string\""

" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

else if (type == CIMTYPE_INSTANCE)

{

out << STRLIT(" PARAMTYPE=\"string\"");

out << STRLIT(" PARAMTYPE=\"string\""

out << STRLIT(" EMBEDDEDOBJECT=\"instance\"");

" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

else

{

out << STRLIT(" PARAMTYPE=\"") << cimTypeToString (type);

out << STRLIT(" PARAM") << _XmlWriterTypeStrings[type];

out.append('"');

}

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

// appendReturnValueElement()

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendReturnValueElement(

Buffer& out,

const CIMValue& value)

{

out << STRLIT("<RETURNVALUE");

CIMType type = value.getType();

appendParamTypeAndEmbeddedObjAttrib(out, type);

out << STRLIT(">\n");

// Add value.

Line 2750

Line 2543

return tmp;

}

//PEP 128 adding serverRsponseTime to header

Buffer XmlWriter::formatSimpleMethodRspMessage(

const CIMName& methodName,

const String& messageId,

Line 2990

Line 2782

{

out << STRLIT("POST ") << requestUri << STRLIT(" HTTP/1.1\r\n");

}

out << STRLIT("HOST: ") << host << STRLIT("\r\n");

out << STRLIT("HOST: ") << host << STRLIT("\r\n"

out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");

"Content-Type: application/xml; charset=\"utf-8\"\r\n");

OUTPUT_CONTENTLENGTH;

OUTPUT_CONTENTLENGTH(out, contentLength);

if (acceptLanguages.size() > 0)

{

Line 3026

Line 2818

}

else

{

out << STRLIT("CIMExport: MethodRequest\r\n");

out << STRLIT("CIMExport: MethodRequest\r\n"

out << STRLIT("CIMExportMethod: ") << cimMethod << STRLIT("\r\n");

"CIMExportMethod: ") << cimMethod << STRLIT("\r\n");

}

if (authenticationHeader.size())

Line 3054

Line 2846

{

char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };

out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");

out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n"

out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");

"Content-Type: application/xml; charset=\"utf-8\"\r\n");

OUTPUT_CONTENTLENGTH;

OUTPUT_CONTENTLENGTH(out, contentLength);

if (contentLanguages.size() > 0)

{

Line 3065

Line 2857

}

if (httpMethod == HTTP_METHOD_M_POST)

{

out << STRLIT("Ext:\r\n");

out << STRLIT("Ext:\r\n"

out << STRLIT("Cache-Control: no-cache\r\n");

"Cache-Control: no-cache\r\n"

out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");

"Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");

out << nn << STRLIT("\r\n");

out << nn << STRLIT("-CIMExport: MethodResponse\r\n\r\n");

}

Line 3316

Line 3108

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

// _xmlWritter_printAttributes()

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

void _xmlWritter_printAttributes(

PEGASUS_STD(ostream)& os,

const XmlAttribute* attributes,

Uint32 attributeCount)

{

for (Uint32 i = 0; i < attributeCount; i++)

{

os << attributes[i].name << "=";

os << '"';

_xmlWritter_appendSpecial(os, attributes[i].value);

os << '"';

if (i + 1 != attributeCount)

os << ' ';

}

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

// _xmlWritter_indent()

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

void _xmlWritter_indent(

PEGASUS_STD(ostream)& os,

Uint32 level,

Uint32 indentChars)

{

Uint32 n = level * indentChars;

for (Uint32 i = 0; i < n; i++)

os << ' ';

}

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

// indentedPrint()

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

void XmlWriter::indentedPrint(

PEGASUS_STD(ostream)& os,

const char* text,

Uint32 indentChars)

{

AutoArrayPtr<char> tmp(strcpy(new char[strlen(text) + 1], text));

XmlParser parser(tmp.get());

XmlEntry entry;

Stack<const char*> stack;

while (parser.next(entry))

{

switch (entry.type)

{

case XmlEntry::XML_DECLARATION:

{

_xmlWritter_indent(os, stack.size(), indentChars);

os << "<?" << entry.text << " ";

_xmlWritter_printAttributes(

os, entry.attributes, entry.attributeCount);

os << "?>";

break;

}

case XmlEntry::START_TAG:

{

_xmlWritter_indent(os, stack.size(), indentChars);

os << "<" << entry.text;

if (entry.attributeCount)

os << ' ';

_xmlWritter_printAttributes(

os, entry.attributes, entry.attributeCount);

os << ">";

stack.push(entry.text);

break;

}

case XmlEntry::EMPTY_TAG:

{

_xmlWritter_indent(os, stack.size(), indentChars);

os << "<" << entry.text << " ";

_xmlWritter_printAttributes(

os, entry.attributes, entry.attributeCount);

os << "/>";

break;

}

case XmlEntry::END_TAG:

{

if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)

stack.pop();

_xmlWritter_indent(os, stack.size(), indentChars);

os << "</" << entry.text << ">";

break;

}

case XmlEntry::COMMENT:

{

_xmlWritter_indent(os, stack.size(), indentChars);

os << "<!--";

_xmlWritter_appendSpecial(os, entry.text);

os << "-->";

break;

}

case XmlEntry::CONTENT:

{

_xmlWritter_indent(os, stack.size(), indentChars);

_xmlWritter_appendSpecial(os, entry.text);

break;

}

case XmlEntry::CDATA:

{

_xmlWritter_indent(os, stack.size(), indentChars);

os << "<![CDATA[" << entry.text << "]]>";

break;

}

case XmlEntry::DOCTYPE:

{

_xmlWritter_indent(os, stack.size(), indentChars);

os << "<!DOCTYPE...>";

break;

}

os << PEGASUS_STD(endl);

}

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

// XmlWriter::getNextMessageId()

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

Line 3483

Line 3129

// XmlWriter::keyBindingTypeToString

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

const char* XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type)

const StrLit XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type)

{

switch (type)

{

case CIMKeyBinding::BOOLEAN:

return "boolean";

return STRLIT("boolean");

case CIMKeyBinding::STRING:

return "string";

return STRLIT("string");

case CIMKeyBinding::NUMERIC:

return "numeric";

return STRLIT("numeric");

case CIMKeyBinding::REFERENCE:

default:

PEGASUS_ASSERT(false);

}

return "unknown";

return STRLIT("unknown");

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.152
changed lines
	Added in v.1.162

No CVS admin address has been configured