(file) Return to XmlWriter.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlWriter.cpp between version 1.12 and 1.23.2.8

version 1.12, 2001/04/25 22:20:56 version 1.23.2.8, 2001/11/21 07:18:56
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
 //  //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // 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.
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // 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)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 145 
Line 149 
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
  
 static inline void AppendSpecialChar(std::ostream& os, char c)  static inline void AppendSpecialChar(PEGASUS_STD(ostream)& os, char c)
 { {
     switch (c)     switch (c)
     {     {
Line 174 
Line 178 
     }     }
 } }
  
 static inline void AppendSpecial(std::ostream& os, const char* str)  static inline void AppendSpecial(PEGASUS_STD(ostream)& os, const char* str)
 { {
     while (*str)     while (*str)
         AppendSpecialChar(os, *str++);         AppendSpecialChar(os, *str++);
Line 206 
Line 210 
     const char* cimOperation,     const char* cimOperation,
     const char* cimMethod,     const char* cimMethod,
     const String& cimObject,     const String& cimObject,
       const String& authenticationHeader,
     const Array<Sint8>& content)     const Array<Sint8>& content)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 215 
Line 220 
     out << "M-POST /cimom HTTP/1.1\r\n";     out << "M-POST /cimom HTTP/1.1\r\n";
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << content.getSize() << "\r\n";      out << "Content-Length: " << content.size() << "\r\n";
     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
     out << nn <<"\r\n";     out << nn <<"\r\n";
     out << nn << "-CIMOperation: " << cimOperation << "\r\n";     out << nn << "-CIMOperation: " << cimOperation << "\r\n";
     out << nn << "-CIMMethod: " << cimMethod << "\r\n";     out << nn << "-CIMMethod: " << cimMethod << "\r\n";
     out << nn << "-CIMObject: " << cimObject << "\r\n\r\n";      out << nn << "-CIMObject: " << cimObject << "\r\n";
       if (authenticationHeader.size())
       {
           out << authenticationHeader << "\r\n";
       }
       out << "\r\n";
     out << content;     out << content;
     return out;     return out;
 } }
Line 242 
Line 252 
  
     out << "HTTP/1.1 200 OK\r\n";     out << "HTTP/1.1 200 OK\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << content.getSize() << "\r\n";      out << "Content-Length: " << content.size() << "\r\n";
     out << "Ext:\r\n";     out << "Ext:\r\n";
     out << "Cache-Control: no-cache\r\n";     out << "Cache-Control: no-cache\r\n";
     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
Line 264 
Line 274 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMessageElement( Array<Sint8> XmlWriter::formatMessageElement(
     Uint32 messageId,      const String& messageId,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 398 
Line 408 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatErrorElement( Array<Sint8> XmlWriter::formatErrorElement(
     CIMException::Code code,      CIMStatusCode code,
     const char* description)     const char* description)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 428 
Line 438 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // appendStringIParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendStringIParameter(
       Array<Sint8>& out,
       const char* name,
       const String& str)
   {
       Array<Sint8> tmp;
       tmp << "<VALUE>";
       appendSpecial(tmp, str);
       tmp << "</VALUE>\n";
       return formatIParamValueElement(out, name, tmp);
   }
   
   //------------------------------------------------------------------------------
   //
 // appendClassNameParameter() // appendClassNameParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 514 
Line 542 
     return formatIParamValueElement(out, parameterName, tmp);     return formatIParamValueElement(out, parameterName, tmp);
 } }
  
   //------------------------------------------------------------------------------
   //
   // appendNamedInstanceParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendNamedInstanceParameter(
       Array<Sint8>& out,
       const char* parameterName,
       const CIMNamedInstance& namedInstance)
   {
       Array<Sint8> tmp;
       namedInstance.toXml(tmp);
       return formatIParamValueElement(out, parameterName, tmp);
   }
   
 //---------------------------------------------------------- //----------------------------------------------------------
 // //
 //  appendPropertyNameParameter() //  appendPropertyNameParameter()
Line 533 
Line 577 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassParameter()  // appendPropertyValueParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendPropertyValueParameter(
       Array<Sint8>& out,
       const char* parameterName,
       const CIMValue& value)
   {
       Array<Sint8> tmp;
       value.toXml(tmp);
       return formatIParamValueElement(out, parameterName, tmp);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendPropertyListParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendPropertyListParameter(
       Array<Sint8>& out,
       const CIMPropertyList& propertyList)
   {
       Array<Sint8> tmp;
   
       tmp << "<VALUE.ARRAY>\n";
       for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)
       {
           tmp << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";
       }
       tmp << "</VALUE.ARRAY>\n";
       return formatIParamValueElement(out, "PropertyList", tmp);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendQualifierDeclarationParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
Line 581 
Line 662 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _printAttributes( static void _printAttributes(
     std::ostream& os,      PEGASUS_STD(ostream)& os,
     const XmlAttribute* attributes,     const XmlAttribute* attributes,
     Uint32 attributeCount)     Uint32 attributeCount)
 { {
Line 604 
Line 685 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _indent(std::ostream& os, Uint32 level, Uint32 indentChars)  static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
 { {
     Uint32 n = level * indentChars;     Uint32 n = level * indentChars;
  
Line 619 
Line 700 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::indentedPrint( void XmlWriter::indentedPrint(
     std::ostream& os,      PEGASUS_STD(ostream)& os,
     const char* text,     const char* text,
     Uint32 indentChars)     Uint32 indentChars)
 { {
Line 635 
Line 716 
         {         {
             case XmlEntry::XML_DECLARATION:             case XmlEntry::XML_DECLARATION:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "<?" << entry.text << " ";                 os << "<?" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                 _printAttributes(os, entry.attributes, entry.attributeCount);
Line 645 
Line 726 
  
             case XmlEntry::START_TAG:             case XmlEntry::START_TAG:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text;                 os << "<" << entry.text;
  
Line 660 
Line 741 
  
             case XmlEntry::EMPTY_TAG:             case XmlEntry::EMPTY_TAG:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text << " ";                 os << "<" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                 _printAttributes(os, entry.attributes, entry.attributeCount);
Line 673 
Line 754 
                 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)                 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
                     stack.pop();                     stack.pop();
  
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "</" << entry.text << ">";                 os << "</" << entry.text << ">";
                 break;                 break;
Line 682 
Line 763 
             case XmlEntry::COMMENT:             case XmlEntry::COMMENT:
             {             {
  
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 os << "<!--";                 os << "<!--";
                 AppendSpecial(os, entry.text);                 AppendSpecial(os, entry.text);
                 os << "-->";                 os << "-->";
Line 691 
Line 772 
  
             case XmlEntry::CONTENT:             case XmlEntry::CONTENT:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 AppendSpecial(os, entry.text);                 AppendSpecial(os, entry.text);
                 break;                 break;
             }             }
  
             case XmlEntry::CDATA:             case XmlEntry::CDATA:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 os << "<![CDATA[...]]>";                 os << "<![CDATA[...]]>";
                 break;                 break;
             }             }
  
             case XmlEntry::DOCTYPE:             case XmlEntry::DOCTYPE:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 os << "<!DOCTYPE...>";                 os << "<!DOCTYPE...>";
                 break;                 break;
             }             }
         }         }
  
         os << std::endl;          os << PEGASUS_STD(endl);
     }     }
  
     delete [] tmp;     delete [] tmp;
Line 723 
Line 804 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Uint32 XmlWriter::getNextMessageId()  String XmlWriter::getNextMessageId()
 { {
     // ATTN: make thread-safe:     // ATTN: make thread-safe:
     static Uint32 messageId = 1000;     static Uint32 messageId = 1000;
Line 733 
Line 814 
     if (messageId < 1000)     if (messageId < 1000)
         messageId = 1001;         messageId = 1001;
  
     return messageId;      char buffer[16];
       sprintf(buffer, "%d", messageId);
       return buffer;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleReqMessage()  // XmlWriter::formatSimpleIMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleReqMessage(  Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(
     const char* host,     const char* host,
     const String& nameSpace,     const String& nameSpace,
     const char* iMethodName,     const char* iMethodName,
       const String& messageId,
       const String& authenticationHeader,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     return XmlWriter::formatMPostHeader(     return XmlWriter::formatMPostHeader(
Line 753 
Line 838 
         "MethodCall",         "MethodCall",
         iMethodName,         iMethodName,
         nameSpace,         nameSpace,
           authenticationHeader,
         XmlWriter::formatMessageElement(         XmlWriter::formatMessageElement(
             XmlWriter::getNextMessageId(),              messageId,
             XmlWriter::formatSimpleReqElement(             XmlWriter::formatSimpleReqElement(
                 XmlWriter::formatIMethodCallElement(                 XmlWriter::formatIMethodCallElement(
                     iMethodName,                     iMethodName,
Line 764 
Line 850 
  
 Array<Sint8> XmlWriter::formatSimpleRspMessage( Array<Sint8> XmlWriter::formatSimpleRspMessage(
     const char* iMethodName,     const char* iMethodName,
       const String& messageId,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     return XmlWriter::formatMethodResponseHeader(     return XmlWriter::formatMethodResponseHeader(
         XmlWriter::formatMessageElement(         XmlWriter::formatMessageElement(
             XmlWriter::getNextMessageId(),              messageId,
             XmlWriter::formatSimpleRspElement(             XmlWriter::formatSimpleRspElement(
                 XmlWriter::formatIMethodResponseElement(                 XmlWriter::formatIMethodResponseElement(
                     iMethodName,                     iMethodName,
                     XmlWriter::formatIReturnValueElement(body)))));                     XmlWriter::formatIReturnValueElement(body)))));
 } }
  
   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, 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>& XmlWriter::appendObjectNameParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMReference& objectName)
   {
       if (objectName.isClassName())
       {
           XmlWriter::appendClassNameParameter(
               out, name, objectName.getClassName());
       }
       else
       {
           XmlWriter::appendInstanceNameParameter(
               out, name, objectName);
       }
   
       return out;
   }
   
   Array<Sint8> XmlWriter::formatEMethodCallElement(
       const char* name,
       const Array<Sint8>& iParamValues)
   {
       Array<Sint8> out;
       out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
       out << iParamValues;
       out << "</EXPMETHODCALL>\n";
       return out;
   }
   
   Array<Sint8> XmlWriter::formatSimpleIndicationReqMessage(
       const char* host,
       const char* iMethodName,
       const String& messageId,
       const String& authenticationHeader,
       const Array<Sint8>& body)
   {
       return XmlWriter::formatMPostIndicationHeader(
           host,
           "MethodRequest",
           iMethodName,
           authenticationHeader,
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleExportReqElement(
                   XmlWriter::formatEMethodCallElement(
                       iMethodName,
                       body))));
   }
   
   Array<Sint8> XmlWriter::formatMPostIndicationHeader(
       const char* host,
       const char* cimOperation,
       const char* cimMethod,
       const String& authenticationHeader,
       const Array<Sint8>& content)
   {
       Array<Sint8> out;
       out.reserve(1024);
       char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
       out << "M-POST /cimom HTTP/1.1\r\n";
       out << "HOST: " << host << "\r\n";
       out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
       out << "Content-Length: " << content.size() << "\r\n";
       out << "Man: http://www.hp.com; ns=";
       out << nn <<"\r\n";
       out << nn << "-CIMExport: " << cimOperation << "\r\n";
       out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
       if (authenticationHeader.size())
       {
           out << authenticationHeader << "\r\n";
       }
       out << "\r\n";
       out << content;
       return out;
   }
   
   Array<Sint8> XmlWriter::formatSimpleExportReqElement(
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       return out << "<SIMPLEEXPREQ>\n" << body << "</SIMPLEEXPREQ>\n";
   }
   
   Array<Sint8> XmlWriter::formatSimpleIndicationRspMessage(
       const char* iMethodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       return XmlWriter::formatEMethodResponseHeader(
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleExportRspElement(
                   XmlWriter::formatEMethodResponseElement(
                       iMethodName,
                       XmlWriter::formatIReturnValueElement(body)))));
   }
   
   //------------------------------------------------------------------------------
   //
   // formatSimpleExportRspElement()
   //
   //     <!ELEMENT SIMPLEEXPRSP (METHODRESPONSE|EXPMETHODRESPONSE)>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatSimpleExportRspElement(
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       return out << "<SIMPLEEXPRSP>\n" << body << "</SIMPLEEXPRSP>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // formatIMethodResponseElement()
   //
   //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatEMethodResponseElement(
       const char* name,
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
       out << body;
       out << "</EXPMETHODRESPONSE>\n";
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // formatMethodResponseHeader()
   //
   //     Build HTTP response header.
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatEMethodResponseHeader(
       const Array<Sint8>& content)
   {
       Array<Sint8> out;
       out.reserve(1024);
       char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
       out << "HTTP/1.1 200 OK\r\n";
       out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
       out << "Content-Length: " << content.size() << "\r\n";
       out << "Ext:\r\n";
       out << "Cache-Control: no-cache\r\n";
       out << "Man:  http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
       out << nn <<"\r\n";
       out << nn << "-CIMExport: MethodResponse\r\n\r\n";
       out << content;
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // XmlWriter::formatSimpleMethodReqMessage()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
       const char* host,
       const String& nameSpace,
       const char* iMethodName,
       const String& messageId,
      const String& authenticationHeader,
       const Array<Sint8>& body)
   {
       return XmlWriter::formatMPostHeader(
           host,
           "MethodCall",
           iMethodName,
           nameSpace,
           authenticationHeader,
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleReqElement(
                   XmlWriter::formatMethodCallElement(
                       iMethodName,
                       nameSpace,
                       body))));
   }
   
   //------------------------------------------------------------------------------
   //
   // formatMethodCallElement()
   //
   //     <!ELEMENT METHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
   //     <!ATTLIST METHODCALL %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatMethodCallElement(
       const char* name,
       const String& nameSpace,
       const Array<Sint8>& iParamValues)
   {
       Array<Sint8> out;
       out << "<METHODCALL NAME=\"" << name << "\">\n";
       out << iParamValues;
       out << "</METHODCALL>\n";
       return out;
   }
   
   Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
       const char* iMethodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       /*return XmlWriter::formatMethodResponseHeader(
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleRspElement(
                   XmlWriter::formatMethodResponseElement(
                       iMethodName,
                       XmlWriter::formatReturnValueElement(body)))));*/
       return XmlWriter::formatMethodResponseHeader(
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleRspElement(
                   XmlWriter::formatMethodResponseElement(
                       iMethodName,
                       body))));
   }
   
   //------------------------------------------------------------------------------
   //
   // formatMethodResponseElement()
   //
   //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST METHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatMethodResponseElement(
       const char* name,
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
       out << body;
       out << "</METHODRESPONSE>\n";
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // appendStringParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendStringParameter(
       Array<Sint8>& out,
       const char* name,
       const String& str)
   {
       Array<Sint8> tmp;
       tmp << "<VALUE>";
       appendSpecial(tmp, str);
       tmp << "</VALUE>\n";
       return formatParamValueElement(out, name, tmp);
   }
   
   //------------------------------------------------------------------------------
   //
   // formatParamValueElement()
   //
   //     <!ELEMENT PARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
   //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
   //         |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
   //     <!ATTLIST PARAMVALUE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::formatParamValueElement(
       Array<Sint8>& out,
       const char* name,
       const Array<Sint8>& body)
   {
       out << "<PARAMVALUE NAME=\"" << name << "\">\n";
       out << body;
       out << "</PARAMVALUE>\n";
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // formatReturnValueElement()
   //
   //      <!ELEMENT RETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
   //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
   //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
   //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatReturnValueElement(
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       return out << "<RETURNVALUE>\n" << body << "</RETURNVALUE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // formatUnauthorizedResponseHeader()
   //
   //     Build HTTP authentication response header for unauthorized requests.
   //
   //     Returns unauthorized message in the following format:
   //
   //        HTTP/1.1 401 Unauthorized
   //        WWW-Authenticate: Basic "hostname:80"
   //        <HTML><HEAD>
   //        <TITLE>401 Unauthorized</TITLE>
   //        </HEAD><BODY BGCOLOR="#99cc99">
   //        <H2>TEST401 Unauthorized</H2>
   //        <HR>
   //        </BODY></HTML>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatUnauthorizedResponseHeader(
       const String& content)
   {
       Array<Sint8> out;
       out.reserve(1024);
   
       out << "HTTP/1.1 401 Unauthorized\r\n";
       out << content << "\r\n";
       out << "\r\n";
   
   //ATTN: We may need to include the following line, so that the browsers
   //      can display the error message.
   //    out << "<HTML><HEAD>\r\n";
   //    out << "<TITLE>" << "401 Unauthorized" <<  "</TITLE>\r\n";
   //    out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
   //    out << "<H2>TEST" << "401 Unauthorized" << "</H2>\r\n";
   //    out << "<HR>\r\n";
   //    out << "</BODY></HTML>\r\n";
   
       return out;
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.12  
changed lines
  Added in v.1.23.2.8
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2