(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.26 and 1.27

version 1.26, 2002/02/20 23:14:19 version 1.27, 2002/02/28 23:06:41
Line 39 
Line 39 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 inline void AppendChar(Array<Sint8>& out, Char16 c)  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;
   }
   
   inline void _appendChar(Array<Sint8>& out, Char16 c)
 { {
     out.append(Sint8(c));     out.append(Sint8(c));
 } }
  
 inline void AppendSpecialChar(Array<Sint8>& out, Char16 c)  inline void _appendSpecialChar(Array<Sint8>& out, Char16 c)
 { {
     // ATTN-B: Only UTF-8 handled for now.     // ATTN-B: Only UTF-8 handled for now.
  
Line 75 
Line 117 
     }     }
 } }
  
   static inline void _appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
   {
       switch (c)
       {
           case '&':
               os << "&amp;";
               break;
   
           case '<':
               os << "&lt;";
               break;
   
           case '>':
               os << "&gt;";
               break;
   
           case '"':
               os << "&quot;";
               break;
   
           case '\'':
               os << "&apos;";
               break;
   
           default:
               os << c;
       }
   }
   
   static inline void _appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
   {
       while (*str)
           _appendSpecialChar(os, *str++);
   }
   
 void XmlWriter::append(Array<Sint8>& out, Char16 x) void XmlWriter::append(Array<Sint8>& out, Char16 x)
 { {
     AppendChar(out, x);      _appendChar(out, x);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint32 x) void XmlWriter::append(Array<Sint8>& out, Uint32 x)
Line 90 
Line 167 
 void XmlWriter::append(Array<Sint8>& out, const char* str) void XmlWriter::append(Array<Sint8>& out, const char* str)
 { {
     while (*str)     while (*str)
         AppendChar(out, *str++);          _appendChar(out, *str++);
   }
   
   void XmlWriter::append(Array<Sint8>& out, const String& str)
   {
       const Char16* tmp = str.getData();
   
       while (*tmp)
           _appendChar(out, *tmp++);
   }
   
   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, Char16 x) void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)
 { {
     AppendSpecialChar(out, x);      _appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x) void XmlWriter::appendSpecial(Array<Sint8>& out, char x)
 { {
     AppendSpecialChar(out, Char16(x));      _appendSpecialChar(out, Char16(x));
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str) void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)
 { {
     while (*str)     while (*str)
         AppendSpecialChar(out, *str++);          _appendSpecialChar(out, *str++);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str) void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)
Line 114 
Line 205 
     const Char16* tmp = str.getData();     const Char16* tmp = str.getData();
  
     while (*tmp)     while (*tmp)
         AppendSpecialChar(out, *tmp++);          _appendSpecialChar(out, *tmp++);
 }  
   
 void XmlWriter::append(Array<Sint8>& out, const String& str)  
 {  
     const Char16* tmp = str.getData();  
   
     while (*tmp)  
         AppendChar(out, *tmp++);  
 }  
   
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)  
 {  
     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)  
         out.append(' ');  
 } }
  
 void XmlWriter::appendLocalNameSpaceElement( void XmlWriter::appendLocalNameSpaceElement(
Line 149 
Line 226 
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
  
 static inline void AppendSpecialChar(PEGASUS_STD(ostream)& os, char c)  
 {  
     switch (c)  
     {  
         case '&':  
             os << "&amp;";  
             break;  
   
         case '<':  
             os << "&lt;";  
             break;  
   
         case '>':  
             os << "&gt;";  
             break;  
   
         case '"':  
             os << "&quot;";  
             break;  
   
         case '\'':  
             os << "&apos;";  
             break;  
   
         default:  
             os << c;  
     }  
 }  
   
 static inline void AppendSpecial(PEGASUS_STD(ostream)& os, const char* str)  
 {  
     while (*str)  
         AppendSpecialChar(os, *str++);  
 }  
   
 //------------------------------------------------------------------------------  
 //  
 // formatGetHeader()  
 //  
 //------------------------------------------------------------------------------  
   
 Array<Sint8> XmlWriter::formatGetHeader(  
     const char* documentPath)  
 {  
     Array<Sint8> out;  
     return out << "GET " << documentPath << "HTTP/1.0\r\n\r\n";  
 }  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMPostHeader()  // appendMethodCallHeader()
 // //
 //     Build HTTP request header. //     Build HTTP request header.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMPostHeader(  void XmlWriter::appendMethodCallHeader(
       Array<Sint8>& out,
     const char* host,     const char* host,
     const char* cimOperation,  
     const char* cimMethod,     const char* cimMethod,
     const String& cimObject,     const String& cimObject,
     const String& authenticationHeader,     const String& authenticationHeader,
     const Array<Sint8>& content)      Uint32 contentLength)
 { {
     Array<Sint8> out;  
     out.reserve(1024);  
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     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.size() << "\r\n";      out << "Content-Length: " << contentLength << "\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: MethodCall\r\n";
     out << nn << "-CIMMethod: " << cimMethod << "\r\n";     out << nn << "-CIMMethod: " << cimMethod << "\r\n";
     out << nn << "-CIMObject: " << cimObject << "\r\n";     out << nn << "-CIMObject: " << cimObject << "\r\n";
     if (authenticationHeader.size())     if (authenticationHeader.size())
Line 231 
Line 258 
         out << authenticationHeader << "\r\n";         out << authenticationHeader << "\r\n";
     }     }
     out << "\r\n";     out << "\r\n";
     out << content;  
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMethodResponseHeader()  // appendMethodResponseHeader()
 // //
 //     Build HTTP response header. //     Build HTTP response header.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMethodResponseHeader(  void XmlWriter::appendMethodResponseHeader(
     const Array<Sint8>& content)      Array<Sint8>& out,
       Uint32 contentLength)
 { {
     Array<Sint8> out;  
     out.reserve(1024);  
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     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.size() << "\r\n";      out << "Content-Length: " << contentLength << "\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=";
     out << nn <<"\r\n";     out << nn <<"\r\n";
     out << nn << "-CIMOperation: MethodResponse\r\n\r\n";     out << nn << "-CIMOperation: MethodResponse\r\n\r\n";
     out << content;  
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMessageElement()  // appendUnauthorizedResponseHeader()
   //
   //     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>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendUnauthorizedResponseHeader(
       Array<Sint8>& out,
       const String& content)
   {
       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";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendMessageElementBegin()
   // appendMessageElementEnd()
 // //
 //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)> //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
 //     <!ATTLIST MESSAGE //     <!ATTLIST MESSAGE
Line 273 
Line 333 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMessageElement(  void XmlWriter::appendMessageElementBegin(
     const String& messageId,      Array<Sint8>& out,
     const Array<Sint8>& body)      const String& messageId)
 { {
     Array<Sint8> out;  
     out.reserve(1024);  
   
     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
     out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";     out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";
     out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";     out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
     out << body;  }
   
   void XmlWriter::appendMessageElementEnd(
       Array<Sint8>& out)
   {
     out << "</MESSAGE>\n";     out << "</MESSAGE>\n";
     out << "</CIM>\n";     out << "</CIM>\n";
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatSimpleReqElement()  // appendSimpleReqElementBegin()
   // appendSimpleReqElementEnd()
 // //
 //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)> //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleReqElement(  void XmlWriter::appendSimpleReqElementBegin(
     const Array<Sint8>& body)      Array<Sint8>& out)
 { {
     Array<Sint8> out;      out << "<SIMPLEREQ>\n";
     return out << "<SIMPLEREQ>\n" << body << "</SIMPLEREQ>\n";  }
   
   void XmlWriter::appendSimpleReqElementEnd(
       Array<Sint8>& out)
   {
       out << "</SIMPLEREQ>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatSimpleRspElement()  // appendMethodCallElementBegin()
   // appendMethodCallElementEnd()
 // //
 //     <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>  //     <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
   //     <!ATTLIST METHODCALL %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleRspElement(  void XmlWriter::appendMethodCallElementBegin(
     const Array<Sint8>& body)      Array<Sint8>& out,
       const char* name)
 { {
     Array<Sint8> out;      out << "<METHODCALL NAME=\"" << name << "\">\n";
     return out << "<SIMPLERSP>\n" << body << "</SIMPLERSP>\n";  }
   
   void XmlWriter::appendMethodCallElementEnd(
       Array<Sint8>& out)
   {
       out << "</METHODCALL>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodCallElement()  // appendIMethodCallElementBegin()
   // appendIMethodCallElementEnd()
 // //
 //     <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)> //     <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
 //     <!ATTLIST IMETHODCALL %CIMName;> //     <!ATTLIST IMETHODCALL %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIMethodCallElement(  void XmlWriter::appendIMethodCallElementBegin(
     const char* name,      Array<Sint8>& out,
     const String& nameSpace,      const char* name)
     const Array<Sint8>& iParamValues)  
 { {
     Array<Sint8> out;  
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";     out << "<IMETHODCALL NAME=\"" << name << "\">\n";
     XmlWriter::appendLocalNameSpaceElement(out, nameSpace);  }
     out << iParamValues;  
   void XmlWriter::appendIMethodCallElementEnd(
       Array<Sint8>& out)
   {
     out << "</IMETHODCALL>\n";     out << "</IMETHODCALL>\n";
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodResponseElement()  // appendIParamValueElementBegin()
   // appendIParamValueElementEnd()
 // //
 //     <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>  //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
 //     <!ATTLIST IMETHODRESPONSE %CIMName;>  //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
   //         |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
   //     <!ATTLIST IPARAMVALUE %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIMethodResponseElement(  void XmlWriter::appendIParamValueElementBegin(
     const char* name,      Array<Sint8>& out,
     const Array<Sint8>& body)      const char* name)
 { {
     Array<Sint8> out;      out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";  }
     out << body;  
     out << "</IMETHODRESPONSE>\n";  void XmlWriter::appendIParamValueElementEnd(
     return out;      Array<Sint8>& out)
   {
       out << "</IPARAMVALUE>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIReturnValueElement()  // appendSimpleRspElementBegin()
   // appendSimpleRspElementEnd()
 // //
 //      <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|  //     <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
 //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|  
 //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|  
 //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIReturnValueElement(  void XmlWriter::appendSimpleRspElementBegin(
     const Array<Sint8>& body)      Array<Sint8>& out)
 { {
     Array<Sint8> out;      out << "<SIMPLERSP>\n";
     return out << "<IRETURNVALUE>\n" << body << "</IRETURNVALUE>\n";  }
   
   void XmlWriter::appendSimpleRspElementEnd(
       Array<Sint8>& out)
   {
       out << "</SIMPLERSP>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIParamValueElement()  // appendMethodResponseElementBegin()
   // appendMethodResponseElementEnd()
 // //
 //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE  //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
 //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION  //     <!ATTLIST METHODRESPONSE %CIMName;>
 //         |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>  
 //     <!ATTLIST IPARAMVALUE %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::formatIParamValueElement(  void XmlWriter::appendMethodResponseElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      const char* name)
     const Array<Sint8>& body)  
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";      out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
     out << body;  }
     out << "</IPARAMVALUE>\n";  
     return out;  void XmlWriter::appendMethodResponseElementEnd(
       Array<Sint8>& out)
   {
       out << "</METHODRESPONSE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendIMethodResponseElementBegin()
   // appendIMethodResponseElementEnd()
   //
   //     <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST IMETHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendIMethodResponseElementBegin(
       Array<Sint8>& out,
       const char* name)
   {
       out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
   }
   
   void XmlWriter::appendIMethodResponseElementEnd(
       Array<Sint8>& out)
   {
       out << "</IMETHODRESPONSE>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatErrorElement()  // appendErrorElement()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatErrorElement(  void XmlWriter::appendErrorElement(
       Array<Sint8>& out,
     CIMStatusCode code,     CIMStatusCode code,
     const char* description)     const char* description)
 { {
     Array<Sint8> out;  
     out << "<ERROR";     out << "<ERROR";
     out << " CODE=\"" << Uint32(code) << "\"";     out << " CODE=\"" << Uint32(code) << "\"";
     out << " DESCRIPTION=\"";     out << " DESCRIPTION=\"";
     appendSpecial(out, description);     appendSpecial(out, description);
     out << "\"/>";     out << "\"/>";
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendBooleanParameter()  // appendReturnValueElement()
   //
   // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
   // <!ATTLIST RETURNVALUE
   //     %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendBooleanParameter(  void XmlWriter::appendReturnValueElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      const CIMValue& value)
     Boolean flag)  
 { {
     Array<Sint8> tmp;      out << "<RETURNVALUE";
     tmp << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";  
     return formatIParamValueElement(out, name, tmp);      CIMType type = value.getType();
       if (type != CIMType::NONE)
       {
           out << " PARAMTYPE=\"" << TypeToString(type) << "\"";
       }
   
       out << ">\n";
       value.toXml(out);
       out << "</RETURNVALUE>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendStringIParameter()  // appendIReturnValueElementBegin()
   // appendIReturnValueElementEnd()
   //
   //      <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
   //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
   //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
   //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendIReturnValueElementBegin(
       Array<Sint8>& out)
   {
       out << "<IRETURNVALUE>\n";
   }
   
   void XmlWriter::appendIReturnValueElementEnd(
       Array<Sint8>& out)
   {
       out << "</IRETURNVALUE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendBooleanIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendStringIParameter(  void XmlWriter::appendBooleanIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const String& str)      Boolean flag)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     tmp << "<VALUE>";      out << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";
     appendSpecial(tmp, str);      appendIParamValueElementEnd(out);
     tmp << "</VALUE>\n";  
     return formatIParamValueElement(out, name, tmp);  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassNameParameter()  // appendStringIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassNameParameter(  void XmlWriter::appendStringIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const String& className)      const String& str)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     appendClassNameElement(tmp, className);      out << "<VALUE>";
     return formatIParamValueElement(out, name, tmp);      appendSpecial(out, str);
       out << "</VALUE>\n";
       appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendQualifierNameParameter()  // appendQualifierNameIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendQualifierNameParameter(  void XmlWriter::appendQualifierNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const String& qualifierName)     const String& qualifierName)
Line 489 
Line 630 
     // as an IPARAMVALUE element according to the spec (look above). So we     // 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.     // just pass it as a class name. An answer must be obtained later.
  
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     appendClassNameElement(tmp, qualifierName);      appendClassNameElement(out, qualifierName);
     return formatIParamValueElement(out, name, tmp);      appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassParameter()  // appendClassNameIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassParameter(  void XmlWriter::appendClassNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMConstClass& cimClass)      const String& className)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     cimClass.toXml(tmp);      appendClassNameElement(out, className);
     return formatIParamValueElement(out, parameterName, tmp);      appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceNameParameter()  // appendInstanceNameIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceNameParameter(  void XmlWriter::appendInstanceNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMReference& instanceName)     const CIMReference& instanceName)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     instanceName.instanceNameToXml(tmp);      instanceName.instanceNameToXml(out);
     return formatIParamValueElement(out, parameterName, tmp);      appendIParamValueElementEnd(out);
   }
   
   void XmlWriter::appendObjectNameIParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMReference& objectName)
   {
       if (objectName.isClassName())
       {
           XmlWriter::appendClassNameIParameter(
               out, name, objectName.getClassName());
       }
       else
       {
           XmlWriter::appendInstanceNameIParameter(
               out, name, objectName);
       }
   }
   
   //------------------------------------------------------------------------------
   //
   // appendClassIParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassIParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMConstClass& cimClass)
   {
       appendIParamValueElementBegin(out, name);
       cimClass.toXml(out);
       appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceParameter()  // appendInstanceIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceParameter(  void XmlWriter::appendInstanceIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     instance.toXml(tmp);      instance.toXml(out);
     return formatIParamValueElement(out, parameterName, tmp);      appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendNamedInstanceParameter()  // appendNamedInstanceIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendNamedInstanceParameter(  void XmlWriter::appendNamedInstanceIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMNamedInstance& namedInstance)     const CIMNamedInstance& namedInstance)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     namedInstance.toXml(tmp);      namedInstance.toXml(out);
     return formatIParamValueElement(out, parameterName, tmp);      appendIParamValueElementEnd(out);
 } }
  
 //---------------------------------------------------------- //----------------------------------------------------------
 // //
 //  appendPropertyNameParameter()  //  appendPropertyNameIParameter()
 // //
 //     </IPARAMVALUE> //     </IPARAMVALUE>
 //     <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE> //     <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
 // //
 //     USE: Create parameter for getProperty operation //     USE: Create parameter for getProperty operation
 //========================================================== //==========================================================
 Array<Sint8>& XmlWriter::appendPropertyNameParameter(  void XmlWriter::appendPropertyNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& propertyName)     const String& propertyName)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, "PropertyName");
     tmp << "<VALUE>" << propertyName << "</VALUE>\n";      out << "<VALUE>" << propertyName << "</VALUE>\n";
     return formatIParamValueElement(out,"PropertyName", tmp);}      appendIParamValueElementEnd(out);
   }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendPropertyValueParameter()  // appendPropertyValueIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendPropertyValueParameter(  void XmlWriter::appendPropertyValueIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMValue& value)     const CIMValue& value)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     value.toXml(tmp);      value.toXml(out);
     return formatIParamValueElement(out, parameterName, tmp);      appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendPropertyListParameter()  // appendPropertyListIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendPropertyListParameter(  void XmlWriter::appendPropertyListIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, "PropertyList");
  
     tmp << "<VALUE.ARRAY>\n";      out << "<VALUE.ARRAY>\n";
     for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)     for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)
     {     {
         tmp << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";          out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";
     }     }
     tmp << "</VALUE.ARRAY>\n";      out << "</VALUE.ARRAY>\n";
     return formatIParamValueElement(out, "PropertyList", tmp);  
       appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendQualifierDeclarationParameter()  // appendQualifierDeclarationIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter(  void XmlWriter::appendQualifierDeclarationIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     Array<Sint8> tmp;      appendIParamValueElementBegin(out, name);
     qualifierDecl.toXml(tmp);      qualifierDecl.toXml(out);
     return formatIParamValueElement(out, parameterName, tmp);      appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 634 
Line 810 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassNameElement(  void XmlWriter::appendClassNameElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& className)     const String& className)
 { {
     return out << "<CLASSNAME NAME=\"" << className << "\"/>\n";      out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 647 
Line 823 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceNameElement(  void XmlWriter::appendInstanceNameElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& instanceName)     const CIMReference& instanceName)
 { {
     instanceName.instanceNameToXml(out);     instanceName.instanceNameToXml(out);
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _printAttributes()  // XmlWriter::formatSimpleMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _printAttributes(  // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
     PEGASUS_STD(ostream)& os,  Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
     const XmlAttribute* attributes,      const char* host,
     Uint32 attributeCount)      const String& nameSpace,
 {      const char* methodName,
     for (Uint32 i = 0; i < attributeCount; i++)      const String& messageId,
       const String& authenticationHeader,
       const Array<Sint8>& body)
     {     {
         os << attributes[i].name << "=";      Array<Sint8> out;
       Array<Sint8> tmp;
  
         os << '"';      appendMessageElementBegin(out, messageId);
         AppendSpecial(os, attributes[i].value);      appendSimpleReqElementBegin(out);
         os << '"';      appendMethodCallElementBegin(out, methodName);
   //    appendLocalPathElement(out, nameSpace); // ATTN-RK-P1-20020228:  Need this
       out << body;
       appendMethodCallElementEnd(out);
       appendSimpleReqElementEnd(out);
       appendMessageElementEnd(out);
  
         if (i + 1 != attributeCount)      appendMethodCallHeader(
             os << ' ';          tmp,
           host,
           methodName,
           nameSpace,  // ATTN-RK: Is this right?
           authenticationHeader,
           out.size());
       tmp << out;
   
       return tmp;
     }     }
   
   Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
       const char* methodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       Array<Sint8> tmp;
   
       appendMessageElementBegin(out, messageId);
       appendSimpleRspElementBegin(out);
       appendMethodResponseElementBegin(out, methodName);
       out << body;
       appendMethodResponseElementEnd(out);
       appendSimpleRspElementEnd(out);
       appendMessageElementEnd(out);
   
       appendMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _indent()  // XmlWriter::formatSimpleIMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)  Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(
       const char* host,
       const String& nameSpace,
       const char* iMethodName,
       const String& messageId,
       const String& authenticationHeader,
       const Array<Sint8>& body)
 { {
     Uint32 n = level * indentChars;      Array<Sint8> out;
       Array<Sint8> tmp;
  
     for (Uint32 i = 0; i < n; i++)      appendMessageElementBegin(out, messageId);
         os << ' ';      appendSimpleReqElementBegin(out);
       appendIMethodCallElementBegin(out, iMethodName);
       appendLocalNameSpaceElement(out, nameSpace);
       out << body;
       appendIMethodCallElementEnd(out);
       appendSimpleReqElementEnd(out);
       appendMessageElementEnd(out);
   
       appendMethodCallHeader(
           tmp,
           host,
           iMethodName,
           nameSpace,
           authenticationHeader,
           out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // indentedPrint()  // XmlWriter::formatSimpleIMethodRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::indentedPrint(  Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(
     PEGASUS_STD(ostream)& os,      const char* iMethodName,
     const char* text,      const String& messageId,
     Uint32 indentChars)      const Array<Sint8>& body)
 { {
     char* tmp = strcpy(new char[strlen(text) + 1], text);      Array<Sint8> out;
       Array<Sint8> tmp;
  
     XmlParser parser(tmp);      appendMessageElementBegin(out, messageId);
     XmlEntry entry;      appendSimpleRspElementBegin(out);
     Stack<const char*> stack;      appendIMethodResponseElementBegin(out, iMethodName);
       appendIReturnValueElementBegin(out);
       out << body;
       appendIReturnValueElementEnd(out);
       appendIMethodResponseElementEnd(out);
       appendSimpleRspElementEnd(out);
       appendMessageElementEnd(out);
  
     while (parser.next(entry))      appendMethodResponseHeader(tmp, out.size());
     {      tmp << out;
         switch (entry.type)  
         {  
             case XmlEntry::XML_DECLARATION:  
             {  
                 _indent(os, stack.size(), indentChars);  
  
                 os << "<?" << entry.text << " ";      return tmp;
                 _printAttributes(os, entry.attributes, entry.attributeCount);  
                 os << "?>";  
                 break;  
             }             }
  
             case XmlEntry::START_TAG:  //******************************************************************************
             {  //
                 _indent(os, stack.size(), indentChars);  // Export Messages (used for indications)
   //
   //******************************************************************************
  
                 os << "<" << entry.text;  //------------------------------------------------------------------------------
   //
   // appendEMethodRequestHeader()
   //
   //     Build HTTP request header for export operation.
   //
   //------------------------------------------------------------------------------
  
                 if (entry.attributeCount)  void XmlWriter::appendEMethodRequestHeader(
                     os << ' ';      Array<Sint8>& out,
       const char* host,
       const char* cimMethod,
       const String& authenticationHeader,
       Uint32 contentLength)
   {
       char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
                 _printAttributes(os, entry.attributes, entry.attributeCount);      out << "M-POST /cimom HTTP/1.1\r\n";
                 os << ">";      out << "HOST: " << host << "\r\n";
                 stack.push(entry.text);      out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
                 break;      out << "Content-Length: " << contentLength << "\r\n";
       out << "Man: http://www.hp.com; ns=";
       out << nn <<"\r\n";
       out << nn << "-CIMExport: MethodRequest\r\n";  // ATTN-RK-P2-20020228: Should this be "MethodCall"?
       out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
       if (authenticationHeader.size())
       {
           out << authenticationHeader << "\r\n";
       }
       out << "\r\n";
             }             }
  
             case XmlEntry::EMPTY_TAG:  //------------------------------------------------------------------------------
   //
   // appendEMethodResponseHeader()
   //
   //     Build HTTP response header for export operation.
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendEMethodResponseHeader(
       Array<Sint8>& out,
       Uint32 contentLength)
             {             {
                 _indent(os, stack.size(), indentChars);      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
                 os << "<" << entry.text << " ";      out << "HTTP/1.1 200 OK\r\n";
                 _printAttributes(os, entry.attributes, entry.attributeCount);      out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
                 os << "/>";      out << "Content-Length: " << contentLength << "\r\n";
                 break;      out << "Ext:\r\n";
             }      out << "Cache-Control: no-cache\r\n";
       out << "Man:  http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
             case XmlEntry::END_TAG:      out << nn <<"\r\n";
             {      out << nn << "-CIMExport: MethodResponse\r\n\r\n";
                 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()  // appendSimpleExportReqElementBegin()
   // appendSimpleExportReqElementEnd()
   //
   //     <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 String XmlWriter::getNextMessageId()  void XmlWriter::appendSimpleExportReqElementBegin(
       Array<Sint8>& out)
 { {
     // ATTN: make thread-safe:      out << "<SIMPLEEXPREQ>\n";
     static Uint32 messageId = 1000;  }
   
     messageId++;  
   
     if (messageId < 1000)  
         messageId = 1001;  
  
     char buffer[16];  void XmlWriter::appendSimpleExportReqElementEnd(
     sprintf(buffer, "%d", messageId);      Array<Sint8>& out)
     return buffer;  {
       out << "</SIMPLEEXPREQ>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleIMethodReqMessage()  // appendEMethodCallElementBegin()
   // appendEMethodCallElementEnd()
   //
   //     <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>
   //     <!ATTLIST EXPMETHODCALL %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(  void XmlWriter::appendEMethodCallElementBegin(
     const char* host,      Array<Sint8>& out,
     const String& nameSpace,      const char* name)
     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::formatIMethodCallElement(  
                     iMethodName,  
                     nameSpace,  
                     body))));  
 }  
   
 Array<Sint8> XmlWriter::formatSimpleRspMessage(  
     const char* iMethodName,  
     const String& messageId,  
     const Array<Sint8>& body)  
 {  
     return XmlWriter::formatMethodResponseHeader(  
         XmlWriter::formatMessageElement(  
             messageId,  
             XmlWriter::formatSimpleRspElement(  
                 XmlWriter::formatIMethodResponseElement(  
                     iMethodName,  
                     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);      out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x)  void XmlWriter::appendEMethodCallElementEnd(
       Array<Sint8>& out)
 { {
     XmlWriter::append(out, x);      out << "</EXPMETHODCALL>\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)  //------------------------------------------------------------------------------
 {  //
     XmlWriter::append(out, x);  // appendSimpleExportRspElementBegin()
     return out;  // appendSimpleExportRspElementEnd()
 }  //
   //     <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
   //
   //------------------------------------------------------------------------------
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)  void XmlWriter::appendSimpleExportRspElementBegin(
       Array<Sint8>& out)
 { {
     XmlWriter::append(out, x);      out << "<SIMPLEEXPRSP>\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)  void XmlWriter::appendSimpleExportRspElementEnd(
       Array<Sint8>& out)
 { {
     out.appendArray(x);      out << "</SIMPLEEXPRSP>\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)  //------------------------------------------------------------------------------
 {  //
     XmlWriter::append(out, x);  // formatEMethodResponseElement()
     return out;  //
 }  //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendObjectNameParameter(  void XmlWriter::appendEMethodResponseElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      const char* name)
     const CIMReference& objectName)  
 { {
     if (objectName.isClassName())      out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
     {  
         XmlWriter::appendClassNameParameter(  
             out, name, objectName.getClassName());  
     }  
     else  
     {  
         XmlWriter::appendInstanceNameParameter(  
             out, name, objectName);  
     }  
   
     return out;  
 } }
  
 Array<Sint8> XmlWriter::formatEMethodCallElement(  void XmlWriter::appendEMethodResponseElementEnd(
     const char* name,      Array<Sint8>& out)
     const Array<Sint8>& iParamValues)  
 { {
     Array<Sint8> out;      out << "</EXPMETHODRESPONSE>\n";
     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";  
     out << iParamValues;  
     out << "</EXPMETHODCALL>\n";  
     return out;  
 } }
  
 Array<Sint8> XmlWriter::formatSimpleIndicationReqMessage(  //------------------------------------------------------------------------------
   //
   // XmlWriter::formatSimpleEMethodReqMessage()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(
     const char* host,     const char* host,
     const char* iMethodName,      const char* eMethodName,
     const String& messageId,     const String& messageId,
     const String& authenticationHeader,     const String& authenticationHeader,
     const Array<Sint8>& body)     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;     Array<Sint8> out;
     out.reserve(1024);      Array<Sint8> tmp;
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };  
  
     out << "M-POST /cimom HTTP/1.1\r\n";      appendMessageElementBegin(out, messageId);
     out << "HOST: " << host << "\r\n";      appendSimpleExportReqElementBegin(out);
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";      appendEMethodCallElementBegin(out, eMethodName);
     out << "Content-Length: " << content.size() << "\r\n";      out << body;
     out << "Man: http://www.hp.com; ns=";      appendEMethodCallElementEnd(out);
     out << nn <<"\r\n";      appendSimpleExportReqElementEnd(out);
     out << nn << "-CIMExport: " << cimOperation << "\r\n";      appendMessageElementEnd(out);
     out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";  
     if (authenticationHeader.size())  
     {  
         out << authenticationHeader << "\r\n";  
     }  
     out << "\r\n";  
     out << content;  
     return out;  
 }  
  
 Array<Sint8> XmlWriter::formatSimpleExportReqElement(      appendEMethodRequestHeader(
     const Array<Sint8>& body)          tmp,
 {          host,
     Array<Sint8> out;          eMethodName,
     return out << "<SIMPLEEXPREQ>\n" << body << "</SIMPLEEXPREQ>\n";          authenticationHeader,
 }          out.size());
       tmp << out;
  
 Array<Sint8> XmlWriter::formatSimpleIndicationRspMessage(      return out;
     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()  // XmlWriter::formatSimpleEMethodRspMessage()
 //  
 //     <!ELEMENT SIMPLEEXPRSP (METHODRESPONSE|EXPMETHODRESPONSE)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleExportRspElement(  Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(
       const char* eMethodName,
       const String& messageId,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     return out << "<SIMPLEEXPRSP>\n" << body << "</SIMPLEEXPRSP>\n";      Array<Sint8> tmp;
   
       appendMessageElementBegin(out, messageId);
       appendSimpleExportRspElementBegin(out);
       appendEMethodResponseElementBegin(out, eMethodName);
       out << body;
       appendEMethodResponseElementEnd(out);
       appendSimpleExportRspElementEnd(out);
       appendMessageElementEnd(out);
   
       appendEMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodResponseElement()  // _printAttributes()
 //  
 //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>  
 //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatEMethodResponseElement(  static void _printAttributes(
     const char* name,      PEGASUS_STD(ostream)& os,
     const Array<Sint8>& body)      const XmlAttribute* attributes,
       Uint32 attributeCount)
 { {
     Array<Sint8> out;      for (Uint32 i = 0; i < attributeCount; i++)
     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";      {
     out << body;          os << attributes[i].name << "=";
     out << "</EXPMETHODRESPONSE>\n";  
     return out;          os << '"';
           _appendSpecial(os, attributes[i].value);
           os << '"';
   
           if (i + 1 != attributeCount)
               os << ' ';
       }
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMethodResponseHeader()  // _indent()
 //  
 //     Build HTTP response header.  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatEMethodResponseHeader(  static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
     const Array<Sint8>& content)  
 { {
     Array<Sint8> out;      Uint32 n = level * indentChars;
     out.reserve(1024);  
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };  
  
     out << "HTTP/1.1 200 OK\r\n";      for (Uint32 i = 0; i < n; i++)
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";          os << ' ';
     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()  // indentedPrint()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(  void XmlWriter::indentedPrint(
     const char* host,      PEGASUS_STD(ostream)& os,
     const String& nameSpace,      const char* text,
     const char* iMethodName,      Uint32 indentChars)
     const String& messageId,  
    const String& authenticationHeader,  
     const Array<Sint8>& body)  
 { {
     return XmlWriter::formatMPostHeader(      char* tmp = strcpy(new char[strlen(text) + 1], text);
         host,  
         "MethodCall",  
         iMethodName,  
         nameSpace,  
         authenticationHeader,  
         XmlWriter::formatMessageElement(  
             messageId,  
             XmlWriter::formatSimpleReqElement(  
                 XmlWriter::formatMethodCallElement(  
                     iMethodName,  
                     nameSpace,  
                     body))));  
 }  
  
 //------------------------------------------------------------------------------      XmlParser parser(tmp);
 //      XmlEntry entry;
 // formatMethodCallElement()      Stack<const char*> stack;
 //  
 //     <!ELEMENT METHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>  
 //     <!ATTLIST METHODCALL %CIMName;>  
 //  
 //------------------------------------------------------------------------------  
  
 Array<Sint8> XmlWriter::formatMethodCallElement(      while (parser.next(entry))
     const char* name,  
     const String& nameSpace,  
     const Array<Sint8>& iParamValues)  
 { {
     Array<Sint8> out;          switch (entry.type)
     out << "<METHODCALL NAME=\"" << name << "\">\n";          {
     out << iParamValues;              case XmlEntry::XML_DECLARATION:
     out << "</METHODCALL>\n";              {
     return out;                  _indent(os, stack.size(), indentChars);
   
                   os << "<?" << entry.text << " ";
                   _printAttributes(os, entry.attributes, entry.attributeCount);
                   os << "?>";
                   break;
 } }
  
 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(              case XmlEntry::START_TAG:
     const char* iMethodName,  
     const String& messageId,  
     const Array<Sint8>& body)  
 { {
     return XmlWriter::formatMethodResponseHeader(                  _indent(os, stack.size(), indentChars);
         XmlWriter::formatMessageElement(  
             messageId,                  os << "<" << entry.text;
             XmlWriter::formatSimpleRspElement(  
                 XmlWriter::formatMethodResponseElement(                  if (entry.attributeCount)
                     iMethodName,                      os << ' ';
                     body))));  
                   _printAttributes(os, entry.attributes, entry.attributeCount);
                   os << ">";
                   stack.push(entry.text);
                   break;
 } }
  
 //------------------------------------------------------------------------------              case XmlEntry::EMPTY_TAG:
 //              {
 // formatMethodResponseElement()                  _indent(os, stack.size(), indentChars);
 //  
 //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>  
 //     <!ATTLIST METHODRESPONSE %CIMName;>  
 //  
 //------------------------------------------------------------------------------  
  
 Array<Sint8> XmlWriter::formatMethodResponseElement(                  os << "<" << entry.text << " ";
     const char* name,                  _printAttributes(os, entry.attributes, entry.attributeCount);
     const Array<Sint8>& body)                  os << "/>";
                   break;
               }
   
               case XmlEntry::END_TAG:
 { {
     Array<Sint8> out;                  if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";                      stack.pop();
     out << body;  
     out << "</METHODRESPONSE>\n";                  _indent(os, stack.size(), indentChars);
     return out;  
                   os << "</" << entry.text << ">";
                   break;
 } }
  
 //------------------------------------------------------------------------------              case XmlEntry::COMMENT:
 //              {
 // appendReturnValueElement()  
 //  
 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>  
 // <!ATTLIST RETURNVALUE  
 //     %ParamType;>  
 //  
 //------------------------------------------------------------------------------  
  
 Array<Sint8>& XmlWriter::appendReturnValueElement(                  _indent(os, stack.size(), indentChars);
     Array<Sint8>& out,                  os << "<!--";
     const CIMValue& value)                  _appendSpecial(os, entry.text);
                   os << "-->";
                   break;
               }
   
               case XmlEntry::CONTENT:
 { {
     out << "<RETURNVALUE";                  _indent(os, stack.size(), indentChars);
                   _appendSpecial(os, entry.text);
                   break;
               }
  
     CIMType type = value.getType();              case XmlEntry::CDATA:
     if (type != CIMType::NONE)  
     {     {
         out << " PARAMTYPE=\"" << TypeToString(type) << "\"";                  _indent(os, stack.size(), indentChars);
                   os << "<![CDATA[...]]>";
                   break;
     }     }
  
     out << ">\n";              case XmlEntry::DOCTYPE:
     value.toXml(out);              {
     out << "</RETURNVALUE>\n";                  _indent(os, stack.size(), indentChars);
     return out;                  os << "<!DOCTYPE...>";
                   break;
               }
           }
   
           os << PEGASUS_STD(endl);
       }
   
       delete [] tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatUnauthorizedResponseHeader()  // XmlWriter::getNextMessageId()
 //  
 //     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(  String XmlWriter::getNextMessageId()
     const String& content)  
 { {
     Array<Sint8> out;      // ATTN: make thread-safe:
     out.reserve(1024);      static Uint32 messageId = 1000;
  
     out << "HTTP/1.1 401 Unauthorized\r\n";      messageId++;
     out << content << "\r\n";  
     out << "\r\n";  
  
 //ATTN: We may need to include the following line, so that the browsers      if (messageId < 1000)
 //      can display the error message.          messageId = 1001;
 //    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;      char buffer[16];
       sprintf(buffer, "%d", messageId);
       return buffer;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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