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.95 and 1.169.4.10

version 1.95, 2003/08/26 20:46:28

version 1.169.4.10, 2014/03/31 22:46:03

Line 1

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

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

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

// The Open Group, Tivoli Systems

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

// this work for additional information regarding copyright ownership.

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

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

// License.

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

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

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

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

// and/or 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 SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

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

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

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

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

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

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

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

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

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

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

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

// 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 SOFTWARE IS PROVIDED

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

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

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

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

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

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

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

Line 35

Line 33

#include <cstdlib>

#include <cstdio>

#include "Constants.h"

#include "Destroyer.h"

#include "CIMClass.h"

#include "CIMClassRep.h"

#include "CIMInstance.h"

Line 54

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

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

out.appendArray(x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

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

return out;

}

// l10n

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

{

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

return out;

}

// l10n

Array<Sint8>& operator<<(Array<Sint8>& 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 _appendChar(Array<Sint8>& 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.

Uint8 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((Sint8 *)str,trailingBytesForUTF8[Uint32(str[0])]+1);

}

inline void _appendSpecialChar(Array<Sint8>& 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.

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

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

out.append((Sint8 *)str,number1);

}

inline void _appendSpecialChar(Array<Sint8>& 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));

}

static inline void _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 _appendSurrogatePair(Array<Sint8>& out, Uint16 high, Uint16 low)

{

Uint8 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 = trailingBytesForUTF8[Uint32(str[0])]+1;

out.append((Sint8 *)str,number1);

}

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

{

while (*str)

_appendSpecialChar(os, *str++);

}

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

{

_appendChar(out, x);

}

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

{

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

}

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

{

char buffer[32];

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

append(out, buffer);

}

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

{

char buffer[32];

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

append(out, buffer);

}

void XmlWriter::append(Array<Sint8>& 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<Sint8>& 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<Sint8>& out, Real64 x)

{

char buffer[128];

// %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec

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

append(out, buffer);

}

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

{

while (*str)

_appendChar(out, *str++);

}

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

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

}

else

{

_appendChar(out, str[i]);

}

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

{

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

out.append(' ');

}

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

{

_appendSpecialChar(out, x);

}

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

{

_appendSpecialChar(out, x);

}

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

{

while (*str)

_appendSpecialChar(out, *str++);

}

void XmlWriter::appendSpecial(Array<Sint8>& 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];

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

}

else

{

_appendSpecialChar(out, str[i]);

}

// chuck start

// 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 _encodeURIChar(String& outString, Sint8 char8)

{

Uint8 c = (Uint8)char8;

#ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING

if ( ((c <= 0x20) && (c >= 0x00)) || // 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

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

{

String encodedString;

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

{

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

{

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

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

}

else

{

_appendChar(utf8, uriString[i]);

}

// Second, escape the non HTTP-safe chars

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

{

_encodeURIChar(encodedString, utf8[i]);

}

return encodedString;

}

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

// appendLocalNameSpacePathElement()

Line 554

Line 69

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

void XmlWriter::appendLocalNameSpacePathElement(

Array<Sint8>& out,

Buffer& out,

const CIMNamespaceName& nameSpace)

{

out << "<LOCALNAMESPACEPATH>\n";

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

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

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

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

#if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \

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 570

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

}

delete nameSpaceCopy;

free(nameSpaceCopy);

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

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

}

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

Line 586

Line 100

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

void XmlWriter::appendNameSpacePathElement(

Array<Sint8>& 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 607

Line 121

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

void XmlWriter::appendClassNameElement(

Array<Sint8>& out,

Buffer& out,

const CIMName& className)

{

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

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

}

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

Line 624

Line 138

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

void XmlWriter::appendInstanceNameElement(

Array<Sint8>& 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";

// Append KEYBINDING ELEMENT

// <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>

// <!ATTLIST KEYBINDING

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

// isClassPath = false

appendValueReferenceElement(out, ref, false);

}

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 663

Line 184

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

void XmlWriter::appendClassPathElement(

Array<Sint8>& 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 683

Line 204

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

void XmlWriter::appendInstancePathElement(

Array<Sint8>& 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 703

Line 224

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

void XmlWriter::appendLocalClassPathElement(

Array<Sint8>& 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 721

Line 242

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

void XmlWriter::appendLocalInstancePathElement(

Array<Sint8>& 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 739

Line 260

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

// appendValueReferenceElement does this correctly with isClassPath flag

// Called only but formatSimple

void XmlWriter::appendLocalObjectPathElement(

Array<Sint8>& out,

Buffer& out,

const CIMObjectPath& objectPath)

{

Line 748

Line 271

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

Line 289

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

inline void _appendValue(Array<Sint8>& out, Boolean x)

inline void _xmlWritter_appendValue(Buffer& out, Boolean x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Uint8 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint8 x)

{

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

}

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

inline void _xmlWritter_appendValue(Buffer& out, Sint8 x)

{

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

}

inline void _appendValue(Array<Sint8>& out, Uint16 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint16 x)

{

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

}

inline void _appendValue(Array<Sint8>& out, Sint16 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint16 x)

{

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

}

inline void _appendValue(Array<Sint8>& out, Uint32 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint32 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Sint32 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint32 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Uint64 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint64 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Sint64 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint64 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Real32 x)

inline void _xmlWritter_appendValue(Buffer& out, Real32 x)

{

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

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Real64 x)

inline void _xmlWritter_appendValue(Buffer& out, Real64 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, const Char16& x)

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

{

XmlWriter::appendSpecial(out, x);

}

inline void _appendValue(Array<Sint8>& out, const String& x)

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

{

XmlWriter::appendSpecial(out, x);

}

inline void _appendValue(Array<Sint8>& out, const CIMDateTime& x)

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

{

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

// CIMDateTime values do not contain special characters.

out << x.toString();

}

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

{

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

// Emit Instance Path with VALUE.REFERENCE wrapper element

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

}

inline void _appendValue(Array<Sint8>& out, const CIMObjectPath& x)

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

{

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

String myStr = x.toString();

_xmlWritter_appendValue(out, myStr);

}

void _appendValueArray(Array<Sint8>& 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--)

{

_appendValue(out, *p++);

_xmlWritter_appendValue(out, *p++);

}

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

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

}

template<class T>

void _appendValueArray(Array<Sint8>& 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>");

_appendValue(out, *p++);

_xmlWritter_appendValue(out, *p++);

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

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

}

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

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

}

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

Line 879

Line 413

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

void XmlWriter::appendValueElement(

Array<Sint8>& out,

Buffer& out,

const CIMValue& value)

{

if (value.isNull())

Line 894

Line 428

{

Array<Boolean> a;

value.get(a);

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

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

break;

}

Line 902

Line 436

{

Array<Uint8> a;

value.get(a);

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

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

break;

}

Line 910

Line 444

{

Array<Sint8> a;

value.get(a);

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

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

break;

}

Line 918

Line 452

{

Array<Uint16> a;

value.get(a);

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

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

break;

}

Line 926

Line 460

{

Array<Sint16> a;

value.get(a);

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

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

break;

}

Line 934

Line 468

{

Array<Uint32> a;

value.get(a);

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

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

break;

}

Line 942

Line 476

{

Array<Sint32> a;

value.get(a);

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

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

break;

}

Line 950

Line 484

{

Array<Uint64> a;

value.get(a);

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

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

break;

}

Line 958

Line 492

{

Array<Sint64> a;

value.get(a);

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

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

break;

}

Line 966

Line 500

{

Array<Real32> a;

value.get(a);

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

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

break;

}

Line 974

Line 508

{

Array<Real64> a;

value.get(a);

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

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

break;

}

Line 982

Line 516

{

Array<Char16> a;

value.get(a);

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

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

break;

}

case CIMTYPE_STRING:

{

Array<String> a;

const String* data;

value.get(a);

Uint32 size;

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

value._get(data, size);

_xmlWritter_appendValueArray(out, data, size);

break;

}

Line 998

Line 533

{

Array<CIMDateTime> a;

value.get(a);

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

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

break;

}

Line 1006

Line 541

{

Array<CIMObjectPath> a;

value.get(a);

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

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

break;

}

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 1019

Line 568

// Has to be separate because it uses VALUE.REFERENCE tag

CIMObjectPath v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

}

else

{

out << "<VALUE>";

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

switch (value.getType())

{

Line 1031

Line 580

{

Boolean v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1039

Line 588

{

Uint8 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1047

Line 596

{

Sint8 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1055

Line 604

{

Uint16 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1063

Line 612

{

Sint16 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1071

Line 620

{

Uint32 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1079

Line 628

{

Sint32 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1087

Line 636

{

Uint64 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1095

Line 644

{

Sint64 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1103

Line 652

{

Real32 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1111

Line 660

{

Real64 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1119

Line 668

{

Char16 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1127

Line 676

{

String v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 1135

Line 684

{

CIMDateTime v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

case CIMTYPE_OBJECT:

{

CIMObject v;

value.get(v);

_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 1151

Line 714

const CIMValue& value,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendValueElement(tmp, value);

tmp.append('\0');

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

}

Line 1167

Line 729

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

void XmlWriter::appendValueObjectWithPathElement(

Array<Sint8>& 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 (), false);

appendObjectElement(out, objectWithPath);

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

}

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

// appendValueReferenceElement()

// <!ELEMENT VALUE.REFERENCE

// INSTANCENAME)>

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

void XmlWriter::appendValueReferenceElement(

appendClassOrInstancePathElement(out, objectWithPath.getPath (),

Array<Sint8>& out,

isClassObject);

const CIMObjectPath& reference,

Boolean putValueWrapper)

{

if (putValueWrapper)

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

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

appendObjectElement(

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

out,

objectWithPath,

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

includeQualifiers,

// distinguish instanceNames from classNames in every case

includeClassOrigin,

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

propertyList);

// key bindings

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

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

}

if (kbs.size())

// Append INSTANCEPATH | LOCALINSTANCEPATH | INSTANCENAME

void XmlWriter::appendInstancePath(

Buffer& out,

const CIMObjectPath& reference)

{

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

{

Line 1222

Line 769

appendInstanceNameElement(out, reference);

}

else

// appends CLASSPATH | LOCALCLASSPATH | CLASSNAME

void XmlWriter::appendClassPath(

Buffer& out,

const CIMObjectPath& reference)

{

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

{

Line 1237

Line 788

appendClassNameElement(out, reference.getClassName());

}

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

// appendValueReferenceElement()

// <!ELEMENT VALUE.REFERENCE

// INSTANCENAME)>

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

// Builds either a classPath or InstancePath based on isClassPath

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

// request.

// The caller must determine if this is a class or instance

// path rather than trying to interpret that difference from reference arg.

void XmlWriter::appendValueReferenceElement(

Buffer& out,

const CIMObjectPath& reference,

Boolean isClassPath)

{

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

appendClassOrInstancePathElement(out, reference, isClassPath);

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

}

// Append either the classPathElement or InstancePathElement depending on

// the isClassPath input argument.

// INSTANCENAME | CLASSNAME

if (putValueWrapper)

void XmlWriter::appendClassOrInstancePathElement(

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

Buffer& out,

const CIMObjectPath& reference,

Boolean isClassPath)

{

if (isClassPath)

{

appendClassPath(out,reference);

}

else

{

appendInstancePath(out,reference);

}

void XmlWriter::printValueReferenceElement(

const CIMObjectPath& reference,

Boolean isClassPath,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendValueReferenceElement(tmp, reference, true);

appendValueReferenceElement(tmp, reference, isClassPath);

tmp.append('\0');

indentedPrint(os, tmp.getData());

}

Line 1261

Line 853

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

void XmlWriter::appendValueNamedInstanceElement(

Array<Sint8>& 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 1285

Line 914

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

void XmlWriter::appendClassElement(

Array<Sint8>& 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<Sint8> tmp;

Buffer tmp;

appendClassElement(tmp, cimclass);

tmp.append('\0');

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

}

Line 1314

Line 976

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

void XmlWriter::appendInstanceElement(

Array<Sint8>& 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++)

{

CIMName name = propertyList[i];

Uint32 pos = rep->_properties.find(

propertyList[i],

propertyList.getCIMNameTag(i));

if(pos != PEG_NOT_FOUND)

{

instance._checkRep();

PEG_TRACE((TRC_XML,Tracer::LEVEL4,

instance._rep->toXml(out);

"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<Sint8> tmp;

Buffer tmp;

appendInstanceElement(tmp, instance);

tmp.append('\0');

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

}

Line 1340

Line 1057

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

void XmlWriter::appendObjectElement(

Array<Sint8>& out,

Buffer& out,

const CIMConstObject& object)

const CIMConstObject& object,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

if (object.isClass())

{

Line 1351

Line 1071

else if (object.isInstance())

{

CIMConstInstance i(object);

appendInstanceElement(out, i);

appendInstanceElement(

out,

includeQualifiers,

includeClassOrigin,

propertyList);

}

// else PEGASUS_ASSERT(0);

}

Line 1385

Line 1110

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

void XmlWriter::appendPropertyElement(

Array<Sint8>& 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<Sint8> tmp;

Buffer tmp;

appendPropertyElement(tmp, property);

tmp.append('\0');

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

}

Line 1417

Line 1391

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

void XmlWriter::appendMethodElement(

Array<Sint8>& 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<Sint8> tmp;

Buffer tmp;

appendMethodElement(tmp, method);

tmp.append('\0');

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

}

Line 1463

Line 1462

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

void XmlWriter::appendParameterElement(

Array<Sint8>& 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<Sint8> tmp;

Buffer tmp;

appendParameterElement(tmp, parameter);

tmp.append('\0');

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

}

Line 1486

Line 1569

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

// <!ATTLIST PARAMVALUE

// %CIMName;>

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendParamValueElement(

Array<Sint8>& 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<Sint8> tmp;

Buffer tmp;

appendParamValueElement(tmp, paramValue);

tmp.append('\0');

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

}

Line 1522

Line 1621

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

void XmlWriter::appendQualifierElement(

Array<Sint8>& 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<Sint8> tmp;

Buffer tmp;

appendQualifierElement(tmp, qualifier);

tmp.append('\0');

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

}

Line 1554

Line 1668

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

void XmlWriter::appendQualifierDeclElement(

Array<Sint8>& 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<Sint8> tmp;

Buffer tmp;

appendQualifierDeclElement(tmp, qualifierDecl);

tmp.append('\0');

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

}

Line 1580

Line 1717

// 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<Sint8>& 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 1616

Line 1757

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

void XmlWriter::appendScopeElement(

Array<Sint8>& 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 1660

Line 1801

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

void XmlWriter::appendMethodCallHeader(

Array<Sint8>& 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 1678

Line 1821

// do that in client today. Permanent change is to retry until spec

// updated. This change is temp to finish tests or until the retry

// installed. Required because of change to wbemservices cimom

#if defined PEGASUS_SNIA_INTEROP_TEST || defined PEGASUS_FORCE_POST_METHOD

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

#else

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 << "POST /cimom HTTP/1.1\r\n";

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

}

#endif

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

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

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

if (binaryRequest)

out << "Content-Length: " << contentLength << "\r\n";

{

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

// binary protocol.

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

}

else

{

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

}

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

// backdoor environment variable to turn OFF client requesting transfer

// encoding. The default is on. to turn off, set this variable to zero.

// This should be removed when stable. This should only be turned off in

// a debugging/testing environment.

static const char *clientTransferEncodingOff =

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

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

#endif

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

}

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

// appendMethodResponseHeader()

// Build HTTP response header.

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

void XmlWriter::appendMethodResponseHeader(

Array<Sint8>& out,

Buffer& out,

HttpMethod httpMethod,

const ContentLanguages & contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

Uint32 contentLength,

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

}

OUTPUT_CONTENTLENGTH(out, contentLength);

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

STAT_SERVERTIME

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

out << "Content-Length: " << contentLength << "\r\n";

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

}

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

// appendHttpErrorResponseHeader()

Line 1779

Line 1995

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

void XmlWriter::appendHttpErrorResponseHeader(

Array<Sint8>& 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 1809

Line 2022

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

Line 2034

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

void XmlWriter::appendUnauthorizedResponseHeader(

Array<Sint8>& 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 1847

Line 2068

// Returns OK message in the following format:

// HTTP/1.1 200 OK

// Content-Length: 0

// WWW-Authenticate: Negotiate "token"

// <HTML><HEAD>

// <TITLE>200 OK</TITLE>

Line 1858

Line 2080

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

void XmlWriter::appendOKResponseHeader(

Array<Sint8>& 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");

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

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

out << "\r\n";

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

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 1889

Line 2115

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

void XmlWriter::_appendMessageElementBegin(

Array<Sint8>& 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<Sint8>& out)

Buffer& out)

{

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

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

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

}

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

Line 1914

Line 2140

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

void XmlWriter::_appendSimpleReqElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLEREQ>\n";

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

}

void XmlWriter::_appendSimpleReqElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1936

Line 2162

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

void XmlWriter::_appendMethodCallElementBegin(

Array<Sint8>& out,

Buffer& out,

const CIMName& name)

{

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

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

}

void XmlWriter::_appendMethodCallElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1953

Line 2179

// _appendIMethodCallElementBegin()

// _appendIMethodCallElementEnd()

// <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>

// <!ATTLIST IMETHODCALL %CIMName;>

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

void XmlWriter::_appendIMethodCallElementBegin(

Buffer& out,

const CIMName& name)

{

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

}

void XmlWriter::_appendIMethodCallElementEnd(

Buffer& out)

{

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

}

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

// _appendIParamValueElementBegin()

// _appendIParamValueElementEnd()

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

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

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

// <!ATTLIST IPARAMVALUE %CIMName;>

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

void XmlWriter::_appendIMethodCallElementBegin(

void XmlWriter::_appendIParamValueElementBegin(

Array<Sint8>& out,

Buffer& out,

const CIMName& name)

const char* name)

{

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

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

}

void XmlWriter::_appendIMethodCallElementEnd(

void XmlWriter::_appendIParamValueElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

//EXP_PULL_BEGIN

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

// _appendIParamValueElementBegin()

// _appendParamValueElementBegin()

// _appendIParamValueElementEnd()

// _appendParamValueElementEnd()

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

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

Line 1983

Line 2235

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

void XmlWriter::_appendIParamValueElementBegin(

void XmlWriter::_appendParamValueElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

{

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

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

}

void XmlWriter::_appendIParamValueElementEnd(

void XmlWriter::_appendParamValueElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

//EXP_PULL_END

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

Line 2006

Line 2259

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

void XmlWriter::_appendSimpleRspElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLERSP>\n";

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

}

void XmlWriter::_appendSimpleRspElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2028

Line 2281

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

void XmlWriter::_appendMethodResponseElementBegin(

Array<Sint8>& out,

Buffer& out,

const CIMName& name)

{

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

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

}

void XmlWriter::_appendMethodResponseElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2051

Line 2304

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

void XmlWriter::_appendIMethodResponseElementBegin(

Array<Sint8>& out,

Buffer& out,

const CIMName& name)

{

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

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

}

void XmlWriter::_appendIMethodResponseElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2070

Line 2323

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

void XmlWriter::_appendErrorElement(

Array<Sint8>& 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 2093

Line 2404

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendReturnValueElement(

Array<Sint8>& 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 2126

Line 2439

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

void XmlWriter::_appendIReturnValueElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<IRETURNVALUE>\n";

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

}

void XmlWriter::_appendIReturnValueElementEnd(

Array<Sint8>& 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 2144

Line 2466

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

void XmlWriter::appendBooleanIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

Boolean flag)

{

_appendIParamValueElementBegin(out, name);

out << "<VALUE>";

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

append(out, flag);

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

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 2162

Line 2566

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

void XmlWriter::appendStringIParameter(

Array<Sint8>& 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<Sint8>& 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);

}

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

// appendStringParameter()

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

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

// 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<Sint8>& out,

Buffer& out,

const char* name,

const CIMName& className)

{

Line 2229

Line 2663

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

void XmlWriter::appendInstanceNameIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMObjectPath& instanceName)

{

Line 2238

Line 2672

_appendIParamValueElementEnd(out);

}

void XmlWriter::appendObjectNameIParameter(

Array<Sint8>& 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 2268

Line 2679

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

void XmlWriter::appendClassIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMConstClass& cimClass)

{

Line 2284

Line 2695

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

void XmlWriter::appendInstanceIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMConstInstance& instance)

{

Line 2300

Line 2711

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

void XmlWriter::appendNamedInstanceIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMInstance& namedInstance)

{

Line 2319

Line 2730

// USE: Create parameter for getProperty operation

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

void XmlWriter::appendPropertyNameIParameter(

Array<Sint8>& out,

Buffer& out,

const CIMName& propertyName)

{

_appendIParamValueElementBegin(out, "PropertyName");

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

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

_appendIParamValueElementEnd(out);

}

Line 2334

Line 2745

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

void XmlWriter::appendPropertyValueIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMValue& value)

{

Line 2350

Line 2761

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

void XmlWriter::appendPropertyListIParameter(

Array<Sint8>& out,

Buffer& out,

const CIMPropertyList& propertyList)

{

_appendIParamValueElementBegin(out, "PropertyList");

Line 2361

Line 2772

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 2379

Line 2790

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

void XmlWriter::appendQualifierDeclarationIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMConstQualifierDecl& qualifierDecl)

{

Line 2394

Line 2805

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

Array<Sint8> XmlWriter::formatHttpErrorRspMessage(

Buffer XmlWriter::formatHttpErrorRspMessage(

const String& status,

const String& cimError,

const String& errorDetail)

{

Array<Sint8> out;

Buffer out;

appendHttpErrorResponseHeader(out, status, cimError, errorDetail);

Line 2415

Line 2826

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

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

Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(

Buffer XmlWriter::formatSimpleMethodReqMessage(

const char* host,

const CIMNamespaceName& nameSpace,

const CIMObjectPath& path,

Line 2424

Line 2835

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& httpAcceptLanguages,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguages& httpContentLanguages)

const ContentLanguageList& httpContentLanguages,

bool binaryResponse)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

CIMObjectPath localObjectPath = path;

localObjectPath.setNameSpace(nameSpace.getString());

localObjectPath.setHost(String::EMPTY);

Line 2454

Line 2866

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size());

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

}

Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(

Buffer XmlWriter::formatSimpleMethodRspMessage(

const CIMName& methodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages & httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Array<Sint8>& body)

const Buffer& bodyParams,

{

const Buffer& body,

Array<Sint8> out;

Uint64 serverResponseTime,

Array<Sint8> tmp;

Boolean isFirst,

Boolean isLast)

{

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

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendMethodResponseElementBegin(out, methodName);

}

if (body.size() != 0)

{

out << body;

}

if (isLast == true)

{

_appendMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

}

appendMethodResponseHeader(tmp,

return out;

httpMethod,

httpContentLanguages,

out.size());

tmp << out;

return tmp;

}

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

// XmlWriter::formatSimpleMethodErrorRspMessage()

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

Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleMethodErrorRspMessage(

const CIMName& methodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

Line 2510

Line 2937

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendMethodResponseHeader(

appendMethodResponseHeader(tmp,

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(),

false);

tmp << out;

return tmp;

Line 2526

Line 2954

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

Array<Sint8> 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<Sint8>& body)

const Buffer& body,

bool binaryResponse)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleReqElementBegin(out);

Line 2558

Line 2987

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size());

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

Line 2570

Line 3001

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

Array<Sint8> 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<Sint8>& body)

const Buffer& rtnParams,

{

const Buffer& body,

Array<Sint8> out;

Uint64 serverResponseTime,

Array<Sint8> tmp;

Boolean isFirst,

Boolean isLast)

{

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

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendIMethodResponseElementBegin(out, iMethodName);

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

// are empty, then this generates and empty response.

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

_appendIReturnValueElementBegin(out);

}

if (body.size() != 0)

{

_appendIReturnValueElementBegin(out);

out << body;

}

if (isLast == true)

{

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

_appendIReturnValueElementEnd(out);

// EXP_PULL_BEGIN

// Insert any return parameters.

if (rtnParams.size() != 0)

{

out << rtnParams;

}

// EXP_PULL_END

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

}

appendMethodResponseHeader(tmp,

return out;

httpMethod,

httpContentLanguages,

out.size());

tmp << out;

return tmp;

}

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

// XmlWriter::formatSimpleIMethodErrorRspMessage()

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

Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleIMethodErrorRspMessage(

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

Line 2625

Line 3095

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendMethodResponseHeader(tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(), false);

tmp << out;

return tmp;

Line 2650

Line 3119

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

void XmlWriter::appendEMethodRequestHeader(

Array<Sint8>& 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");

out << "Content-Length: " << contentLength << "\r\n";

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

// backdoor environment variable to turn OFF client requesting transfer

// encoding. The default is on. to turn off, set this variable to zero.

// This should be removed when stable. This should only be turned off in

// a debugging/testing environment.

static const char *clientTransferEncodingOff =

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

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

#endif

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

if (httpMethod == HTTP_METHOD_M_POST)

{

out << "Man: http://www.hp.com; 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 2710

Line 3196

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

void XmlWriter::appendEMethodResponseHeader(

Array<Sint8>& 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 << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n"

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

OUTPUT_CONTENTLENGTH(out, contentLength);

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

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

out << "Content-Length: " << contentLength << "\r\n";

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 2748

Line 3236

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

void XmlWriter::_appendSimpleExportReqElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLEEXPREQ>\n";

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

}

void XmlWriter::_appendSimpleExportReqElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2770

Line 3258

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

void XmlWriter::_appendEMethodCallElementBegin(

Array<Sint8>& out,

Buffer& out,

const CIMName& name)

{

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

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

}

void XmlWriter::_appendEMethodCallElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2794

Line 3282

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

void XmlWriter::_appendEParamValueElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

{

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

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

}

void XmlWriter::_appendEParamValueElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2813

Line 3301

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

void XmlWriter::appendInstanceEParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMInstance& instance)

{

Line 2832

Line 3320

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

void XmlWriter::_appendSimpleExportRspElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLEEXPRSP>\n";

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

}

void XmlWriter::_appendSimpleExportRspElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2854

Line 3342

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

void XmlWriter::_appendEMethodResponseElementBegin(

Array<Sint8>& out,

Buffer& out,

const CIMName& name)

{

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

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

}

void XmlWriter::_appendEMethodResponseElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2872

Line 3360

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

Array<Sint8> 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<Sint8>& body)

const Buffer& body)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportReqElementBegin(out);

Line 2915

Line 3403

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

Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(

Buffer XmlWriter::formatSimpleEMethodRspMessage(

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages& httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Array<Sint8>& body)

const Buffer& body)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

Line 2948

Line 3436

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

Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleEMethodErrorRspMessage(

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

Line 2965

Line 3453

_appendSimpleExportRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendEMethodResponseHeader(

appendEMethodResponseHeader(tmp,

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

Line 2977

Line 3465

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

// _printAttributes()

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

static void _printAttributes(

PEGASUS_STD(ostream)& os,

const XmlAttribute* attributes,

Uint32 attributeCount)

{

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

{

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

os << '"';

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

os << '"';

if (i + 1 != attributeCount)

os << ' ';

}

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

// _indent()

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

static void _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)

{

char* tmp = strcpy(new char[strlen(text) + 1], text);

XmlParser parser(tmp);

XmlEntry entry;

Stack<const char*> stack;

while (parser.next(entry))

{

switch (entry.type)

{

case XmlEntry::XML_DECLARATION:

{

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

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

_printAttributes(os, entry.attributes, entry.attributeCount);

os << "?>";

break;

}

case XmlEntry::START_TAG:

{

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

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

if (entry.attributeCount)

os << ' ';

_printAttributes(os, entry.attributes, entry.attributeCount);

os << ">";

stack.push(entry.text);

break;

}

case XmlEntry::EMPTY_TAG:

{

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

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

_printAttributes(os, entry.attributes, entry.attributeCount);

os << "/>";

break;

}

case XmlEntry::END_TAG:

{

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

stack.pop();

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

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

break;

}

case XmlEntry::COMMENT:

{

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

os << "<!--";

_appendSpecial(os, entry.text);

os << "-->";

break;

}

case XmlEntry::CONTENT:

{

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

_appendSpecial(os, entry.text);

break;

}

case XmlEntry::CDATA:

{

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

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

break;

}

case XmlEntry::DOCTYPE:

{

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

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

break;

}

os << PEGASUS_STD(endl);

}

delete [] tmp;

}

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

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

Line 3486

// 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.95
changed lines
	Added in v.1.169.4.10

No CVS admin address has been configured