version 1.159, 2008/08/12 19:36:14
|
version 1.169.4.1, 2011/01/15 21:26:53
|
|
|
//%2006//////////////////////////////////////////////////////////////////////// |
//%LICENSE//////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Licensed to The Open Group (TOG) under one or more contributor license |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
// this work for additional information regarding copyright ownership. |
// IBM Corp.; EMC Corporation, The Open Group. |
// Each contributor licenses this file to you under the OpenPegasus Open |
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
// Source License; you may not use this file except in compliance with the |
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// License. |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// |
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
// Permission is hereby granted, free of charge, to any person obtaining a |
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// copy of this software and associated documentation files (the "Software"), |
// EMC Corporation; Symantec Corporation; The Open Group. |
// to deal in the Software without restriction, including without limitation |
// |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, |
// Permission is hereby granted, free of charge, to any person obtaining a copy |
// and/or sell copies of the Software, and to permit persons to whom the |
// of this software and associated documentation files (the "Software"), to |
// Software is furnished to do so, subject to the following conditions: |
// deal in the Software without restriction, including without limitation the |
// |
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
// The above copyright notice and this permission notice shall be included |
// sell copies of the Software, and to permit persons to whom the Software is |
// in all copies or substantial portions of the Software. |
// furnished to do so, subject to the following conditions: |
// |
// |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
// 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. |
|
// | // |
//============================================================================== |
////////////////////////////////////////////////////////////////////////// |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
const String& host, | const String& host, |
const CIMNamespaceName& nameSpace) | const CIMNamespaceName& nameSpace) |
{ | { |
out << STRLIT("<NAMESPACEPATH>\n"); |
out << STRLIT("<NAMESPACEPATH>\n" |
out << STRLIT("<HOST>") << host << STRLIT("</HOST>\n"); |
"<HOST>") << host << STRLIT("</HOST>\n"); |
appendLocalNameSpacePathElement(out, nameSpace); | appendLocalNameSpacePathElement(out, nameSpace); |
out << STRLIT("</NAMESPACEPATH>\n"); | out << STRLIT("</NAMESPACEPATH>\n"); |
} | } |
|
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); | _xmlWritter_appendValueArray(out, a.getData(), a.size()); |
break; | break; |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
case CIMTYPE_INSTANCE: | case CIMTYPE_INSTANCE: |
{ | { |
Array<CIMInstance> a; | Array<CIMInstance> a; |
|
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); | _xmlWritter_appendValueArray(out, a.getData(), a.size()); |
break; | break; |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
default: | default: |
PEGASUS_ASSERT(false); | PEGASUS_ASSERT(false); |
} | } |
|
|
_xmlWritter_appendValue(out, v); | _xmlWritter_appendValue(out, v); |
break; | break; |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
case CIMTYPE_INSTANCE: | case CIMTYPE_INSTANCE: |
{ | { |
CIMInstance v; | CIMInstance v; |
|
|
_xmlWritter_appendValue(out, v); | _xmlWritter_appendValue(out, v); |
break; | break; |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
default: | default: |
PEGASUS_ASSERT(false); | PEGASUS_ASSERT(false); |
} | } |
|
|
out << STRLIT("</VALUE.NAMEDINSTANCE>\n"); | out << STRLIT("</VALUE.NAMEDINSTANCE>\n"); |
} | } |
| |
|
//EXP_PULL |
|
//------------------------------------------------------------------------------ |
|
// |
|
// appendValueInstanceWithPathElement() |
|
// |
|
// <!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH,INSTANCE)> |
|
// |
|
//------------------------------------------------------------------------------ |
|
// EXP_PULL_TBD checkout the INSTANCEPATH vs NAMEDINSTANCE |
|
void XmlWriter::appendValueInstanceWithPathElement( |
|
Buffer& out, |
|
const CIMInstance& namedInstance) |
|
{ |
|
out << STRLIT("<VALUE.INSTANCEWITHPATH>\n"); |
|
|
|
appendInstancePathElement(out, namedInstance.getPath ()); |
|
appendInstanceElement(out, namedInstance); |
|
|
|
out << STRLIT("</VALUE.INSTANCEWITHPATH>\n"); |
|
} |
|
//EXP_PULL_END |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// appendClassElement() | // appendClassElement() |
|
|
// EmbeddedObject attribute. | // EmbeddedObject attribute. |
if (a.size() > 0 && a[0].isInstance()) | if (a.size() > 0 && a[0].isInstance()) |
{ | { |
out << STRLIT(" EmbeddedObject=\"object\""); |
out << STRLIT(" EmbeddedObject=\"object\"" |
out << STRLIT(" EMBEDDEDOBJECT=\"object\""); |
" EMBEDDEDOBJECT=\"object\""); |
} | } |
#ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY | #ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY |
else | else |
|
|
} | } |
} | } |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else if (rep->getValue().getType() == CIMTYPE_INSTANCE) | else if (rep->getValue().getType() == CIMTYPE_INSTANCE) |
{ | { |
// If the property array type is CIMInstance, then | // If the property array type is CIMInstance, then |
|
|
// add the EmbeddedObject attribute | // add the EmbeddedObject attribute |
if (a.size() > 0) | if (a.size() > 0) |
{ | { |
out << STRLIT(" EmbeddedObject=\"instance\""); |
out << STRLIT(" EmbeddedObject=\"instance\"" |
out << STRLIT(" EMBEDDEDOBJECT=\"instance\""); |
" EMBEDDEDOBJECT=\"instance\""); |
| |
// Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY is | // Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY is |
// defined, then the EmbeddedInstance qualifier will be added | // defined, then the EmbeddedInstance qualifier will be added |
|
|
# endif | # endif |
} | } |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else | else |
{ | { |
out << STRLIT(" TYPE=\"") |
out.append(' '); |
<< cimTypeToString(rep->getValue().getType()); |
out << xmlWriterTypeStrings(rep->getValue().getType()); |
out.append('"'); |
|
} | } |
| |
if (rep->getArraySize()) | if (rep->getArraySize()) |
|
|
} | } |
else if (rep->getValue().getType() == CIMTYPE_REFERENCE) | else if (rep->getValue().getType() == CIMTYPE_REFERENCE) |
{ | { |
out << STRLIT("<PROPERTY.REFERENCE"); |
out << STRLIT("<PROPERTY.REFERENCE" |
|
" NAME=\"") << rep->getName() << STRLIT("\" "); |
out << STRLIT(" NAME=\"") << rep->getName() << STRLIT("\" "); |
|
| |
if (!rep->getReferenceClassName().isNull()) | if (!rep->getReferenceClassName().isNull()) |
{ | { |
|
|
// EmbeddedObject attribute. | // EmbeddedObject attribute. |
if (a.isInstance()) | if (a.isInstance()) |
{ | { |
out << STRLIT(" EmbeddedObject=\"object\""); |
out << STRLIT(" EmbeddedObject=\"object\"" |
out << STRLIT(" EMBEDDEDOBJECT=\"object\""); |
" EMBEDDEDOBJECT=\"object\""); |
} | } |
// Else the Embedded Object is a class, always add the | // Else the Embedded Object is a class, always add the |
// EmbeddedObject qualifier. | // EmbeddedObject qualifier. |
|
|
} | } |
} | } |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else if (rep->getValue().getType() == CIMTYPE_INSTANCE) | else if (rep->getValue().getType() == CIMTYPE_INSTANCE) |
{ | { |
CIMInstance a; | CIMInstance a; |
rep->getValue().get(a); | rep->getValue().get(a); |
out << " TYPE=\"string\""; |
out << STRLIT(" TYPE=\"string\"" |
out << " EmbeddedObject=\"instance\""; |
" EmbeddedObject=\"instance\"" |
out << " EMBEDDEDOBJECT=\"instance\""; |
" EMBEDDEDOBJECT=\"instance\""); |
| |
# ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY | # ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY |
if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT) | if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT) |
|
|
} | } |
# endif | # endif |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else | else |
{ | { |
out << STRLIT(" TYPE=\"") |
out.append(' '); |
<< cimTypeToString(rep->getValue().getType()); |
out << xmlWriterTypeStrings(rep->getValue().getType()); |
out.append('"'); |
|
} | } |
| |
out << STRLIT(">\n"); | out << STRLIT(">\n"); |
|
|
const CIMMethodRep* rep = method._rep; | const CIMMethodRep* rep = method._rep; |
| |
out << STRLIT("<METHOD NAME=\"") << rep->getName(); | out << STRLIT("<METHOD NAME=\"") << rep->getName(); |
out.append('"'); |
out << STRLIT("\" "); |
| |
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getType()); |
out << xmlWriterTypeStrings(rep->getType()); |
out.append('"'); |
|
| |
if (!rep->getClassOrigin().isNull()) | if (!rep->getClassOrigin().isNull()) |
{ | { |
|
|
} | } |
else | else |
{ | { |
out << STRLIT("<PARAMETER.ARRAY"); |
out << STRLIT("<PARAMETER.ARRAY" |
out << STRLIT(" NAME=\"") << rep->getName(); |
" NAME=\"") << rep->getName(); |
out << STRLIT("\" "); |
out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getType()); |
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getType()); |
|
out.append('"'); |
|
| |
if (rep->getArraySize()) | if (rep->getArraySize()) |
{ | { |
|
|
} | } |
else if (rep->getType() == CIMTYPE_REFERENCE) | else if (rep->getType() == CIMTYPE_REFERENCE) |
{ | { |
out << STRLIT("<PARAMETER.REFERENCE"); |
out << STRLIT("<PARAMETER.REFERENCE" |
out << STRLIT(" NAME=\"") << rep->getName(); |
" NAME=\"") << rep->getName(); |
out.append('"'); | out.append('"'); |
| |
if (!rep->getReferenceClassName().isNull()) | if (!rep->getReferenceClassName().isNull()) |
|
|
} | } |
else | else |
{ | { |
out << STRLIT("<PARAMETER"); |
out << STRLIT("<PARAMETER" |
out << STRLIT(" NAME=\"") << rep->getName(); |
" NAME=\"") << rep->getName(); |
out << STRLIT("\" "); |
out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getType()); |
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getType()); |
|
out << STRLIT("\">\n"); |
out << STRLIT(">\n"); |
| |
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) | for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); | XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
const CIMQualifierRep* rep = qualifier._rep; | const CIMQualifierRep* rep = qualifier._rep; |
| |
out << STRLIT("<QUALIFIER NAME=\"") << rep->getName(); | out << STRLIT("<QUALIFIER NAME=\"") << rep->getName(); |
out.append('"'); |
out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getValue().getType()); |
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getValue().getType()); |
|
out.append('"'); |
|
| |
if (rep->getPropagated()) | if (rep->getPropagated()) |
{ | { |
|
|
const CIMQualifierDeclRep* rep = qualifierDecl._rep; | const CIMQualifierDeclRep* rep = qualifierDecl._rep; |
| |
out << STRLIT("<QUALIFIER.DECLARATION NAME=\"") << rep->getName(); | out << STRLIT("<QUALIFIER.DECLARATION NAME=\"") << rep->getName(); |
out.append('"'); |
out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getValue().getType()); |
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getValue().getType()); |
|
out.append('"'); |
|
| |
if (rep->getValue().isArray()) | if (rep->getValue().isArray()) |
{ | { |
|
|
// TOINSTANCE (true|false) 'false' | // TOINSTANCE (true|false) 'false' |
// TRANSLATABLE (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( | void XmlWriter::appendQualifierFlavorEntity( |
|
|
if (!(flavor.hasFlavor (CIMFlavor::TOSUBCLASS))) | if (!(flavor.hasFlavor (CIMFlavor::TOSUBCLASS))) |
out << STRLIT(" TOSUBCLASS=\"false\""); | out << STRLIT(" TOSUBCLASS=\"false\""); |
| |
if (flavor.hasFlavor (CIMFlavor::TOINSTANCE)) |
//if (flavor.hasFlavor (CIMFlavor::TOINSTANCE)) |
out << STRLIT(" TOINSTANCE=\"true\""); |
// out << STRLIT(" TOINSTANCE=\"true\""); |
| |
if (flavor.hasFlavor (CIMFlavor::TRANSLATABLE)) | if (flavor.hasFlavor (CIMFlavor::TRANSLATABLE)) |
out << STRLIT(" TRANSLATABLE=\"true\""); | out << STRLIT(" TRANSLATABLE=\"true\""); |
|
|
HttpMethod httpMethod, | HttpMethod httpMethod, |
const AcceptLanguageList& acceptLanguages, | const AcceptLanguageList& acceptLanguages, |
const ContentLanguageList& contentLanguages, | const ContentLanguageList& contentLanguages, |
Uint32 contentLength) |
Uint32 contentLength, |
|
bool binaryRequest, |
|
bool binaryResponse) |
{ | { |
char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; | char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; |
| |
|
|
out << STRLIT("POST /cimom HTTP/1.1\r\n"); | out << STRLIT("POST /cimom HTTP/1.1\r\n"); |
} | } |
out << STRLIT("HOST: ") << host << STRLIT("\r\n"); | out << STRLIT("HOST: ") << host << STRLIT("\r\n"); |
|
|
|
if (binaryRequest) |
|
{ |
|
// Tell the server that the payload is encoded in the OpenPegasus |
|
// binary protocol. |
|
out << STRLIT("Content-Type: application/x-openpegasus\r\n"); |
|
} |
|
else |
|
{ |
out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); | out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
|
} |
|
|
|
if (binaryResponse) |
|
{ |
|
// Tell the server that this client accepts the OpenPegasus binary |
|
// protocol. |
|
out << STRLIT("Accept: application/x-openpegasus\r\n"); |
|
} |
|
|
OUTPUT_CONTENTLENGTH(out, contentLength); | OUTPUT_CONTENTLENGTH(out, contentLength); |
if (acceptLanguages.size() > 0) | if (acceptLanguages.size() > 0) |
{ | { |
|
|
static const char *clientTransferEncodingOff = | static const char *clientTransferEncodingOff = |
getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST"); | getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST"); |
| |
if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0') |
// EXP_PULL_TEMP DELETE |
|
// KS_TODO - Remove this. Temp to insure no chunking during testing |
|
// if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0') |
#endif | #endif |
| |
|
// EXP_PULL TEMP DELETE out << STRLIT("TE: chunked, trailers\r\n"); |
|
|
|
if (!binaryResponse) |
|
{ |
|
// The binary protocol does not allow chunking. |
out << STRLIT("TE: chunked, trailers\r\n"); | out << STRLIT("TE: chunked, trailers\r\n"); |
|
} |
| |
if (httpMethod == HTTP_METHOD_M_POST) | if (httpMethod == HTTP_METHOD_M_POST) |
{ | { |
|
|
HttpMethod httpMethod, | HttpMethod httpMethod, |
const ContentLanguageList& contentLanguages, | const ContentLanguageList& contentLanguages, |
Uint32 contentLength, | Uint32 contentLength, |
Uint64 serverResponseTime) |
Uint64 serverResponseTime, |
|
bool binaryResponse) |
{ | { |
char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; |
// 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"); | out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n"); |
| |
#ifndef PEGASUS_DISABLE_PERFINST | #ifndef PEGASUS_DISABLE_PERFINST |
|
|
} | } |
#endif | #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 |
|
{ |
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); | OUTPUT_CONTENTLENGTH(out, contentLength); |
| |
if (contentLanguages.size() > 0) | if (contentLanguages.size() > 0) |
|
|
} | } |
if (httpMethod == HTTP_METHOD_M_POST) | if (httpMethod == HTTP_METHOD_M_POST) |
{ | { |
out << STRLIT("Ext:\r\n"); |
char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; |
out << STRLIT("Cache-Control: no-cache\r\n"); |
|
out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns="); |
out << STRLIT("Ext:\r\n" |
|
"Cache-Control: no-cache\r\n" |
|
"Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns="); |
out << nn << STRLIT("\r\n"); | out << nn << STRLIT("\r\n"); |
out << nn << STRLIT("-CIMOperation: MethodResponse\r\n\r\n"); | out << nn << STRLIT("-CIMOperation: MethodResponse\r\n\r\n"); |
} | } |
|
|
// Returns unauthorized message in the following format: | // Returns unauthorized message in the following format: |
// | // |
// HTTP/1.1 401 Unauthorized | // HTTP/1.1 401 Unauthorized |
// WWW-Authenticate: Basic "hostname:80" |
// WWW-Authenticate: Basic realm="HostName" |
// <HTML><HEAD> | // <HTML><HEAD> |
// <TITLE>401 Unauthorized</TITLE> | // <TITLE>401 Unauthorized</TITLE> |
// </HEAD><BODY BGCOLOR="#99cc99"> | // </HEAD><BODY BGCOLOR="#99cc99"> |
|
|
{ | { |
out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n"); | out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n"); |
OUTPUT_CONTENTLENGTH(out, 0); | OUTPUT_CONTENTLENGTH(out, 0); |
out << content << STRLIT("\r\n"); |
out << content << STRLIT("\r\n\r\n"); |
out << STRLIT("\r\n"); |
|
| |
//ATTN: We may need to include the following line, so that the browsers | //ATTN: We may need to include the following line, so that the browsers |
// can display the error message. | // can display the error message. |
|
|
// may not always be the case so we need to indicate that there | // may not always be the case so we need to indicate that there |
// is no content | // is no content |
OUTPUT_CONTENTLENGTH(out, 0); | OUTPUT_CONTENTLENGTH(out, 0); |
out << content << STRLIT("\r\n"); |
out << content << STRLIT("\r\n\r\n"); |
out << STRLIT("\r\n"); |
|
| |
//ATTN: We may need to include the following line, so that the browsers | //ATTN: We may need to include the following line, so that the browsers |
// can display the error message. | // can display the error message. |
|
|
Buffer& out, | Buffer& out, |
const String& messageId) | const String& messageId) |
{ | { |
out << STRLIT("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"); |
out << STRLIT("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" |
out << STRLIT("<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n"); |
"<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n" |
out << STRLIT("<MESSAGE ID=\"") << messageId; |
"<MESSAGE ID=\"") << messageId; |
out << STRLIT("\" PROTOCOLVERSION=\"1.0\">\n"); | out << STRLIT("\" PROTOCOLVERSION=\"1.0\">\n"); |
} | } |
| |
void XmlWriter::_appendMessageElementEnd( | void XmlWriter::_appendMessageElementEnd( |
Buffer& out) | Buffer& out) |
{ | { |
out << STRLIT("</MESSAGE>\n"); |
out << STRLIT("</MESSAGE>\n</CIM>\n"); |
out << STRLIT("</CIM>\n"); |
|
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// _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"); |
|
} |
|
//------------------------------------------------------------------------------ |
|
// |
// _appendSimpleRspElementBegin() | // _appendSimpleRspElementBegin() |
// _appendSimpleRspElementEnd() | // _appendSimpleRspElementEnd() |
// | // |
|
|
Buffer& out, | Buffer& out, |
const CIMException& cimException) | const CIMException& cimException) |
{ | { |
Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException); |
Tracer::traceCIMException(TRC_XML, Tracer::LEVEL2, cimException); |
| |
out << STRLIT("<ERROR"); |
out << STRLIT("<ERROR CODE=\"") << Uint32(cimException.getCode()); |
out << STRLIT(" CODE=\"") << Uint32(cimException.getCode()); |
|
out.append('"'); | out.append('"'); |
| |
String description = TraceableCIMException(cimException).getDescription(); | String description = TraceableCIMException(cimException).getDescription(); |
|
|
if (type == CIMTYPE_OBJECT) | if (type == CIMTYPE_OBJECT) |
{ | { |
| |
out << STRLIT(" PARAMTYPE=\"string\""); |
out << STRLIT(" PARAMTYPE=\"string\"" |
out << STRLIT(" EmbeddedObject=\"object\""); |
" EmbeddedObject=\"object\"" |
out << STRLIT(" EMBEDDEDOBJECT=\"object\""); |
" EMBEDDEDOBJECT=\"object\""); |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else if (type == CIMTYPE_INSTANCE) | else if (type == CIMTYPE_INSTANCE) |
{ | { |
out << STRLIT(" PARAMTYPE=\"string\""); |
out << STRLIT(" PARAMTYPE=\"string\"" |
out << STRLIT(" EmbeddedObject=\"instance\""); |
" EmbeddedObject=\"instance\"" |
out << STRLIT(" EMBEDDEDOBJECT=\"instance\""); |
" EMBEDDEDOBJECT=\"instance\""); |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else | else |
{ | { |
out << STRLIT(" PARAMTYPE=\"") << cimTypeToString (type); |
out << STRLIT(" PARAM") << xmlWriterTypeStrings(type); |
out.append('"'); |
|
} | } |
} | } |
| |
|
|
out << STRLIT("</IRETURNVALUE>\n"); | 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() | // appendBooleanIParameter() |
|
|
_appendIParamValueElementEnd(out); | _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); |
|
} |
|
|
|
// 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::appendUint32IParameter( |
|
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() | // appendStringIParameter() |
|
|
_appendIParamValueElementEnd(out); | _appendIParamValueElementEnd(out); |
} | } |
| |
|
// EXP_PULL |
|
//------------------------------------------------------------------------------ |
|
// |
|
// 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() | // appendClassNameIParameter() |
|
|
HttpMethod httpMethod, | HttpMethod httpMethod, |
const String& authenticationHeader, | const String& authenticationHeader, |
const AcceptLanguageList& httpAcceptLanguages, | const AcceptLanguageList& httpAcceptLanguages, |
const ContentLanguageList& httpContentLanguages) |
const ContentLanguageList& httpContentLanguages, |
|
bool binaryResponse) |
{ | { |
Buffer out; | Buffer out; |
Buffer tmp; | Buffer tmp; |
|
|
httpMethod, | httpMethod, |
httpAcceptLanguages, | httpAcceptLanguages, |
httpContentLanguages, | httpContentLanguages, |
out.size()); |
out.size(), |
|
false, |
|
binaryResponse); |
tmp << out; | tmp << out; |
| |
return tmp; | return tmp; |
|
|
const String& messageId, | const String& messageId, |
HttpMethod httpMethod, | HttpMethod httpMethod, |
const ContentLanguageList& httpContentLanguages, | const ContentLanguageList& httpContentLanguages, |
|
const Buffer& bodyParams, |
const Buffer& body, | const Buffer& body, |
Uint64 serverResponseTime, | Uint64 serverResponseTime, |
Boolean isFirst, | Boolean isFirst, |
|
|
tmp, | tmp, |
httpMethod, | httpMethod, |
cimException.getContentLanguages(), | cimException.getContentLanguages(), |
out.size()); |
out.size(), |
|
false); |
tmp << out; | tmp << out; |
| |
return tmp; | return tmp; |
|
|
const String& authenticationHeader, | const String& authenticationHeader, |
const AcceptLanguageList& httpAcceptLanguages, | const AcceptLanguageList& httpAcceptLanguages, |
const ContentLanguageList& httpContentLanguages, | const ContentLanguageList& httpContentLanguages, |
const Buffer& body) |
const Buffer& body, |
|
bool binaryResponse) |
{ | { |
Buffer out; | Buffer out; |
Buffer tmp; | Buffer tmp; |
|
|
httpMethod, | httpMethod, |
httpAcceptLanguages, | httpAcceptLanguages, |
httpContentLanguages, | httpContentLanguages, |
out.size()); |
out.size(), |
|
false, |
|
binaryResponse); |
tmp << out; | tmp << out; |
| |
return tmp; | return tmp; |
|
|
// | // |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
| |
|
/* |
|
Formats a IMethod Response Message. Note that 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( | Buffer XmlWriter::formatSimpleIMethodRspMessage( |
const CIMName& iMethodName, | const CIMName& iMethodName, |
const String& messageId, | const String& messageId, |
HttpMethod httpMethod, | HttpMethod httpMethod, |
const ContentLanguageList& httpContentLanguages, | const ContentLanguageList& httpContentLanguages, |
|
const Buffer& rtnParams, |
const Buffer& body, | const Buffer& body, |
Uint64 serverResponseTime, | Uint64 serverResponseTime, |
Boolean isFirst, | Boolean isFirst, |
|
|
{ | { |
if (body.size() != 0 || isFirst == false) | if (body.size() != 0 || isFirst == false) |
_appendIReturnValueElementEnd(out); | _appendIReturnValueElementEnd(out); |
|
// EXP_PULL |
|
// If there are any parameters include them here. |
|
// Assumes that it is prebuilt with all components |
|
// |
|
if (rtnParams.size() != 0) |
|
{ |
|
out << rtnParams; |
|
} |
|
// |
|
// //EXP_PULL_END |
_appendIMethodResponseElementEnd(out); | _appendIMethodResponseElementEnd(out); |
_appendSimpleRspElementEnd(out); | _appendSimpleRspElementEnd(out); |
_appendMessageElementEnd(out); | _appendMessageElementEnd(out); |
|
|
appendMethodResponseHeader(tmp, | appendMethodResponseHeader(tmp, |
httpMethod, | httpMethod, |
cimException.getContentLanguages(), | cimException.getContentLanguages(), |
out.size()); |
out.size(), false); |
tmp << out; | tmp << out; |
| |
return tmp; | return tmp; |
|
|
{ | { |
out << STRLIT("POST ") << requestUri << STRLIT(" HTTP/1.1\r\n"); | out << STRLIT("POST ") << requestUri << STRLIT(" HTTP/1.1\r\n"); |
} | } |
out << STRLIT("HOST: ") << host << STRLIT("\r\n"); |
out << STRLIT("HOST: ") << host << STRLIT("\r\n" |
out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
"Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
OUTPUT_CONTENTLENGTH(out, contentLength); | OUTPUT_CONTENTLENGTH(out, contentLength); |
| |
if (acceptLanguages.size() > 0) | if (acceptLanguages.size() > 0) |
|
|
} | } |
else | else |
{ | { |
out << STRLIT("CIMExport: MethodRequest\r\n"); |
out << STRLIT("CIMExport: MethodRequest\r\n" |
out << STRLIT("CIMExportMethod: ") << cimMethod << STRLIT("\r\n"); |
"CIMExportMethod: ") << cimMethod << STRLIT("\r\n"); |
} | } |
| |
if (authenticationHeader.size()) | if (authenticationHeader.size()) |
|
|
{ | { |
char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; | char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; |
| |
out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n"); |
out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n" |
out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
"Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
OUTPUT_CONTENTLENGTH(out, contentLength); | OUTPUT_CONTENTLENGTH(out, contentLength); |
| |
if (contentLanguages.size() > 0) | if (contentLanguages.size() > 0) |
|
|
} | } |
if (httpMethod == HTTP_METHOD_M_POST) | if (httpMethod == HTTP_METHOD_M_POST) |
{ | { |
out << STRLIT("Ext:\r\n"); |
out << STRLIT("Ext:\r\n" |
out << STRLIT("Cache-Control: no-cache\r\n"); |
"Cache-Control: no-cache\r\n" |
out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns="); |
"Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns="); |
out << nn << STRLIT("\r\n"); | out << nn << STRLIT("\r\n"); |
out << nn << STRLIT("-CIMExport: MethodResponse\r\n\r\n"); | out << nn << STRLIT("-CIMExport: MethodResponse\r\n\r\n"); |
} | } |
|
|
// XmlWriter::keyBindingTypeToString | // XmlWriter::keyBindingTypeToString |
// | // |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
const char* XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type) |
const StrLit XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type) |
{ | { |
switch (type) | switch (type) |
{ | { |
case CIMKeyBinding::BOOLEAN: | case CIMKeyBinding::BOOLEAN: |
return "boolean"; |
return STRLIT("boolean"); |
| |
case CIMKeyBinding::STRING: | case CIMKeyBinding::STRING: |
return "string"; |
return STRLIT("string"); |
| |
case CIMKeyBinding::NUMERIC: | case CIMKeyBinding::NUMERIC: |
return "numeric"; |
return STRLIT("numeric"); |
| |
case CIMKeyBinding::REFERENCE: | case CIMKeyBinding::REFERENCE: |
default: | default: |
PEGASUS_ASSERT(false); | PEGASUS_ASSERT(false); |
} | } |
| |
return "unknown"; |
return STRLIT("unknown"); |
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |