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.169.4.8 and 1.170

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

version 1.170, 2011/01/25 11:24:24

Line 153

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

{

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

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

appendValueReferenceElement(out, ref, true);

appendValueReferenceElement(out, ref, false, true);

}

else

{

Line 162

Line 161

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

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

// fixed the special characters

// fixed the special character problem - Markus

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

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

Line 257

Line 256

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

// appendValueReferenceElement does this correctly with isClassPath flag

// Called only but formatSimple

void XmlWriter::appendLocalObjectPathElement(

Buffer& out,

const CIMObjectPath& objectPath)

Line 268

Line 265

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

Line 356

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

{

// Emit Instance Path with value wrapper

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

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

}

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

Line 557

Line 552

break;

}

default:

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

PEGASUS_ASSERT(false);

}

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

Line 700

Line 695

break;

}

default:

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

PEGASUS_ASSERT(false);

}

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

Line 730

Line 725

const CIMObject& objectWithPath,

Boolean includeQualifiers,

Boolean includeClassOrigin,

Boolean isClassObject,

const CIMPropertyList& propertyList)

{

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

appendValueReferenceElement(out, objectWithPath.getPath (),

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

isClassObject , false);

appendObjectElement(

out,

objectWithPath,

Line 758

Line 750

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

// appends INSTANCEPATH | LOCALINSTANCEPATH | INSTANCENAME

void XmlWriter::appendValueReferenceElement(

void XmlWriter::appendValueInstancePathElement(

Buffer& out,

const CIMObjectPath& reference)

const CIMObjectPath& reference,

Boolean putValueWrapper)

{

if (putValueWrapper)

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

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

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

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

// distinguish instanceNames from classNames in every case

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

// key bindings

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

if (kbs.size())

{

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

{

Line 776

Line 784

appendInstanceNameElement(out, reference);

}

else

// appends CLASSPATH | LOCALCLASSPATH | CLASSNAME

void XmlWriter::appendValueClassPathElement(

Buffer& out,

const CIMObjectPath& reference)

{

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

{

Line 796

Line 800

}

// Builds either a classPath or InstancePath based on isClassPath

if (putValueWrapper)

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

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

void XmlWriter::appendValueReferenceElement(

Buffer& out,

const CIMObjectPath& reference,

Boolean isClassPath,

Boolean addValueWrapper)

{

if (addValueWrapper)

{

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

}

if (isClassPath)

{

appendValueClassPathElement(out,reference);

}

else

{

appendValueInstancePathElement(out,reference);

}

if (addValueWrapper)

{

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

}

void XmlWriter::printValueReferenceElement(

const CIMObjectPath& reference,

Boolean isClassPath,

PEGASUS_STD(ostream)& os)

{

Buffer tmp;

appendValueReferenceElement(tmp, reference, isClassPath, true);

appendValueReferenceElement(tmp, reference, true);

indentedPrint(os, tmp.getData());

}

Line 862

Line 841

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 1174

Line 1124

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

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE ==

== PEG_NOT_FOUND)

PEG_NOT_FOUND)

{

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

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

Line 1803

Line 1753

bool binaryRequest,

bool binaryResponse)

{

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

char nn[] = { '0' + (rand() % 10), '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 1829

Line 1779

}

else

{

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

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

}

if (binaryResponse)

Line 1943

Line 1893

}

else

{

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

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

}

OUTPUT_CONTENTLENGTH(out, contentLength);

Line 1955

Line 1905

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

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

Line 2012

Line 1962

// Returns unauthorized message in the following format:

// HTTP/1.1 401 Unauthorized

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

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

// <HTML><HEAD>

// <TITLE>401 Unauthorized</TITLE>

Line 2025

Line 1974

void XmlWriter::appendUnauthorizedResponseHeader(

Buffer& out,

const String& errorDetail,

const String& content)

{

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

if (errorDetail.size() > 0)

{

out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")

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

}

OUTPUT_CONTENTLENGTH(out, 0);

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

Line 2212

Line 2154

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

}

//EXP_PULL_BEGIN

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

// _appendParamValueElementBegin()

// _appendParamValueElementEnd()

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

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

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

// <!ATTLIST IPARAMVALUE %CIMName;>

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

void XmlWriter::_appendParamValueElementBegin(

Buffer& out,

const char* name)

{

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

}

void XmlWriter::_appendParamValueElementEnd(

Buffer& out)

{

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

}

//EXP_PULL_END

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

// _appendSimpleRspElementBegin()

Line 2440

Line 2355

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

}

//EXP_PULL_BEGIN

void XmlWriter::_appendIReturnValueElementWithNameBegin(

Buffer& out,

const char* name)

{

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

}

//EXP_PULL_END

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

// appendBooleanIParameter()

Line 2467

Line 2373

_appendIParamValueElementEnd(out);

}

//EXP_PULL_BEGIN

void XmlWriter::appendBooleanParameter(

Buffer& out,

const char* name,

Boolean flag)

{

_appendParamValueElementBegin(out, name);

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

append(out, flag);

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

_appendParamValueElementEnd(out);

}

void XmlWriter::appendBooleanIReturnValue(

Buffer& out,

const char* name,

Boolean flag)

{

_appendIReturnValueElementWithNameBegin(out, name);

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

append(out, flag);

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

_appendIReturnValueElementEnd(out);

}

void XmlWriter::appendUint32IParameter(

Buffer& out,

const char* name,

Uint32 val)

{

_appendIParamValueElementBegin(out, name);

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

append(out, val);

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

_appendIParamValueElementEnd(out);

}

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

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

// no parameters output at all.

void XmlWriter::appendUint32ArgIParameter(

Buffer& out,

const char* name,

const Uint32Arg& val,

const Boolean required)

{

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

{

return;

}

_appendIParamValueElementBegin(out, name);

if (!val.isNull())

{

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

append(out, val.getValue());

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

}

_appendIParamValueElementEnd(out);

}

/* Output return value from Uint64Arg object as

Value inside IRETURNVALUE

If the state of the object is NULL output

the parameter without value. Else

output the value

void XmlWriter::appendUint64ReturnValue(

Buffer& out,

const char* name,

const Uint64Arg& val)

{

_appendIReturnValueElementBegin(out);

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

if (!val.isNull())

{

append(out, val.getValue());

}

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

_appendIReturnValueElementEnd(out);

}

//EXP_PULL_END

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

// appendStringIParameter()

Line 2567

Line 2391

_appendIParamValueElementEnd(out);

}

// EXP_PULL_BEGIN

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

// appendStringIParameterIfNotEmpty()

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

void XmlWriter::appendStringIParameterIfNotEmpty(

Buffer& out,

const char* name,

const String& str)

{

if (str != String::EMPTY)

{

appendStringIParameter(out,name,str);

}

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

// appendStringParameter()

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

void XmlWriter::appendStringParameter(

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

Line 2662

Line 2432

_appendIParamValueElementEnd(out);

}

void XmlWriter::appendObjectNameIParameter(

Buffer& 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 2869

Line 2662

const String& messageId,

HttpMethod httpMethod,

const ContentLanguageList& httpContentLanguages,

const Buffer& bodyParams,

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Line 2991

Line 2783

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

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 ContentLanguageList& httpContentLanguages,

const Buffer& rtnParams,

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Line 3044

Line 2824

{

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

_appendIReturnValueElementEnd(out);

// Insert any return parameters.

if (rtnParams.size() != 0)

{

out << rtnParams;

}

// //EXP_PULL_END

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

Line 3118

Line 2890

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

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

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

if (httpMethod == HTTP_METHOD_M_POST)

{

Line 3129

Line 2901

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

}

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

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

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

OUTPUT_CONTENTLENGTH(out, contentLength);

if (acceptLanguages.size() > 0)

Line 3190

Line 2962

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

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

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

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

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

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

OUTPUT_CONTENTLENGTH(out, contentLength);

if (contentLanguages.size() > 0)

Line 3490

Line 3262

case CIMKeyBinding::REFERENCE:

default:

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

PEGASUS_ASSERT(false);

}

return STRLIT("unknown");

Legend:

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

No CVS admin address has been configured