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.116 and 1.169.4.8

version 1.116, 2005/02/05 22:59:24

version 1.169.4.8, 2013/09/19 10:56:58

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: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)

// Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101

// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1

// Willis White (whiwill@us.ibm.com) PEP 127 and 128

// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2

// Dave Sudlik, IBM (dsudlik@us.ibm.com)

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

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

Line 66

Line 51

#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 "IDFactory.h"

#include "StringConversion.h"

PEGASUS_NAMESPACE_BEGIN

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

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

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

out << "content-length: " << contentLengthP << "\r\n"; \

}

Array<char>& operator<<(Array<char>& out, const char* x)

{

XmlWriter::append(out, x);

return out;

}

Array<char>& operator<<(Array<char>& out, char x)

{

XmlWriter::append(out, x);

return out;

}

Array<char>& operator<<(Array<char>& out, const Char16& x)

{

XmlWriter::append(out, x);

return out;

}

Array<char>& operator<<(Array<char>& out, const String& x)

{

XmlWriter::append(out, x);

return out;

}

Array<char>& operator<<(Array<char>& out, const Indentor& x)

{

XmlWriter::append(out, x);

return out;

}

Array<char>& operator<<(Array<char>& out, const Array<char>& x)

{

out.appendArray(x);

return out;

}

Array<char>& operator<<(Array<char>& out, Uint32 x)

{

XmlWriter::append(out, x);

return out;

}

Array<char>& operator<<(Array<char>& out, const CIMName& name)

{

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

return out;

}

// l10n

Array<char>& operator<<(Array<char>& out, const AcceptLanguages& al)

{

XmlWriter::append(out, al.toString ());

return out;

}

// l10n

Array<char>& operator<<(Array<char>& out, const ContentLanguages& cl)

{

XmlWriter::append(out, cl.toString ());

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;

}

inline void _xmlWritter_appendChar(Array<char>& 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 _xmlWritter_appendSpecialChar(Array<char>& out, const Char16& c)

{

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

{

char charref[7];

sprintf(charref, "&#%u;", (Uint16)c);

out.append(charref, strlen(charref));

}

else

{

switch (c)

{

case '&':

out.append("&", 5);

break;

case '<':

out.append("<", 4);

break;

case '>':

out.append(">", 4);

break;

case '"':

out.append(""", 6);

break;

case '\'':

out.append("'", 6);

break;

default:

{

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

const char* charIN = reinterpret_cast<const char *>(&c);

const Uint16 *strsrc = (const Uint16 *)charIN;

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

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_appendSpecialChar(Array<char>& out, char c)

{

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

{

char charref[7];

sprintf(charref, "&#%u;", (Uint8)c);

out.append(charref, strlen(charref));

}

else

{

switch (c)

{

case '&':

out.append("&", 5);

break;

case '<':

out.append("<", 4);

break;

case '>':

out.append(">", 4);

break;

case '"':

out.append(""", 6);

break;

case '\'':

out.append("'", 6);

break;

default:

out.append(Sint8(c));

}

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

{

if ( (c < Char16(0x20)) || (c == Char16(0x7f)) )

{

char charref[7];

sprintf(charref, "&#%u;", (Uint8)c);

os << charref;

}

else

{

switch (c)

{

case '&':

os << "&";

break;

case '<':

os << "<";

break;

case '>':

os << ">";

break;

case '"':

os << """;

break;

case '\'':

os << "'";

break;

default:

os << c;

}

void _xmlWritter_appendSurrogatePair(Array<char>& 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++);

}

void XmlWriter::append(Array<char>& out, const Char16& x)

{

_xmlWritter_appendChar(out, x);

}

void XmlWriter::append(Array<char>& out, Boolean x)

{

append(out, (x ? "TRUE" : "FALSE"));

}

void XmlWriter::append(Array<char>& out, Uint32 x)

{

char buffer[32];

sprintf(buffer, "%u", x);

append(out, buffer);

}

void XmlWriter::append(Array<char>& out, Sint32 x)

{

char buffer[32];

sprintf(buffer, "%d", x);

append(out, buffer);

}

void XmlWriter::append(Array<char>& out, Uint64 x)

{

char buffer[32]; // Should need 21 chars max

sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);

append(out, buffer);

}

void XmlWriter::append(Array<char>& out, Sint64 x)

{

char buffer[32]; // Should need 21 chars max

sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);

append(out, buffer);

}

void XmlWriter::append(Array<char>& 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);

append(out, buffer);

}

void XmlWriter::append(Array<char>& 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);

append(out, buffer);

}

void XmlWriter::append(Array<char>& out, const char* str)

{

while (*str)

XmlWriter::append(out, *str++);

}

void XmlWriter::append(Array<char>& out, const String& str)

{

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

{

Uint16 c = str[i];

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

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

{

Char16 highSurrogate = str[i];

Char16 lowSurrogate = str[++i];

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

}

else

{

_xmlWritter_appendChar(out, str[i]);

}

void XmlWriter::append(Array<char>& out, const Indentor& x)

{

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

out.append(' ');

}

void XmlWriter::appendSpecial(Array<char>& out, const Char16& x)

{

_xmlWritter_appendSpecialChar(out, x);

}

void XmlWriter::appendSpecial(Array<char>& out, char x)

{

_xmlWritter_appendSpecialChar(out, x);

}

void XmlWriter::appendSpecial(Array<char>& out, const char* str)

{

while (*str)

_xmlWritter_appendSpecialChar(out, *str++);

}

void XmlWriter::appendSpecial(Array<char>& out, const String& str)

{

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

{

Uint16 c = str[i];

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

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

{

Char16 highSurrogate = str[i];

Char16 lowSurrogate = str[++i];

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

}

else

{

_xmlWritter_appendSpecialChar(out, str[i]);

}

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

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

// Excluded characters:

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

// Space character = 0x20

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

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

inline void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)

{

Uint8 c = (Uint8)char8;

#ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING

if ( (c <= 0x20) || // Control characters + space char

( (c >= 0x22) && (c <= 0x26) ) || // '"' '#' '$' '%' '&'

(c == 0x2b) || // '+'

(c == 0x2c) || // ','

(c == 0x2f) || // '/'

( (c >= 0x3a) && (c <= 0x40) ) || // ':' ';' '<' '=' '>' '?' '@'

( (c >= 0x5b) && (c <= 0x5e) ) || // '[' '\\' ']' '^'

(c == 0x60) || // '`'

( (c >= 0x7b) && (c <= 0x7d) ) || // '{' '|' '}'

(c >= 0x7f) ) // Control character or non US-ASCII (UTF-8)

{

char hexencoding[4];

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

outString.append(hexencoding);

}

else

#endif

{

outString.append((Uint16)c);

}

String XmlWriter::encodeURICharacters(Array<char> uriString)

{

String encodedString;

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

{

_xmlWritter_encodeURIChar(encodedString, uriString[i]);

}

return encodedString;

}

String XmlWriter::encodeURICharacters(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)

Array<char> 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 589

Line 69

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

void XmlWriter::appendLocalNameSpacePathElement(

Array<char>& out,

Buffer& out,

const CIMNamespaceName& nameSpace)

{

out << "<LOCALNAMESPACEPATH>\n";

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

char* nameSpaceCopy = strdup(nameSpace.getString().getCString());

#if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \

#if !defined(PEGASUS_COMPILER_MSVC) && !defined(PEGASUS_OS_ZOS)

defined(PEGASUS_OS_HPUX) || \

defined(PEGASUS_OS_LINUX)

char *last;

for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;

p = strtok_r(NULL, "/", &last))

Line 606

Line 84

for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))

#endif

{

out << "<NAMESPACE NAME=\"" << p << "\"/>\n";

out << STRLIT("<NAMESPACE NAME=\"") << p << STRLIT("\"/>\n");

}

free(nameSpaceCopy);

out << "</LOCALNAMESPACEPATH>\n";

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

}

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

Line 622

Line 100

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

void XmlWriter::appendNameSpacePathElement(

Array<char>& out,

Buffer& out,

const String& host,

const CIMNamespaceName& nameSpace)

{

out << "<NAMESPACEPATH>\n";

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

out << "<HOST>" << host << "</HOST>\n";

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

appendLocalNameSpacePathElement(out, nameSpace);

out << "</NAMESPACEPATH>\n";

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

}

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

Line 643

Line 121

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

void XmlWriter::appendClassNameElement(

Array<char>& out,

Buffer& out,

const CIMName& className)

{

out << "<CLASSNAME NAME=\"" << className << "\"/>\n";

out << STRLIT("<CLASSNAME NAME=\"") << className << STRLIT("\"/>\n");

}

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

Line 660

Line 138

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

void XmlWriter::appendInstanceNameElement(

Array<char>& out,

Buffer& out,

const CIMObjectPath& instanceName)

{

out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";

out << STRLIT("<INSTANCENAME CLASSNAME=\"");

out << instanceName.getClassName() << STRLIT("\">\n");

Array<CIMKeyBinding> keyBindings = instanceName.getKeyBindings();

const Array<CIMKeyBinding>& keyBindings = instanceName.getKeyBindings();

for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)

{

out << "<KEYBINDING NAME=\"" << keyBindings[i].getName() << "\">\n";

out << STRLIT("<KEYBINDING NAME=\"");

out << keyBindings[i].getName() << STRLIT("\">\n");

if (keyBindings[i].getType() == CIMKeyBinding::REFERENCE)

{

CIMObjectPath ref = keyBindings[i].getValue();

appendValueReferenceElement(out, ref, true);

// create an instancePath (i.e. isClassPath = false)

appendValueReferenceElement(out, ref, false, true);

}

else {

else

out << "<KEYVALUE VALUETYPE=\"";

{

out << STRLIT("<KEYVALUE VALUETYPE=\"");

out << keyBindingTypeToString(keyBindings[i].getType());

out << "\">";

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

// fixed the special character problem - Markus

// fixed the special characters

appendSpecial(out, keyBindings[i].getValue());

out << "</KEYVALUE>\n";

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

}

out << "</KEYBINDING>\n";

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

}

out << "</INSTANCENAME>\n";

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

}

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

Line 699

Line 181

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

void XmlWriter::appendClassPathElement(

Array<char>& out,

Buffer& out,

const CIMObjectPath& classPath)

{

out << "<CLASSPATH>\n";

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

appendNameSpacePathElement(out,

classPath.getHost(),

classPath.getNameSpace());

appendClassNameElement(out, classPath.getClassName());

out << "</CLASSPATH>\n";

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

}

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

Line 719

Line 201

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

void XmlWriter::appendInstancePathElement(

Array<char>& out,

Buffer& out,

const CIMObjectPath& instancePath)

{

out << "<INSTANCEPATH>\n";

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

appendNameSpacePathElement(out,

instancePath.getHost(),

instancePath.getNameSpace());

appendInstanceNameElement(out, instancePath);

out << "</INSTANCEPATH>\n";

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

}

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

Line 739

Line 221

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

void XmlWriter::appendLocalClassPathElement(

Array<char>& out,

Buffer& out,

const CIMObjectPath& classPath)

{

out << "<LOCALCLASSPATH>\n";

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

appendLocalNameSpacePathElement(out, classPath.getNameSpace());

appendClassNameElement(out, classPath.getClassName());

out << "</LOCALCLASSPATH>\n";

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

}

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

Line 757

Line 239

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

void XmlWriter::appendLocalInstancePathElement(

Array<char>& out,

Buffer& out,

const CIMObjectPath& instancePath)

{

out << "<LOCALINSTANCEPATH>\n";

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

appendLocalNameSpacePathElement(out, instancePath.getNameSpace());

appendInstanceNameElement(out, instancePath);

out << "</LOCALINSTANCEPATH>\n";

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

}

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

Line 775

Line 257

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

// appendValueReferenceElement does this correctly with isClassPath flag

// Called only but formatSimple

void XmlWriter::appendLocalObjectPathElement(

Array<char>& out,

Buffer& out,

const CIMObjectPath& objectPath)

{

Line 784

Line 268

// distinguish instanceNames from classNames in every case

// The instanceName of a singleton instance of a keyless class has no

// key bindings

// See bBUG_3302.

if (objectPath.getKeyBindings ().size () != 0)

{

Line 801

Line 286

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

inline void _xmlWritter_appendValue(Array<char>& out, Boolean x)

inline void _xmlWritter_appendValue(Buffer& out, Boolean x)

{

XmlWriter::append(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, Uint8 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint8 x)

{

XmlWriter::append(out, Uint32(x));

}

inline void _xmlWritter_appendValue(Array<char>& out, Sint8 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint8 x)

{

XmlWriter::append(out, Sint32(x));

}

inline void _xmlWritter_appendValue(Array<char>& out, Uint16 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint16 x)

{

XmlWriter::append(out, Uint32(x));

}

inline void _xmlWritter_appendValue(Array<char>& out, Sint16 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint16 x)

{

XmlWriter::append(out, Sint32(x));

}

inline void _xmlWritter_appendValue(Array<char>& out, Uint32 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint32 x)

{

XmlWriter::append(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, Sint32 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint32 x)

{

XmlWriter::append(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, Uint64 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint64 x)

{

XmlWriter::append(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, Sint64 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint64 x)

{

XmlWriter::append(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, Real32 x)

inline void _xmlWritter_appendValue(Buffer& out, Real32 x)

{

XmlWriter::append(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, Real64 x)

inline void _xmlWritter_appendValue(Buffer& out, Real64 x)

{

XmlWriter::append(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, const Char16& x)

inline void _xmlWritter_appendValue(Buffer& out, const Char16& x)

{

XmlWriter::appendSpecial(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, const String& x)

inline void _xmlWritter_appendValue(Buffer& out, const String& x)

{

XmlWriter::appendSpecial(out, x);

}

inline void _xmlWritter_appendValue(Array<char>& out, const CIMDateTime& x)

inline void _xmlWritter_appendValue(Buffer& out, const CIMDateTime& x)

{

out << x.toString(); //ATTN: append() method?

// It is not necessary to use XmlWriter::appendSpecial(), because

// CIMDateTime values do not contain special characters.

out << x.toString();

}

inline void _xmlWritter_appendValue(Array<char>& out, const CIMObjectPath& x)

inline void _xmlWritter_appendValue(Buffer& out, const CIMObjectPath& x)

{

XmlWriter::appendValueReferenceElement(out, x, true);

// Emit Instance Path with value wrapper

XmlWriter::appendValueReferenceElement(out, x, false, true);

}

// DJS -- temporary for testing until encode/decode issues resolved

inline void _xmlWritter_appendValue(Buffer& out, const CIMObject& x)

inline void _xmlWritter_appendValue(Array<char>& out, const CIMObject& x)

{

out << x.toString();

String myStr = x.toString();

_xmlWritter_appendValue(out, myStr);

}

void _xmlWritter_appendValueArray(Array<char>& out, const CIMObjectPath* p, Uint32 size)

void _xmlWritter_appendValueArray(

Buffer& out, const CIMObjectPath* p, Uint32 size)

{

out << "<VALUE.REFARRAY>\n";

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

while (size--)

{

_xmlWritter_appendValue(out, *p++);

}

out << "</VALUE.REFARRAY>\n";

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

}

template<class T>

void _xmlWritter_appendValueArray(Array<char>& out, const T* p, Uint32 size)

void _xmlWritter_appendValueArray(Buffer& out, const T* p, Uint32 size)

{

out << "<VALUE.ARRAY>\n";

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

while (size--)

{

out << "<VALUE>";

out << STRLIT("<VALUE>");

_xmlWritter_appendValue(out, *p++);

out << "</VALUE>\n";

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

}

out << "</VALUE.ARRAY>\n";

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

}

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

Line 921

Line 410

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

void XmlWriter::appendValueElement(

Array<char>& out,

Buffer& out,

const CIMValue& value)

{

if (value.isNull())

Line 1030

Line 519

case CIMTYPE_STRING:

{

Array<String> a;

const String* data;

value.get(a);

Uint32 size;

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

value._get(data, size);

_xmlWritter_appendValueArray(out, data, size);

break;

}

Line 1052

Line 542

break;

}

// DJS -- temporary for testing until encode/decode issues resolved

case CIMTYPE_OBJECT:

{

Array<CIMObject> a;

value.get(a);

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

break;

}

case CIMTYPE_INSTANCE:

{

Array<CIMInstance> a;

value.get(a);

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

break;

}

default:

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

else if (value.getType() == CIMTYPE_REFERENCE)

Line 1074

Line 569

}

else

{

out << "<VALUE>";

out << STRLIT("<VALUE>");

switch (value.getType())

{

Line 1190

Line 685

break;

}

// DJS -- temporary for testing until encode/decode issues resolved

case CIMTYPE_OBJECT:

{

CIMObject v;

Line 1198

Line 692

_xmlWritter_appendValue(out, v);

break;

}

case CIMTYPE_INSTANCE:

{

CIMInstance v;

value.get(v);

_xmlWritter_appendValue(out, v);

break;

}

default:

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

out << "</VALUE>\n";

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

}

Line 1211

Line 711

const CIMValue& value,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendValueElement(tmp, value);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1227

Line 726

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

void XmlWriter::appendValueObjectWithPathElement(

Array<char>& out,

Buffer& out,

const CIMObject& objectWithPath)

const CIMObject& objectWithPath,

Boolean includeQualifiers,

Boolean includeClassOrigin,

Boolean isClassObject,

const CIMPropertyList& propertyList)

{

out << "<VALUE.OBJECTWITHPATH>\n";

out << STRLIT("<VALUE.OBJECTWITHPATH>\n");

appendValueReferenceElement(out, objectWithPath.getPath (),

isClassObject , false);

appendValueReferenceElement(out, objectWithPath.getPath (), false);

appendObjectElement(

appendObjectElement(out, objectWithPath);

out,

objectWithPath,

includeQualifiers,

includeClassOrigin,

propertyList);

out << "</VALUE.OBJECTWITHPATH>\n";

out << STRLIT("</VALUE.OBJECTWITHPATH>\n");

}

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

Line 1248

Line 758

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

void XmlWriter::appendValueReferenceElement(

// appends INSTANCEPATH | LOCALINSTANCEPATH | INSTANCENAME

Array<char>& out,

void XmlWriter::appendValueInstancePathElement(

const CIMObjectPath& reference,

Buffer& out,

Boolean putValueWrapper)

const CIMObjectPath& reference)

{

if (putValueWrapper)

out << "<VALUE.REFERENCE>\n";

// See if it is a class or instance reference (instance references have

// key-bindings; class references do not).

// ATTN-CAKG-P2-20020726: The following condition does not correctly

// distinguish instanceNames from classNames in every case

// The instanceName of a singleton instance of a keyless class has no

// key bindings

Array<CIMKeyBinding> kbs = reference.getKeyBindings();

if (kbs.size())

{

if (reference.getHost().size())

{

Line 1282

Line 776

appendInstanceNameElement(out, reference);

}

else

// appends CLASSPATH | LOCALCLASSPATH | CLASSNAME

void XmlWriter::appendValueClassPathElement(

Buffer& out,

const CIMObjectPath& reference)

{

if (reference.getHost().size())

{

Line 1298

Line 796

}

if (putValueWrapper)

// Builds either a classPath or InstancePath based on isClassPath

out << "</VALUE.REFERENCE>\n";

// parameter which was carried forward from, for example, the

// request. If wrapper true, wrap output with <VALUE.REFERENCE>

void XmlWriter::appendValueReferenceElement(

Buffer& out,

const CIMObjectPath& reference,

Boolean isClassPath,

Boolean addValueWrapper)

{

if (addValueWrapper)

{

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

}

if (isClassPath)

{

appendValueClassPathElement(out,reference);

}

else

{

appendValueInstancePathElement(out,reference);

}

if (addValueWrapper)

{

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

}

void XmlWriter::printValueReferenceElement(

const CIMObjectPath& reference,

Boolean isClassPath,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendValueReferenceElement(tmp, reference, true);

appendValueReferenceElement(tmp, reference, isClassPath, true);

tmp.append('\0');

indentedPrint(os, tmp.getData());

}

Line 1321

Line 843

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

void XmlWriter::appendValueNamedInstanceElement(

Array<char>& out,

Buffer& out,

const CIMInstance& namedInstance)

const CIMInstance& namedInstance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

out << "<VALUE.NAMEDINSTANCE>\n";

out << STRLIT("<VALUE.NAMEDINSTANCE>\n");

appendInstanceNameElement(out, namedInstance.getPath ());

appendInstanceElement(out, namedInstance);

appendInstanceElement(

out,

namedInstance,

includeQualifiers,

includeClassOrigin,

propertyList);

out << "</VALUE.NAMEDINSTANCE>\n";

out << STRLIT("</VALUE.NAMEDINSTANCE>\n");

}

//EXP_PULL_BEGIN

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

// appendValueInstanceWithPathElement()

// <!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH,INSTANCE)>

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

void XmlWriter::appendValueInstanceWithPathElement(

Buffer& out,

const CIMInstance& namedInstance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");

appendInstancePathElement(out, namedInstance.getPath ());

appendInstanceElement(

out,

namedInstance,

includeQualifiers,

includeClassOrigin,

propertyList);

out << STRLIT("</VALUE.INSTANCEWITHPATH>\n");

}

//EXP_PULL_END

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

// appendClassElement()

Line 1345

Line 904

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

void XmlWriter::appendClassElement(

Array<char>& out,

Buffer& out,

const CIMConstClass& cimclass)

const CIMConstClass& cimClass)

{

CheckRep(cimClass._rep);

const CIMClassRep* rep = cimClass._rep;

// Class opening element:

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

<< rep->getClassName()

<< STRLIT("\" ");

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

{

cimclass._checkRep();

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

cimclass._rep->toXml(out);

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

const CIMConstClass& cimclass,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendClassElement(tmp, cimclass);

tmp.append('\0');

indentedPrint(os, tmp.getData(), 4);

}

Line 1374

Line 966

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

void XmlWriter::appendInstanceElement(

Array<char>& out,

Buffer& out,

const CIMConstInstance& instance)

const CIMConstInstance& instance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

CheckRep(instance._rep);

const CIMInstanceRep* rep = instance._rep;

// Class opening element:

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

<< rep->getClassName()

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

// Append Instance Qualifiers:

if(includeQualifiers)

{

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

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

}

if(propertyList.isNull())

{

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

{

XmlWriter::appendPropertyElement(

out,

rep->getProperty(i),

includeQualifiers,includeClassOrigin);

}

else

{

for (Uint32 i = 0, n = propertyList.size(); i < n; i++)

{

instance._checkRep();

CIMName name = propertyList[i];

instance._rep->toXml(out);

Uint32 pos = rep->_properties.find(

propertyList[i],

propertyList.getCIMNameTag(i));

if(pos != PEG_NOT_FOUND)

{

PEG_TRACE((TRC_XML,Tracer::LEVEL4,

"XmlWriter::appendInstanceElement"

" Filtering the property name:%s for the className:%s"

"since it was not filtered by the provider.",

(const char *)name.getString().getCString(),

(const char *)instance.getClassName().

getString().getCString()));

XmlWriter::appendPropertyElement(

out,

rep->getProperty(pos),

includeQualifiers,includeClassOrigin);

}

// Instance closing element:

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

}

void XmlWriter::printInstanceElement(

const CIMConstInstance& instance,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendInstanceElement(tmp, instance);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1400

Line 1047

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

void XmlWriter::appendObjectElement(

Array<char>& out,

Buffer& out,

const CIMConstObject& object)

const CIMConstObject& object,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

if (object.isClass())

{

Line 1411

Line 1061

else if (object.isInstance())

{

CIMConstInstance i(object);

appendInstanceElement(out, i);

appendInstanceElement(

out,

includeQualifiers,

includeClassOrigin,

propertyList);

}

// else PEGASUS_ASSERT(0);

}

Line 1445

Line 1100

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

void XmlWriter::appendPropertyElement(

Array<char>& out,

Buffer& out,

const CIMConstProperty& property)

const CIMConstProperty& property,

Boolean includeQualifiers,

Boolean includeClassOrigin)

{

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(includeClassOrigin && !rep->getClassOrigin().isNull())

{

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

out.append('"');

}

if (rep->getPropagated())

{

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

}

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

if(includeQualifiers)

{

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(includeClassOrigin && !rep->getClassOrigin().isNull())

{

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

out.append('"');

}

if (rep->getPropagated())

{

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

}

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

if(includeQualifiers)

{

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(includeClassOrigin && !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

{

out.append(' ');

out << xmlWriterTypeStrings(rep->getValue().getType());

}

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

if(includeQualifiers)

{

property._checkRep();

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

property._rep->toXml(out);

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

}

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

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

}

void XmlWriter::printPropertyElement(

const CIMConstProperty& property,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendPropertyElement(tmp, property);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1477

Line 1381

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

void XmlWriter::appendMethodElement(

Array<char>& out,

Buffer& out,

const CIMConstMethod& method)

{

method._checkRep();

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(

const CIMConstMethod& method,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendMethodElement(tmp, method);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1523

Line 1452

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

void XmlWriter::appendParameterElement(

Array<char>& out,

Buffer& out,

const CIMConstParameter& parameter)

{

parameter._checkRep();

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(

const CIMConstParameter& parameter,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendParameterElement(tmp, parameter);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1546

Line 1559

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

// <!ATTLIST PARAMVALUE

// %CIMName;>

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendParamValueElement(

Array<char>& out,

Buffer& out,

const CIMParamValue& paramValue)

{

paramValue._checkRep();

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(

const CIMParamValue& paramValue,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendParamValueElement(tmp, paramValue);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1582

Line 1611

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

void XmlWriter::appendQualifierElement(

Array<char>& out,

Buffer& out,

const CIMConstQualifier& qualifier)

{

qualifier._checkRep();

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(

const CIMConstQualifier& qualifier,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendQualifierElement(tmp, qualifier);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1613

Line 1657

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

void XmlWriter::appendQualifierDeclElement(

Array<char>& out,

Buffer& out,

const CIMConstQualifierDecl& qualifierDecl)

{

qualifierDecl._checkRep();

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(

const CIMConstQualifierDecl& qualifierDecl,

PEGASUS_STD(ostream)& os)

{

Array<char> tmp;

Buffer tmp;

appendQualifierDeclElement(tmp, qualifierDecl);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1640

Line 1707

// TOINSTANCE (true|false) 'false'

// TRANSLATABLE (true|false) 'false'">

// DEPRECATION NOTE: The attribute TOINSTANCE is DEPRECATED and MAY be

// removed from the QualifierFlavor entity in a future version of this

// document. Use of this qualifier is discouraged.

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

void XmlWriter::appendQualifierFlavorEntity(

Array<char>& out,

Buffer& out,

const CIMFlavor & flavor)

{

if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))

out << " OVERRIDABLE=\"false\"";

out << STRLIT(" OVERRIDABLE=\"false\"");

if (!(flavor.hasFlavor (CIMFlavor::TOSUBCLASS)))

out << " TOSUBCLASS=\"false\"";

out << STRLIT(" TOSUBCLASS=\"false\"");

if (flavor.hasFlavor (CIMFlavor::TOINSTANCE))

//if (flavor.hasFlavor (CIMFlavor::TOINSTANCE))

out << " TOINSTANCE=\"true\"";

// out << STRLIT(" TOINSTANCE=\"true\"");

if (flavor.hasFlavor (CIMFlavor::TRANSLATABLE))

out << " TRANSLATABLE=\"true\"";

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

}

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

Line 1676

Line 1747

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

void XmlWriter::appendScopeElement(

Array<char>& out,

Buffer& out,

const CIMScope & scope)

{

if (!(scope.equal (CIMScope ())))

{

out << "<SCOPE";

out << STRLIT("<SCOPE");

if (scope.hasScope (CIMScope::CLASS))

out << " CLASS=\"true\"";

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

if (scope.hasScope (CIMScope::ASSOCIATION))

out << " ASSOCIATION=\"true\"";

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

if (scope.hasScope (CIMScope::REFERENCE))

out << " REFERENCE=\"true\"";

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

if (scope.hasScope (CIMScope::PROPERTY))

out << " PROPERTY=\"true\"";

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

if (scope.hasScope (CIMScope::METHOD))

out << " METHOD=\"true\"";

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

if (scope.hasScope (CIMScope::PARAMETER))

out << " PARAMETER=\"true\"";

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

if (scope.hasScope (CIMScope::INDICATION))

out << " INDICATION=\"true\"";

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

out << "/>";

out << STRLIT("/>");

}

Line 1720

Line 1791

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

void XmlWriter::appendMethodCallHeader(

Array<char>& out,

Buffer& out,

const char* host,

const CIMName& cimMethod,

const String& cimObject,

const String& authenticationHeader,

HttpMethod httpMethod,

const AcceptLanguages & acceptLanguages,

const AcceptLanguageList& acceptLanguages,

const ContentLanguages & contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

Uint32 contentLength,

bool binaryRequest,

bool binaryResponse)

{

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

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

// ATTN: KS 20020926 - Temporary change to issue only POST. This may

// be changed in the DMTF CIM Operations standard in the future.

Line 1740

Line 1813

// installed. Required because of change to wbemservices cimom

if (httpMethod == HTTP_METHOD_M_POST)

{

out << "M-POST /cimom HTTP/1.1\r\n";

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

}

else

{

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

}

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

if (binaryRequest)

{

// Tell the server that the payload is encoded in the OpenPegasus

// binary protocol.

out << STRLIT("Content-Type: application/x-openpegasus\r\n");

}

else

{

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

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

}

if (binaryResponse)

{

// Tell the server that this client accepts the OpenPegasus binary

// protocol.

out << STRLIT("Accept: application/x-openpegasus\r\n");

}

out << "HOST: " << host << "\r\n";

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

OUTPUT_CONTENTLENGTH(out, contentLength);

OUTPUT_CONTENTLENGTH;

if (acceptLanguages.size() > 0)

{

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

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

}

if (contentLanguages.size() > 0)

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

#ifdef PEGASUS_DEBUG

Line 1766

Line 1858

static const char *clientTransferEncodingOff =

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')

#endif

out << "TE: chunked, trailers" << "\r\n";

if (!binaryResponse)

{

// The binary protocol does not allow chunking.

out << STRLIT("TE: chunked, trailers\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

out << nn <<"\r\n";

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

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

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

out << nn << "-CIMMethod: "

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

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

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

out << nn << "-CIMObject: " << encodeURICharacters(cimObject) << "\r\n";

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

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

}

else

{

out << "CIMOperation: MethodCall\r\n";

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

out << "CIMMethod: " << encodeURICharacters(cimMethod.getString())

out << STRLIT("CIMMethod: ")

<< "\r\n";

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

out << "CIMObject: " << encodeURICharacters(cimObject) << "\r\n";

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

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

}

if (authenticationHeader.size())

{

out << authenticationHeader << "\r\n";

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

}

out << "\r\n";

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

}

void XmlWriter::appendMethodResponseHeader(

Array<char>& out,

Buffer& out,

HttpMethod httpMethod,

const ContentLanguages & contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength,

Uint64 serverResponseTime)

Uint64 serverResponseTime,

bool binaryResponse)

{

// Optimize the typical case for binary messages, circumventing the

// more expensive logic below.

if (binaryResponse &&

contentLength == 0 &&

httpMethod != HTTP_METHOD_M_POST &&

contentLanguages.size() == 0)

{

static const char HEADERS[] =

"HTTP/1.1 200 OK\r\n"

"Content-Type: application/x-openpegasus\r\n"

"content-length: 0000000000\r\n"

"CIMOperation: MethodResponse\r\n"

"\r\n";

// The HTTP processor fills in the content-length value later.

// It searches for a field matching "content-length" (so the first

// character must be lower case).

out.append(HEADERS, sizeof(HEADERS) - 1);

return;

}

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

#ifndef PEGASUS_DISABLE_PERFINST

if (StatisticalData::current()->copyGSD)

{

out << STRLIT("WBEMServerResponseTime: ") <<

CIMValue(serverResponseTime).toString() << STRLIT("\r\n");

}

#endif

if (binaryResponse)

{

// According to MIME RFC, the "x-" prefix should be used for all

// non-registered values.

out << STRLIT("Content-Type: application/x-openpegasus\r\n");

}

else

{

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

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

out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";

}

STAT_SERVERTIME

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

OUTPUT_CONTENTLENGTH(out, contentLength);

OUTPUT_CONTENTLENGTH;

if (contentLanguages.size() > 0)

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

out << "Ext:\r\n";

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

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

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

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

out << nn <<"\r\n";

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

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

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

}

else

{

out << "CIMOperation: MethodResponse\r\n\r\n";

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

}

Line 1844

Line 1985

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

void XmlWriter::appendHttpErrorResponseHeader(

Array<char>& out,

Buffer& out,

const String& status,

const String& cimError,

const String& errorDetail)

{

out << "HTTP/1.1 " << status << "\r\n";

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

if (cimError != String::EMPTY)

{

out << "CIMError: " << cimError << "\r\n";

out << STRLIT("CIMError: ") << cimError << STRLIT("\r\n");

}

if (errorDetail != String::EMPTY)

{

// ATTN-RK-P3-20020404: It is critical that this text not contain '\n'

out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")

// ATTN-RK-P3-20020404: Need to encode this value properly. (See

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

// CIM/HTTP Specification section 3.3.2

out << PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": "

<< encodeURICharacters(errorDetail) << "\r\n";

}

out << "\r\n";

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

}

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

Line 1874

Line 2012

// Returns unauthorized message in the following format:

// HTTP/1.1 401 Unauthorized

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

// PGErrorDetail: <error text> (if specified by caller)

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

// <HTML><HEAD>

// <TITLE>401 Unauthorized</TITLE>

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

Line 1885

Line 2024

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

void XmlWriter::appendUnauthorizedResponseHeader(

Array<char>& out,

Buffer& out,

const String& errorDetail,

const String& content)

{

out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";

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

out << content << "\r\n";

if (errorDetail.size() > 0)

out << "\r\n";

{

out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")

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

}

OUTPUT_CONTENTLENGTH(out, 0);

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 1924

Line 2070

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

void XmlWriter::appendOKResponseHeader(

Array<char>& out,

Buffer& out,

const String& content)

{

out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";

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

// Content-Length header needs to be added because 200 OK record

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

out << "\r\n";

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

// can display the error message.

Line 1961

Line 2105

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

void XmlWriter::_appendMessageElementBegin(

Array<char>& out,

Buffer& out,

const String& messageId)

{

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

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

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

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

out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";

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

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

}

void XmlWriter::_appendMessageElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</MESSAGE>\n";

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

out << "</CIM>\n";

}

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

Line 1986

Line 2130

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

void XmlWriter::_appendSimpleReqElementBegin(

Array<char>& out)

Buffer& out)

{

out << "<SIMPLEREQ>\n";

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

}

void XmlWriter::_appendSimpleReqElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</SIMPLEREQ>\n";

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

}

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

Line 2008

Line 2152

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

void XmlWriter::_appendMethodCallElementBegin(

Array<char>& out,

Buffer& out,

const CIMName& name)

{

out << "<METHODCALL NAME=\"" << name << "\">\n";

out << STRLIT("<METHODCALL NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendMethodCallElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</METHODCALL>\n";

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

}

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

Line 2031

Line 2175

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

void XmlWriter::_appendIMethodCallElementBegin(

Array<char>& out,

Buffer& out,

const CIMName& name)

{

out << "<IMETHODCALL NAME=\"" << name << "\">\n";

out << STRLIT("<IMETHODCALL NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendIMethodCallElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</IMETHODCALL>\n";

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

}

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

Line 2056

Line 2200

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

void XmlWriter::_appendIParamValueElementBegin(

Array<char>& out,

Buffer& out,

const char* name)

{

out << "<IPARAMVALUE NAME=\"" << name << "\">\n";

out << STRLIT("<IPARAMVALUE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendIParamValueElementEnd(

Array<char>& out)

Buffer& out)

{

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

}

//EXP_PULL_BEGIN

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

// _appendParamValueElementBegin()

// _appendParamValueElementEnd()

// <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

// |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>

// <!ATTLIST IPARAMVALUE %CIMName;>

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

void XmlWriter::_appendParamValueElementBegin(

Buffer& out,

const char* name)

{

out << STRLIT("<PARAMVALUE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendParamValueElementEnd(

Buffer& out)

{

out << "</IPARAMVALUE>\n";

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

}

//EXP_PULL_END

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

Line 2078

Line 2249

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

void XmlWriter::_appendSimpleRspElementBegin(

Array<char>& out)

Buffer& out)

{

out << "<SIMPLERSP>\n";

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

}

void XmlWriter::_appendSimpleRspElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</SIMPLERSP>\n";

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

}

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

Line 2100

Line 2271

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

void XmlWriter::_appendMethodResponseElementBegin(

Array<char>& out,

Buffer& out,

const CIMName& name)

{

out << "<METHODRESPONSE NAME=\"" << name << "\">\n";

out << STRLIT("<METHODRESPONSE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendMethodResponseElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</METHODRESPONSE>\n";

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

}

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

Line 2123

Line 2294

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

void XmlWriter::_appendIMethodResponseElementBegin(

Array<char>& out,

Buffer& out,

const CIMName& name)

{

out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";

out << STRLIT("<IMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendIMethodResponseElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</IMETHODRESPONSE>\n";

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

}

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

Line 2142

Line 2313

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

void XmlWriter::_appendErrorElement(

Array<char>& out,

Buffer& out,

const CIMException& cimException)

{

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

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

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

out.append('"');

out << "<ERROR";

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

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

if (description != String::EMPTY)

{

out << " DESCRIPTION=\"";

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

appendSpecial(out, description);

out << "\"";

out.append('"');

}

if (cimException.getErrorCount())

{

out << STRLIT(">");

for (Uint32 i = 0, n = cimException.getErrorCount(); i < n; i++)

appendInstanceElement(out, cimException.getError(i));

out << STRLIT("</ERROR>");

}

else

out << STRLIT("/>");

}

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

// appendParamTypeAndEmbeddedObjAttrib

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

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendParamTypeAndEmbeddedObjAttrib(

Buffer& out,

const CIMType& type)

{

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

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

" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

else if (type == CIMTYPE_INSTANCE)

{

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

" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

}

else

{

out << STRLIT(" PARAM") << xmlWriterTypeStrings(type);

}

out << "/>";

}

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

Line 2165

Line 2394

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendReturnValueElement(

Array<char>& out,

Buffer& out,

const CIMValue& value)

{

out << "<RETURNVALUE";

out << STRLIT("<RETURNVALUE");

CIMType type = value.getType();

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

out << ">\n";

appendParamTypeAndEmbeddedObjAttrib(out, type);

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

// Add value.

appendValueElement(out, value);

out << "</RETURNVALUE>\n";

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

}

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

Line 2198

Line 2429

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

void XmlWriter::_appendIReturnValueElementBegin(

Array<char>& out)

Buffer& out)

{

out << "<IRETURNVALUE>\n";

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

}

void XmlWriter::_appendIReturnValueElementEnd(

Array<char>& out)

Buffer& out)

{

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

}

//EXP_PULL_BEGIN

void XmlWriter::_appendIReturnValueElementWithNameBegin(

Buffer& out,

const char* name)

{

out << "</IRETURNVALUE>\n";

out << STRLIT("<IRETURNVALUE NAME=\"") << name << STRLIT("\">\n");

}

//EXP_PULL_END

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

Line 2216

Line 2456

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

void XmlWriter::appendBooleanIParameter(

Array<char>& out,

Buffer& out,

const char* name,

Boolean flag)

{

_appendIParamValueElementBegin(out, name);

out << "<VALUE>";

out << STRLIT("<VALUE>");

append(out, flag);

out << "</VALUE>\n";

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

_appendIParamValueElementEnd(out);

}

//EXP_PULL_BEGIN

void XmlWriter::appendBooleanParameter(

Buffer& out,

const char* name,

Boolean flag)

{

_appendParamValueElementBegin(out, name);

out << STRLIT("<VALUE>");

append(out, flag);

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

_appendParamValueElementEnd(out);

}

void XmlWriter::appendBooleanIReturnValue(

Buffer& out,

const char* name,

Boolean flag)

{

_appendIReturnValueElementWithNameBegin(out, name);

out << STRLIT("<VALUE>");

append(out, flag);

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

_appendIReturnValueElementEnd(out);

}

void XmlWriter::appendUint32IParameter(

Buffer& out,

const char* name,

Uint32 val)

{

_appendIParamValueElementBegin(out, name);

out << STRLIT("<VALUE>");

append(out, val);

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

_appendIParamValueElementEnd(out);

}

// Can be used to generate either parameters with value,

// parameters with NULL (i.e. no value element) or

// no parameters output at all.

void XmlWriter::appendUint32ArgIParameter(

Buffer& out,

const char* name,

const Uint32Arg& val,

const Boolean required)

{

if (!required && val.isNull())

{

return;

}

_appendIParamValueElementBegin(out, name);

if (!val.isNull())

{

out << STRLIT("<VALUE>");

append(out, val.getValue());

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

}

_appendIParamValueElementEnd(out);

}

/* Output return value from Uint64Arg object as

Value inside IRETURNVALUE

If the state of the object is NULL output

the parameter without value. Else

output the value

void XmlWriter::appendUint64ReturnValue(

Buffer& out,

const char* name,

const Uint64Arg& val)

{

_appendIReturnValueElementBegin(out);

out << STRLIT("<VALUE>");

if (!val.isNull())

{

append(out, val.getValue());

}

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

_appendIReturnValueElementEnd(out);

}

//EXP_PULL_END

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

// appendStringIParameter()

Line 2234

Line 2556

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

void XmlWriter::appendStringIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const String& str)

{

_appendIParamValueElementBegin(out, name);

out << "<VALUE>";

out << STRLIT("<VALUE>");

appendSpecial(out, str);

out << "</VALUE>\n";

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

_appendIParamValueElementEnd(out);

}

// EXP_PULL_BEGIN

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

// appendQualifierNameIParameter()

// appendStringIParameterIfNotEmpty()

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

void XmlWriter::appendQualifierNameIParameter(

void XmlWriter::appendStringIParameterIfNotEmpty(

Array<char>& out,

Buffer& out,

const char* name,

const String& qualifierName)

const String& str)

{

// <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE

if (str != String::EMPTY)

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

{

// |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>

appendStringIParameter(out,name,str);

}

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

// ATTN: notice that there is really no way to pass a qualifier name

// appendStringParameter()

// as an IPARAMVALUE element according to the spec (look above). So we

// just pass it as a class name. An answer must be obtained later.

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

_appendIParamValueElementBegin(out, name);

void XmlWriter::appendStringParameter(

appendClassNameElement(out, qualifierName);

Buffer& out,

_appendIParamValueElementEnd(out);

const char* name,

const String& str)

{

_appendParamValueElementBegin(out, name);

out << STRLIT("<VALUE>");

appendSpecial(out, str);

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

_appendParamValueElementEnd(out);

}

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

// appendStringIReturnValue()

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

void XmlWriter::appendStringIReturnValue(

Buffer& out,

const char* name,

const String& str)

{

_appendIReturnValueElementWithNameBegin(out, name);

out << STRLIT("<VALUE>");

appendSpecial(out, str);

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

_appendIReturnValueElementEnd(out);

}

//EXP_PULL_END

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

// appendClassNameIParameter()

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

void XmlWriter::appendClassNameIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMName& className)

{

Line 2301

Line 2653

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

void XmlWriter::appendInstanceNameIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMObjectPath& instanceName)

{

Line 2310

Line 2662

_appendIParamValueElementEnd(out);

}

void XmlWriter::appendObjectNameIParameter(

Array<char>& out,

const char* name,

const CIMObjectPath& objectName)

{

// ATTN-CAKG-P2-20020726: The following condition does not correctly

// distinguish instanceNames from classNames in every case

// The instanceName of a singleton instance of a keyless class also

// has no key bindings

if (objectName.getKeyBindings ().size () == 0)

{

XmlWriter::appendClassNameIParameter(

out, name, objectName.getClassName());

}

else

{

XmlWriter::appendInstanceNameIParameter(

out, name, objectName);

}

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

// appendClassIParameter()

Line 2340

Line 2669

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

void XmlWriter::appendClassIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMConstClass& cimClass)

{

Line 2356

Line 2685

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

void XmlWriter::appendInstanceIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMConstInstance& instance)

{

Line 2372

Line 2701

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

void XmlWriter::appendNamedInstanceIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMInstance& namedInstance)

{

Line 2391

Line 2720

// USE: Create parameter for getProperty operation

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

void XmlWriter::appendPropertyNameIParameter(

Array<char>& out,

Buffer& out,

const CIMName& propertyName)

{

_appendIParamValueElementBegin(out, "PropertyName");

out << "<VALUE>" << propertyName << "</VALUE>\n";

out << STRLIT("<VALUE>") << propertyName << STRLIT("</VALUE>\n");

_appendIParamValueElementEnd(out);

}

Line 2406

Line 2735

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

void XmlWriter::appendPropertyValueIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMValue& value)

{

Line 2422

Line 2751

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

void XmlWriter::appendPropertyListIParameter(

Array<char>& out,

Buffer& out,

const CIMPropertyList& propertyList)

{

_appendIParamValueElementBegin(out, "PropertyList");

Line 2433

Line 2762

if (!propertyList.isNull ())

{

out << "<VALUE.ARRAY>\n";

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

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

{

out << "<VALUE>" << propertyList[i] << "</VALUE>\n";

out << STRLIT("<VALUE>") << propertyList[i] << STRLIT("</VALUE>\n");

}

out << "</VALUE.ARRAY>\n";

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

}

_appendIParamValueElementEnd(out);

Line 2451

Line 2780

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

void XmlWriter::appendQualifierDeclarationIParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMConstQualifierDecl& qualifierDecl)

{

Line 2466

Line 2795

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

Array<char> XmlWriter::formatHttpErrorRspMessage(

Buffer XmlWriter::formatHttpErrorRspMessage(

const String& status,

const String& cimError,

const String& errorDetail)

{

Array<char> out;

Buffer out;

appendHttpErrorResponseHeader(out, status, cimError, errorDetail);

Line 2487

Line 2816

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

// ATTN-RK-P1-20020228: Need to complete copy elimination optimization

Array<char> XmlWriter::formatSimpleMethodReqMessage(

Buffer XmlWriter::formatSimpleMethodReqMessage(

const char* host,

const CIMNamespaceName& nameSpace,

const CIMObjectPath& path,

Line 2496

Line 2825

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& httpAcceptLanguages,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguages& httpContentLanguages)

const ContentLanguageList& httpContentLanguages,

bool binaryResponse)

{

Array<char> out;

Buffer out;

Array<char> tmp;

Buffer tmp;

CIMObjectPath localObjectPath = path;

localObjectPath.setNameSpace(nameSpace.getString());

localObjectPath.setHost(String::EMPTY);

Line 2526

Line 2856

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size());

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

}

//PEP 128 adding serverRsponseTime to header

Buffer XmlWriter::formatSimpleMethodRspMessage(

Array<char> XmlWriter::formatSimpleMethodRspMessage(

const CIMName& methodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages & httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Array<char>& body,

const Buffer& bodyParams,

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Boolean isLast)

{

Array<char> out;

Buffer out;

if (isFirst == true)

{

// NOTE: temporarily put zero for content length. the http code

// will later decide to fill in the length or remove it altogether

appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,

appendMethodResponseHeader(

serverResponseTime);

out, httpMethod, httpContentLanguages, 0, serverResponseTime);

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendMethodResponseElementBegin(out, methodName);

Line 2572

Line 2904

}

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

// XmlWriter::formatSimpleMethodErrorRspMessage()

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

Array<char> XmlWriter::formatSimpleMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleMethodErrorRspMessage(

const CIMName& methodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<char> out;

Buffer out;

Array<char> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

Line 2596

Line 2927

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendMethodResponseHeader(

appendMethodResponseHeader(tmp,

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(),

false);

tmp << out;

return tmp;

Line 2612

Line 2944

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

Array<char> XmlWriter::formatSimpleIMethodReqMessage(

Buffer XmlWriter::formatSimpleIMethodReqMessage(

const char* host,

const CIMNamespaceName& nameSpace,

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& httpAcceptLanguages,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguages& httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Array<char>& body)

const Buffer& body,

bool binaryResponse)

{

Array<char> out;

Buffer out;

Array<char> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleReqElementBegin(out);

Line 2644

Line 2977

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size());

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

Line 2656

Line 2991

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

Array<char> XmlWriter::formatSimpleIMethodRspMessage(

Formats a IMethod Response Message. This function formats

messages for chunking based on the isFirst and isLast parameters.

If isFirst is set, it outputs headers and ResponseElement begin.

It always sends the body. If isLast is set, it sends the rtnParams

and the ResponseElement end followed by any parameter in the rtnParams.

KS_PULL_TBD_TODO - Determine what we want to do with chunking. Since this

This whole thing is based on the concept of each message sending a single

chunk and we will want in the future to modify so we can chose easily

whether we want to chunk or not and send the chunks.

Buffer XmlWriter::formatSimpleIMethodRspMessage(

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages & httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Array<char>& body,

const Buffer& rtnParams,

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Boolean isLast)

{

Array<char> out;

Buffer out;

if (isFirst == true)

{

// NOTE: temporarily put zero for content length. the http code

// will later decide to fill in the length or remove it altogether

appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,

appendMethodResponseHeader(

serverResponseTime);

out, httpMethod, httpContentLanguages, 0, serverResponseTime);

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendIMethodResponseElementBegin(out, iMethodName);

// output the start of the return tag. Test if there is response data by:

// output the start of the return tag. Test if there is response data

// by:

// 1. there is data on the first chunk OR

// 2. there is no data on the first chunk but isLast is false implying

// there is more non-empty data to come. If all subsequent chunks

Line 2696

Line 3044

{

if (body.size() != 0 || isFirst == false)

_appendIReturnValueElementEnd(out);

// Insert any return parameters.

if (rtnParams.size() != 0)

{

out << rtnParams;

}

// //EXP_PULL_END

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

Line 2711

Line 3067

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

Array<char> XmlWriter::formatSimpleIMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleIMethodErrorRspMessage(

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<char> out;

Buffer out;

Array<char> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

Line 2728

Line 3084

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendMethodResponseHeader(tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(), false);

tmp << out;

return tmp;

Line 2753

Line 3108

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

void XmlWriter::appendEMethodRequestHeader(

Array<char>& out,

Buffer& out,

const char* requestUri,

const char* host,

const CIMName& cimMethod,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& acceptLanguages,

const AcceptLanguageList& acceptLanguages,

const ContentLanguages& contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

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

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

if (httpMethod == HTTP_METHOD_M_POST)

{

out << "M-POST " << requestUri << " HTTP/1.1\r\n";

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

}

else

{

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

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

}

out << "HOST: " << host << "\r\n";

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

out << "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 << "Accept-Language: " << acceptLanguages << "\r\n";

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

}

if (contentLanguages.size() > 0)

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

#ifdef PEGASUS_DEBUG

Line 2796

Line 3152

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')

#endif

out << "TE: chunked, trailers" << "\r\n";

out << STRLIT("TE: chunked, trailers\r\n");

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

out << nn <<"\r\n";

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

out << nn << "-CIMExport: MethodRequest\r\n";

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

out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";

out << nn << STRLIT("-CIMExportMethod: ") << cimMethod <<

STRLIT("\r\n");

}

else

{

out << "CIMExport: MethodRequest\r\n";

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

out << "CIMExportMethod: " << cimMethod << "\r\n";

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

}

if (authenticationHeader.size())

{

out << authenticationHeader << "\r\n";

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

}

out << "\r\n";

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

}

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

Line 2828

Line 3185

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

void XmlWriter::appendEMethodResponseHeader(

Array<char>& out,

Buffer& out,

HttpMethod httpMethod,

const ContentLanguages& contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

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

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

out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";

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

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

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

out << "Ext:\r\n";

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

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

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

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

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

out << nn <<"\r\n";

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

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

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

}

else

{

out << "CIMExport: MethodResponse\r\n\r\n";

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

}

Line 2867

Line 3225

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

void XmlWriter::_appendSimpleExportReqElementBegin(

Array<char>& out)

Buffer& out)

{

out << "<SIMPLEEXPREQ>\n";

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

}

void XmlWriter::_appendSimpleExportReqElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</SIMPLEEXPREQ>\n";

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

}

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

Line 2889

Line 3247

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

void XmlWriter::_appendEMethodCallElementBegin(

Array<char>& out,

Buffer& out,

const CIMName& name)

{

out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";

out << STRLIT("<EXPMETHODCALL NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendEMethodCallElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</EXPMETHODCALL>\n";

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

}

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

Line 2913

Line 3271

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

void XmlWriter::_appendEParamValueElementBegin(

Array<char>& out,

Buffer& out,

const char* name)

{

out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";

out << STRLIT("<EXPPARAMVALUE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendEParamValueElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</EXPPARAMVALUE>\n";

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

}

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

Line 2932

Line 3290

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

void XmlWriter::appendInstanceEParameter(

Array<char>& out,

Buffer& out,

const char* name,

const CIMInstance& instance)

{

Line 2951

Line 3309

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

void XmlWriter::_appendSimpleExportRspElementBegin(

Array<char>& out)

Buffer& out)

{

out << "<SIMPLEEXPRSP>\n";

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

}

void XmlWriter::_appendSimpleExportRspElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</SIMPLEEXPRSP>\n";

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

}

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

Line 2973

Line 3331

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

void XmlWriter::_appendEMethodResponseElementBegin(

Array<char>& out,

Buffer& out,

const CIMName& name)

{

out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";

out << STRLIT("<EXPMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendEMethodResponseElementEnd(

Array<char>& out)

Buffer& out)

{

out << "</EXPMETHODRESPONSE>\n";

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

}

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

Line 2991

Line 3349

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

Array<char> XmlWriter::formatSimpleEMethodReqMessage(

Buffer XmlWriter::formatSimpleEMethodReqMessage(

const char* requestUri,

const char* host,

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& httpAcceptLanguages,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguages& httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Array<char>& body)

const Buffer& body)

{

Array<char> out;

Buffer out;

Array<char> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportReqElementBegin(out);

Line 3034

Line 3392

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

Array<char> XmlWriter::formatSimpleEMethodRspMessage(

Buffer XmlWriter::formatSimpleEMethodRspMessage(

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages& httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Array<char>& body)

const Buffer& body)

{

Array<char> out;

Buffer out;

Array<char> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

Line 3067

Line 3425

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

Array<char> XmlWriter::formatSimpleEMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleEMethodErrorRspMessage(

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<char> out;

Buffer out;

Array<char> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

Line 3084

Line 3442

_appendSimpleExportRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendEMethodResponseHeader(

appendEMethodResponseHeader(tmp,

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

Line 3096

Line 3454

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

// _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[...]]>";

break;

}

case XmlEntry::DOCTYPE:

{

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

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

break;

}

os << PEGASUS_STD(endl);

}

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

// XmlWriter::getNextMessageId()

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

static IDFactory _messageIDFactory(1000);

String XmlWriter::getNextMessageId()

{

// ATTN: make thread-safe:

char scratchBuffer[22];

static Uint32 messageId = 1000;

Uint32 n;

const char * startP = Uint32ToString(scratchBuffer,

messageId++;

_messageIDFactory.getID(),

n);

if (messageId < 1000)

return String(startP, n);

messageId = 1001;

char buffer[16];

sprintf(buffer, "%d", messageId);

return buffer;

}

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

Line 3262

Line 3475

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

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

return "unknown";

return STRLIT("unknown");

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.116
changed lines
	Added in v.1.169.4.8

No CVS admin address has been configured