(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.80 and 1.124.2.1

version 1.80, 2002/09/13 21:40:42 version 1.124.2.1, 2005/09/30 16:28:15
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 28 
Line 34 
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                  (carolann_graves@hp.com) //                  (carolann_graves@hp.com)
   //              Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
   //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
   //                               Willis White (whiwill@us.ibm.com) PEP 127 and 128
   //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
   //              Dave Sudlik, IBM (dsudlik@us.ibm.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
   //              Vijay Eli, vijayeli@in.ibm.com, fix for #2571
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 35 
Line 49 
 #include <cstdlib> #include <cstdlib>
 #include <cstdio> #include <cstdio>
 #include "Constants.h" #include "Constants.h"
 #include "Destroyer.h"  
 #include "CIMClass.h" #include "CIMClass.h"
 #include "CIMClassRep.h" #include "CIMClassRep.h"
 #include "CIMInstance.h" #include "CIMInstance.h"
Line 57 
Line 70 
 #include "XmlParser.h" #include "XmlParser.h"
 #include "Tracer.h" #include "Tracer.h"
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
   #include "CommonUTF.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)  // This is a shortcut macro for outputing content length. This
   // pads the output number to the max characters representing a Uint32 number
   // so that it can be overwritten easily with a transfer encoding line later
   // on in HTTPConnection if required. This is strictly for performance since
   // messages can be very large. This overwriting shortcut allows us to NOT have
   // to repackage a large message later.
   
   #define OUTPUT_CONTENTLENGTH                                   \
   {                                                              \
       char contentLengthP[11];                                   \
       sprintf(contentLengthP,"%.10u", contentLength);            \
       out << "content-length: " << contentLengthP << "\r\n";     \
   }
   
   Buffer& operator<<(Buffer& out, const char* x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, char x)  Buffer& operator<<(Buffer& out, char x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Char16& x)  Buffer& operator<<(Buffer& out, const Char16& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)  Buffer& operator<<(Buffer& out, const String& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)  Buffer& operator<<(Buffer& out, const Indentor& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)  Buffer& operator<<(Buffer& out, const Buffer& x)
 { {
     out.appendArray(x);      out.append(x.getData(), x.size());
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)  Buffer& operator<<(Buffer& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const CIMName& name)  Buffer& operator<<(Buffer& out, const CIMName& name)
 { {
     XmlWriter::append(out, name.getString ());     XmlWriter::append(out, name.getString ());
     return out;     return out;
 } }
  
   
   // l10n
   Buffer& operator<<(Buffer& out, const AcceptLanguages& al)
   {
       XmlWriter::append(out, al.toString ());
       return out;
   }
   
   // l10n
   Buffer& operator<<(Buffer& out, const ContentLanguages& cl)
   {
       XmlWriter::append(out, cl.toString ());
       return out;
   }
   
   
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x) PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x)
 { {
     return os << x.toString();     return os << x.toString();
Line 126 
Line 170 
     return os;     return os;
 } }
  
 inline void _appendChar(Array<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendChar(Buffer& out, const Char16& c)
   {
       // We need to convert the Char16 to UTF8 then append the UTF8
       // character into the array.
       // NOTE: The UTF8 character could be several bytes long.
       // WARNING: This function will put in replacement character for
       // all characters that have surogate pairs.
       char str[6];
       memset(str,0x00,sizeof(str));
       Uint8* charIN = (Uint8 *)&c;
   
       const Uint16 *strsrc = (Uint16 *)charIN;
       Uint16 *endsrc = (Uint16 *)&charIN[1];
   
       Uint8 *strtgt = (Uint8 *)str;
       Uint8 *endtgt = (Uint8 *)&str[5];
   
       UTF16toUTF8(&strsrc,
                   endsrc,
                   &strtgt,
                   endtgt);
   
       out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);
   }
   
   inline void _xmlWritter_appendSpecialChar(Buffer& out, const Char16& c)
   {
       if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
 { {
     out.append(Sint8(c));          char charref[7];
           sprintf(charref, "&#%u;", (Uint16)c);
           out.append(charref, static_cast<Uint32>(strlen(charref)));
 } }
       else
       {
           switch (c)
           {
               case '&':
                   out.append("&amp;", 5);
                   break;
   
               case '<':
                   out.append("&lt;", 4);
                   break;
   
               case '>':
                   out.append("&gt;", 4);
                   break;
   
               case '"':
                   out.append("&quot;", 6);
                   break;
   
               case '\'':
                   out.append("&apos;", 6);
                   break;
  
 inline void _appendSpecialChar(Array<Sint8>& out, const Char16& c)              default:
 { {
     // ATTN-B: Only UTF-8 handled for now.                      // We need to convert the Char16 to UTF8 then append the UTF8
                       // character into the array.
                       // NOTE: The UTF8 character could be several bytes long.
                       // WARNING: This function will put in replacement character for
                       // all characters that have surogate pairs.
               char str[6];
                       memset(str,0x00,sizeof(str));
                       const char* charIN = reinterpret_cast<const char *>(&c);
   
                       const Uint16 *strsrc = (const Uint16 *)charIN;
                       const Uint16 *endsrc = (const Uint16 *)&charIN[1];
   
                       Uint8 *strtgt = (Uint8 *)str;
                       Uint8 *endtgt = (Uint8 *)&str[5];
  
                       UTF16toUTF8(&strsrc,
                                   endsrc,
                                   &strtgt,
                                   endtgt);
   
                       Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
   
                       out.append(str,number1);
                   }
           }
       }
   }
   
   inline void _xmlWritter_appendSpecialChar(Buffer& out, char c)
   {
           if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
       {
           char charref[7];
           sprintf(charref, "&#%u;", (Uint8)c);
           out.append(charref, static_cast<Uint32>(strlen(charref)));
       }
       else
       {
     switch (c)     switch (c)
     {     {
         case '&':         case '&':
Line 158 
Line 290 
             break;             break;
  
         default:         default:
             out.append(Sint8(c));                  out.append(static_cast<Sint8>(c));
           }
     }     }
 } }
  
 static inline void _appendSpecialChar(PEGASUS_STD(ostream)& os, char c)  
   inline void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
   {
       if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
       {
           char charref[7];
           sprintf(charref, "&#%u;", static_cast<Uint8>(c));
           os << charref;
       }
       else
 { {
     switch (c)     switch (c)
     {     {
Line 190 
Line 332 
             os << c;             os << c;
     }     }
 } }
   }
   
   void _xmlWritter_appendSurrogatePair(Buffer& out, Uint16 high, Uint16 low)
   {
       char str[6];
       Uint8 charIN[5];
       memset(str,0x00,sizeof(str));
       memcpy(&charIN,&high,2);
       memcpy(&charIN[2],&low,2);
       const Uint16 *strsrc = (Uint16 *)charIN;
       Uint16 *endsrc = (Uint16 *)&charIN[3];
   
       Uint8 *strtgt = (Uint8 *)str;
       Uint8 *endtgt = (Uint8 *)&str[5];
   
       UTF16toUTF8(&strsrc,
                   endsrc,
                   &strtgt,
                   endtgt);
   
       Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
       out.append(str,number1);
   }
  
 static inline void _appendSpecial(PEGASUS_STD(ostream)& os, const char* str)  inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
 { {
     while (*str)     while (*str)
         _appendSpecialChar(os, *str++);          _xmlWritter_appendSpecialChar(os, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Char16& x)  void XmlWriter::append(Buffer& out, const Char16& x)
 { {
     _appendChar(out, x);      _xmlWritter_appendChar(out, x);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Boolean x)  void XmlWriter::append(Buffer& out, Boolean x)
 { {
     append(out, (x ? "TRUE" : "FALSE"));     append(out, (x ? "TRUE" : "FALSE"));
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint32 x)  void XmlWriter::append(Buffer& out, Uint32 x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%u", x);     sprintf(buffer, "%u", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Sint32 x)  void XmlWriter::append(Buffer& out, Sint32 x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%d", x);     sprintf(buffer, "%d", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint64 x)  void XmlWriter::append(Buffer& out, Uint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     // I know I shouldn't put platform flags here, but the other way is too hard      sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  
     sprintf(buffer, "%I64u", x);  
 #else  
     sprintf(buffer, "%llu", x);  
 #endif  
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Sint64 x)  void XmlWriter::append(Buffer& out, Sint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     // I know I shouldn't put platform flags here, but the other way is too hard      sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)      append(out, buffer);
     sprintf(buffer, "%I64d", x);  }
 #else  
     sprintf(buffer, "%lld", x);  void XmlWriter::append(Buffer& out, Real32 x)
 #endif  {
       char buffer[128];
       // %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format
       // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec
       // (4 byte IEEE floating point)
       sprintf(buffer, "%.7e", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Real64 x)  void XmlWriter::append(Buffer& out, Real64 x)
 { {
     char buffer[128];     char buffer[128];
     // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec      // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format
     sprintf(buffer, "%e", x);      // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec
       // (8 byte IEEE floating point)
       sprintf(buffer, "%.16e", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const char* str)  void XmlWriter::append(Buffer& out, const char* str)
 { {
     while (*str)     while (*str)
         _appendChar(out, *str++);        XmlWriter::append(out, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str)  void XmlWriter::append(Buffer& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
         _appendChar(out, str[i]);          Uint16 c = str[i];
           if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
              ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
           {
               Char16 highSurrogate = str[i];
               Char16 lowSurrogate = str[++i];
   
               _xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));
           }
           else
           {
               _xmlWritter_appendChar(out, str[i]);
           }
     }     }
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)  void XmlWriter::append(Buffer& out, const Indentor& x)
 { {
     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
         out.append(' ');         out.append(' ');
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const Char16& x)  void XmlWriter::appendSpecial(Buffer& out, const Char16& x)
 { {
     _appendSpecialChar(out, x);      _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)  void XmlWriter::appendSpecial(Buffer& out, char x)
 { {
     _appendSpecialChar(out, Char16(x));      _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)  void XmlWriter::appendSpecial(Buffer& out, const char* str)
 { {
     while (*str)     while (*str)
         _appendSpecialChar(out, *str++);          _xmlWritter_appendSpecialChar(out, *str++);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)  void XmlWriter::appendSpecial(Buffer& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
         _appendSpecialChar(out, str[i]);          Uint16 c = str[i];
   
           if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
              ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
           {
               Char16 highSurrogate = str[i];
               Char16 lowSurrogate = str[++i];
   
               _xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));
           }
           else
           {
               _xmlWritter_appendSpecialChar(out, str[i]);
           }
       }
   }
   
   // See http://www.ietf.org/rfc/rfc2396.txt section 2
   // Reserved characters = ';' '/' '?' ':' '@' '&' '=' '+' '$' ','
   // Excluded characters:
   //   Control characters = 0x00-0x1f, 0x7f
   //   Space character = 0x20
   //   Delimiters = '<' '>' '#' '%' '"'
   //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'
   //
   
   inline void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)
   {
       Uint8 c = (Uint8)char8;
   
   #ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING
       if ( (c <= 0x20) ||                     // Control characters + space char
            ( (c >= 0x22) && (c <= 0x26) ) ||  // '"' '#' '$' '%' '&'
            (c == 0x2b) ||                     // '+'
            (c == 0x2c) ||                     // ','
            (c == 0x2f) ||                     // '/'
            ( (c >= 0x3a) && (c <= 0x40) ) ||  // ':' ';' '<' '=' '>' '?' '@'
            ( (c >= 0x5b) && (c <= 0x5e) ) ||  // '[' '\\' ']' '^'
            (c == 0x60) ||                     // '`'
            ( (c >= 0x7b) && (c <= 0x7d) ) ||  // '{' '|' '}'
            (c >= 0x7f) )                      // Control character or non US-ASCII (UTF-8)
       {
           char hexencoding[4];
   
           sprintf(hexencoding, "%%%X%X", c/16, c%16);
           outString.append(hexencoding);
       }
       else
   #endif
       {
           outString.append((Uint16)c);
       }
   }
   
   String XmlWriter::encodeURICharacters(const Buffer& uriString)
   {
       String encodedString;
   
       for (Uint32 i=0; i<uriString.size(); i++)
       {
           _xmlWritter_encodeURIChar(encodedString, uriString[i]);
       }
   
       return encodedString;
   }
   
   String XmlWriter::encodeURICharacters(const String& uriString)
   {
       String encodedString;
   
   /* i18n remove - did not handle surrogate pairs
       for (Uint32 i=0; i<uriString.size(); i++)
       {
           _xmlWritter_encodeURIChar(encodedString, uriString[i]);
       }
   */
   
       // See the "CIM Operations over HTTP" spec, section 3.3.2 and
       // 3.3.3, for the treatment of non US-ASCII (UTF-8) chars
   
       // First, convert to UTF-8 (include handling of surrogate pairs)
       Buffer utf8;
       for (Uint32 i = 0; i < uriString.size(); i++)
       {
           Uint16 c = uriString[i];
   
           if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
              ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
           {
               Char16 highSurrogate = uriString[i];
               Char16 lowSurrogate = uriString[++i];
   
               _xmlWritter_appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));
           }
           else
           {
               _xmlWritter_appendChar(utf8, uriString[i]);
     }     }
 } }
  
       // Second, escape the non HTTP-safe chars
       for (Uint32 i=0; i<utf8.size(); i++)
       {
           _xmlWritter_encodeURIChar(encodedString, utf8[i]);
       }
   
       return encodedString;
   }
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendLocalNameSpacePathElement() // appendLocalNameSpacePathElement()
Line 306 
Line 590 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalNameSpacePathElement( void XmlWriter::appendLocalNameSpacePathElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
     out << "<LOCALNAMESPACEPATH>\n";     out << "<LOCALNAMESPACEPATH>\n";
  
     char* nameSpaceCopy = strdup(nameSpace.getString().getCString());     char* nameSpaceCopy = strdup(nameSpace.getString().getCString());
   
   #if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \
       defined(PEGASUS_OS_HPUX) || \
       defined(PEGASUS_OS_LINUX)
       char *last;
       for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;
            p = strtok_r(NULL, "/", &last))
   #else
     for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))     for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))
   #endif
     {     {
         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
     }     }
     delete nameSpaceCopy;      free(nameSpaceCopy);
  
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
Line 330 
Line 623 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNameSpacePathElement( void XmlWriter::appendNameSpacePathElement(
     Array<Sint8>& out,      Buffer& out,
     const String& host,     const String& host,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
Line 351 
Line 644 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameElement( void XmlWriter::appendClassNameElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& className)     const CIMName& className)
 { {
     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
Line 368 
Line 661 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameElement( void XmlWriter::appendInstanceNameElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
Line 407 
Line 700 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassPathElement( void XmlWriter::appendClassPathElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<CLASSPATH>\n";     out << "<CLASSPATH>\n";
Line 427 
Line 720 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstancePathElement( void XmlWriter::appendInstancePathElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<INSTANCEPATH>\n";     out << "<INSTANCEPATH>\n";
Line 447 
Line 740 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalClassPathElement( void XmlWriter::appendLocalClassPathElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<LOCALCLASSPATH>\n";     out << "<LOCALCLASSPATH>\n";
Line 465 
Line 758 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalInstancePathElement( void XmlWriter::appendLocalInstancePathElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<LOCALINSTANCEPATH>\n";     out << "<LOCALINSTANCEPATH>\n";
Line 484 
Line 777 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalObjectPathElement( void XmlWriter::appendLocalObjectPathElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObjectPath& objectPath)     const CIMObjectPath& objectPath)
 { {
     //     //
Line 509 
Line 802 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 inline void _appendValue(Array<Sint8>& out, Boolean x)  inline void _xmlWritter_appendValue(Buffer& out, Boolean x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Uint8 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint8 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _appendValue(Array<Sint8>& out, Sint8 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint8 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _appendValue(Array<Sint8>& out, Uint16 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint16 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _appendValue(Array<Sint8>& out, Sint16 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint16 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _appendValue(Array<Sint8>& out, Uint32 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Sint32 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Uint64 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Sint64 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Real32 x)  inline void _xmlWritter_appendValue(Buffer& out, Real32 x)
 { {
     XmlWriter::append(out, Real64(x));      XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Real64 x)  inline void _xmlWritter_appendValue(Buffer& out, Real64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, const Char16& x)  inline void _xmlWritter_appendValue(Buffer& out, const Char16& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, const String& x)  inline void _xmlWritter_appendValue(Buffer& out, const String& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, const CIMDateTime& x)  inline void _xmlWritter_appendValue(Buffer& out, const CIMDateTime& x)
 { {
     out << x.toString();  //ATTN: append() method?     out << x.toString();  //ATTN: append() method?
 } }
  
 inline void _appendValue(Array<Sint8>& out, const CIMObjectPath& x)  inline void _xmlWritter_appendValue(Buffer& out, const CIMObjectPath& x)
 { {
     XmlWriter::appendValueReferenceElement(out, x, true);     XmlWriter::appendValueReferenceElement(out, x, true);
 } }
  
 void _appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)  inline void _xmlWritter_appendValue(Buffer& out, const CIMObject& x)
   {
       String myStr = x.toString();
       _xmlWritter_appendValue(out, myStr);
   }
   
   void _xmlWritter_appendValueArray(Buffer& out, const CIMObjectPath* p, Uint32 size)
 { {
     out << "<VALUE.REFARRAY>\n";     out << "<VALUE.REFARRAY>\n";
     while (size--)     while (size--)
     {     {
         _appendValue(out, *p++);          _xmlWritter_appendValue(out, *p++);
     }     }
     out << "</VALUE.REFARRAY>\n";     out << "</VALUE.REFARRAY>\n";
 } }
  
 template<class T> template<class T>
 void _appendValueArray(Array<Sint8>& out, const T* p, Uint32 size)  void _xmlWritter_appendValueArray(Buffer& out, const T* p, Uint32 size)
 { {
     out << "<VALUE.ARRAY>\n";     out << "<VALUE.ARRAY>\n";
  
     while (size--)     while (size--)
     {     {
         out << "<VALUE>";         out << "<VALUE>";
         _appendValue(out, *p++);          _xmlWritter_appendValue(out, *p++);
         out << "</VALUE>\n";         out << "</VALUE>\n";
     }     }
  
Line 623 
Line 922 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueElement( void XmlWriter::appendValueElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     if (value.isNull())     if (value.isNull())
Line 638 
Line 937 
             {             {
                 Array<Boolean> a;                 Array<Boolean> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 646 
Line 945 
             {             {
                 Array<Uint8> a;                 Array<Uint8> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 654 
Line 953 
             {             {
                 Array<Sint8> a;                 Array<Sint8> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 662 
Line 961 
             {             {
                 Array<Uint16> a;                 Array<Uint16> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 670 
Line 969 
             {             {
                 Array<Sint16> a;                 Array<Sint16> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 678 
Line 977 
             {             {
                 Array<Uint32> a;                 Array<Uint32> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 686 
Line 985 
             {             {
                 Array<Sint32> a;                 Array<Sint32> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 694 
Line 993 
             {             {
                 Array<Uint64> a;                 Array<Uint64> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 702 
Line 1001 
             {             {
                 Array<Sint64> a;                 Array<Sint64> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 710 
Line 1009 
             {             {
                 Array<Real32> a;                 Array<Real32> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 718 
Line 1017 
             {             {
                 Array<Real64> a;                 Array<Real64> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 726 
Line 1025 
             {             {
                 Array<Char16> a;                 Array<Char16> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 734 
Line 1033 
             {             {
                 Array<String> a;                 Array<String> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 742 
Line 1041 
             {             {
                 Array<CIMDateTime> a;                 Array<CIMDateTime> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 750 
Line 1049 
             {             {
                 Array<CIMObjectPath> a;                 Array<CIMObjectPath> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_OBJECT:
               {
                   Array<CIMObject> a;
                   value.get(a);
                   _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 763 
Line 1070 
         // Has to be separate because it uses VALUE.REFERENCE tag         // Has to be separate because it uses VALUE.REFERENCE tag
         CIMObjectPath v;         CIMObjectPath v;
         value.get(v);         value.get(v);
         _appendValue(out, v);          _xmlWritter_appendValue(out, v);
     }     }
     else     else
     {     {
Line 775 
Line 1082 
             {             {
                 Boolean v;                 Boolean v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 783 
Line 1090 
             {             {
                 Uint8 v;                 Uint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 791 
Line 1098 
             {             {
                 Sint8 v;                 Sint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 799 
Line 1106 
             {             {
                 Uint16 v;                 Uint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 807 
Line 1114 
             {             {
                 Sint16 v;                 Sint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 815 
Line 1122 
             {             {
                 Uint32 v;                 Uint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 823 
Line 1130 
             {             {
                 Sint32 v;                 Sint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 831 
Line 1138 
             {             {
                 Uint64 v;                 Uint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 839 
Line 1146 
             {             {
                 Sint64 v;                 Sint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 847 
Line 1154 
             {             {
                 Real32 v;                 Real32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 855 
Line 1162 
             {             {
                 Real64 v;                 Real64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 863 
Line 1170 
             {             {
                 Char16 v;                 Char16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 871 
Line 1178 
             {             {
                 String v;                 String v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 879 
Line 1186 
             {             {
                 CIMDateTime v;                 CIMDateTime v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_OBJECT:
               {
                   CIMObject v;
                   value.get(v);
                   _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 895 
Line 1210 
     const CIMValue& value,     const CIMValue& value,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendValueElement(tmp, value);     appendValueElement(tmp, value);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 911 
Line 1226 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueObjectWithPathElement( void XmlWriter::appendValueObjectWithPathElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObject& objectWithPath)     const CIMObject& objectWithPath)
 { {
     out << "<VALUE.OBJECTWITHPATH>\n";     out << "<VALUE.OBJECTWITHPATH>\n";
Line 933 
Line 1248 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueReferenceElement( void XmlWriter::appendValueReferenceElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     Boolean putValueWrapper)     Boolean putValueWrapper)
 { {
Line 990 
Line 1305 
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendValueReferenceElement(tmp, reference, true);     appendValueReferenceElement(tmp, reference, true);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData());     indentedPrint(os, tmp.getData());
Line 1005 
Line 1320 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueNamedInstanceElement( void XmlWriter::appendValueNamedInstanceElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
     out << "<VALUE.NAMEDINSTANCE>\n";     out << "<VALUE.NAMEDINSTANCE>\n";
Line 1029 
Line 1344 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassElement( void XmlWriter::appendClassElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstClass& cimclass)     const CIMConstClass& cimclass)
 { {
     cimclass._checkRep();     cimclass._checkRep();
Line 1040 
Line 1355 
     const CIMConstClass& cimclass,     const CIMConstClass& cimclass,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendClassElement(tmp, cimclass);     appendClassElement(tmp, cimclass);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData(), 4);     indentedPrint(os, tmp.getData(), 4);
Line 1058 
Line 1373 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceElement( void XmlWriter::appendInstanceElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     instance._checkRep();     instance._checkRep();
Line 1069 
Line 1384 
     const CIMConstInstance& instance,     const CIMConstInstance& instance,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendInstanceElement(tmp, instance);     appendInstanceElement(tmp, instance);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1084 
Line 1399 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendObjectElement( void XmlWriter::appendObjectElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstObject& object)     const CIMConstObject& object)
 { {
     if (object.isClass())     if (object.isClass())
Line 1129 
Line 1444 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyElement( void XmlWriter::appendPropertyElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstProperty& property)     const CIMConstProperty& property)
 { {
     property._checkRep();     property._checkRep();
Line 1140 
Line 1455 
     const CIMConstProperty& property,     const CIMConstProperty& property,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendPropertyElement(tmp, property);     appendPropertyElement(tmp, property);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1161 
Line 1476 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodElement( void XmlWriter::appendMethodElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstMethod& method)     const CIMConstMethod& method)
 { {
     method._checkRep();     method._checkRep();
Line 1172 
Line 1487 
     const CIMConstMethod& method,     const CIMConstMethod& method,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendMethodElement(tmp, method);     appendMethodElement(tmp, method);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1207 
Line 1522 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParameterElement( void XmlWriter::appendParameterElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstParameter& parameter)     const CIMConstParameter& parameter)
 { {
     parameter._checkRep();     parameter._checkRep();
Line 1218 
Line 1533 
     const CIMConstParameter& parameter,     const CIMConstParameter& parameter,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendParameterElement(tmp, parameter);     appendParameterElement(tmp, parameter);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1235 
Line 1550 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParamValueElement( void XmlWriter::appendParamValueElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMParamValue& paramValue)     const CIMParamValue& paramValue)
 { {
     paramValue._checkRep();     paramValue._checkRep();
Line 1246 
Line 1561 
     const CIMParamValue& paramValue,     const CIMParamValue& paramValue,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendParamValueElement(tmp, paramValue);     appendParamValueElement(tmp, paramValue);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1266 
Line 1581 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierElement( void XmlWriter::appendQualifierElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstQualifier& qualifier)     const CIMConstQualifier& qualifier)
 { {
     qualifier._checkRep();     qualifier._checkRep();
Line 1277 
Line 1592 
     const CIMConstQualifier& qualifier,     const CIMConstQualifier& qualifier,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendQualifierElement(tmp, qualifier);     appendQualifierElement(tmp, qualifier);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1298 
Line 1613 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclElement( void XmlWriter::appendQualifierDeclElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     qualifierDecl._checkRep();     qualifierDecl._checkRep();
Line 1309 
Line 1624 
     const CIMConstQualifierDecl& qualifierDecl,     const CIMConstQualifierDecl& qualifierDecl,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Buffer tmp;
     appendQualifierDeclElement(tmp, qualifierDecl);     appendQualifierDeclElement(tmp, qualifierDecl);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1327 
Line 1642 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierFlavorEntity( void XmlWriter::appendQualifierFlavorEntity(
     Array<Sint8>& out,      Buffer& out,
     const CIMFlavor & flavor)     const CIMFlavor & flavor)
 { {
     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))
Line 1360 
Line 1675 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendScopeElement( void XmlWriter::appendScopeElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMScope & scope)     const CIMScope & scope)
 { {
     if (!(scope.equal (CIMScope ())))     if (!(scope.equal (CIMScope ())))
Line 1392 
Line 1707 
     }     }
 } }
  
   // l10n - added content language and accept language support to
   // the header methods below
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendMethodCallHeader() // appendMethodCallHeader()
Line 1401 
Line 1719 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodCallHeader( void XmlWriter::appendMethodCallHeader(
     Array<Sint8>& out,      Buffer& out,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
     const String& cimObject,     const String& cimObject,
     const String& authenticationHeader,     const String& authenticationHeader,
       HttpMethod httpMethod,
       const AcceptLanguages & acceptLanguages,
       const ContentLanguages & contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
       // ATTN: KS 20020926 - Temporary change to issue only POST. This may
       // be changed in the DMTF CIM Operations standard in the future.
       // If we kept M-Post we would have to retry with Post. Does not
       // do that in client today. Permanent change is to retry until spec
       // updated. This change is temp to finish tests or until the retry
       // installed.  Required because of change to wbemservices cimom
       if (httpMethod == HTTP_METHOD_M_POST)
       {
     out << "M-POST /cimom HTTP/1.1\r\n";     out << "M-POST /cimom HTTP/1.1\r\n";
       }
       else
       {
           out << "POST /cimom HTTP/1.1\r\n";
       }
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";                  OUTPUT_CONTENTLENGTH;
       if (acceptLanguages.size() > 0)
       {
           out << "Accept-Language: " << acceptLanguages << "\r\n";
       }
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\r\n";
       }
   
   #ifdef PEGASUS_DEBUG
                   // backdoor environment variable to turn OFF client requesting transfer
                   // encoding. The default is on. to turn off, set this variable to zero.
                   // This should be removed when stable. This should only be turned off in
                   // a debugging/testing environment.
   
                   static const char *clientTransferEncodingOff =
                           getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
                   if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
   #endif
   
                           out << "TE: chunked, trailers" << "\r\n";
   
       if (httpMethod == HTTP_METHOD_M_POST)
       {
     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: MethodCall\r\n";     out << nn << "-CIMOperation: MethodCall\r\n";
     out << nn << "-CIMMethod: " << cimMethod << "\r\n";          out << nn << "-CIMMethod: "
     out << nn << "-CIMObject: " << cimObject << "\r\n";              << encodeURICharacters(cimMethod.getString()) << "\r\n";
           out << nn << "-CIMObject: " << encodeURICharacters(cimObject) << "\r\n";
       }
       else
       {
           out << "CIMOperation: MethodCall\r\n";
           out << "CIMMethod: " << encodeURICharacters(cimMethod.getString())
               << "\r\n";
           out << "CIMObject: " << encodeURICharacters(cimObject) << "\r\n";
       }
   
     if (authenticationHeader.size())     if (authenticationHeader.size())
     {     {
         out << authenticationHeader << "\r\n";         out << authenticationHeader << "\r\n";
     }     }
   
     out << "\r\n";     out << "\r\n";
 } }
  
 //------------------------------------------------------------------------------  
 //  
 // appendMethodResponseHeader()  
 //  
 //     Build HTTP response header.  
 //  
 //------------------------------------------------------------------------------  
  
 void XmlWriter::appendMethodResponseHeader( void XmlWriter::appendMethodResponseHeader(
     Array<Sint8>& out,       Buffer& out,
     Uint32 contentLength)       HttpMethod httpMethod,
        const ContentLanguages & contentLanguages,
        Uint32 contentLength,
        Uint32 serverResponseTime)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
     STAT_SERVERTIME     STAT_SERVERTIME
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";       OUTPUT_CONTENTLENGTH;
   
        if (contentLanguages.size() > 0)
        {
            out << "Content-Language: " << contentLanguages << "\r\n";
        }
        if (httpMethod == HTTP_METHOD_M_POST)
        {
     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";
 } }
        else
        {
            out << "CIMOperation: MethodResponse\r\n\r\n";
        }
   }
   
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
Line 1466 
Line 1843 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendHttpErrorResponseHeader( void XmlWriter::appendHttpErrorResponseHeader(
     Array<Sint8>& out,      Buffer& out,
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
Line 1481 
Line 1858 
         // ATTN-RK-P3-20020404: It is critical that this text not contain '\n'         // ATTN-RK-P3-20020404: It is critical that this text not contain '\n'
         // ATTN-RK-P3-20020404: Need to encode this value properly.  (See         // ATTN-RK-P3-20020404: Need to encode this value properly.  (See
         // CIM/HTTP Specification section 3.3.2         // CIM/HTTP Specification section 3.3.2
         out << PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": " << errorDetail << "\r\n";          out << PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": "
               << encodeURICharacters(errorDetail) << "\r\n";
     }     }
     out << "\r\n";     out << "\r\n";
 } }
Line 1506 
Line 1884 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendUnauthorizedResponseHeader( void XmlWriter::appendUnauthorizedResponseHeader(
     Array<Sint8>& out,      Buffer& out,
     const String& content)     const String& content)
 { {
     out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";
Line 1523 
Line 1901 
 //    out << "</BODY></HTML>\r\n"; //    out << "</BODY></HTML>\r\n";
 } }
  
   #ifdef PEGASUS_KERBEROS_AUTHENTICATION
   //------------------------------------------------------------------------------
   //
   // appendOKResponseHeader()
   //
   //     Build HTTP authentication response header for unauthorized requests.
   //
   //     Returns OK message in the following format:
   //
   //        HTTP/1.1 200 OK
   //        Content-Length: 0
   //        WWW-Authenticate: Negotiate "token"
   //        <HTML><HEAD>
   //        <TITLE>200 OK</TITLE>
   //        </HEAD><BODY BGCOLOR="#99cc99">
   //        <H2>TEST200 OK</H2>
   //        <HR>
   //        </BODY></HTML>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendOKResponseHeader(
       Buffer& out,
       const String& content)
   {
       out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
       // Content-Length header needs to be added because 200 OK record
       // is usually intended to have content.  But, for Kerberos this
       // may not always be the case so we need to indicate that there
       // is no content
                   Uint32 contentLength = 0;
                   OUTPUT_CONTENTLENGTH;
       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>" << "200 OK" <<  "</TITLE>\r\n";
   //    out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
   //    out << "<H2>TEST" << "200 OK" << "</H2>\r\n";
   //    out << "<HR>\r\n";
   //    out << "</BODY></HTML>\r\n";
   }
   #endif
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _appendMessageElementBegin() // _appendMessageElementBegin()
Line 1536 
Line 1960 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMessageElementBegin( void XmlWriter::_appendMessageElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const String& messageId)     const String& messageId)
 { {
     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
Line 1545 
Line 1969 
 } }
  
 void XmlWriter::_appendMessageElementEnd( void XmlWriter::_appendMessageElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</MESSAGE>\n";     out << "</MESSAGE>\n";
     out << "</CIM>\n";     out << "</CIM>\n";
Line 1561 
Line 1985 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleReqElementBegin( void XmlWriter::_appendSimpleReqElementBegin(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "<SIMPLEREQ>\n";     out << "<SIMPLEREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleReqElementEnd( void XmlWriter::_appendSimpleReqElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</SIMPLEREQ>\n";     out << "</SIMPLEREQ>\n";
 } }
Line 1583 
Line 2007 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodCallElementBegin( void XmlWriter::_appendMethodCallElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODCALL NAME=\"" << name << "\">\n";     out << "<METHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodCallElementEnd( void XmlWriter::_appendMethodCallElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</METHODCALL>\n";     out << "</METHODCALL>\n";
 } }
Line 1606 
Line 2030 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodCallElementBegin( void XmlWriter::_appendIMethodCallElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";     out << "<IMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodCallElementEnd( void XmlWriter::_appendIMethodCallElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</IMETHODCALL>\n";     out << "</IMETHODCALL>\n";
 } }
Line 1631 
Line 2055 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIParamValueElementBegin( void XmlWriter::_appendIParamValueElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const char* name)     const char* name)
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIParamValueElementEnd( void XmlWriter::_appendIParamValueElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</IPARAMVALUE>\n";     out << "</IPARAMVALUE>\n";
 } }
Line 1653 
Line 2077 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleRspElementBegin( void XmlWriter::_appendSimpleRspElementBegin(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "<SIMPLERSP>\n";     out << "<SIMPLERSP>\n";
 } }
  
 void XmlWriter::_appendSimpleRspElementEnd( void XmlWriter::_appendSimpleRspElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</SIMPLERSP>\n";     out << "</SIMPLERSP>\n";
 } }
Line 1675 
Line 2099 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodResponseElementBegin( void XmlWriter::_appendMethodResponseElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodResponseElementEnd( void XmlWriter::_appendMethodResponseElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</METHODRESPONSE>\n";     out << "</METHODRESPONSE>\n";
 } }
Line 1698 
Line 2122 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodResponseElementBegin( void XmlWriter::_appendIMethodResponseElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodResponseElementEnd( void XmlWriter::_appendIMethodResponseElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</IMETHODRESPONSE>\n";     out << "</IMETHODRESPONSE>\n";
 } }
Line 1717 
Line 2141 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendErrorElement( void XmlWriter::_appendErrorElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);
Line 1740 
Line 2164 
 // //
 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)> // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
 // <!ATTLIST RETURNVALUE // <!ATTLIST RETURNVALUE
   //     %EmbeddedObject; #IMPLIED
 //     %ParamType;> //     %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendReturnValueElement( void XmlWriter::appendReturnValueElement(
     Array<Sint8>& out,      Buffer& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     out << "<RETURNVALUE";     out << "<RETURNVALUE";
  
     CIMType type = value.getType();     CIMType type = value.getType();
       // If the property type is CIMObject, then
       //   encode the property in CIM-XML as a string with the EMBEDDEDOBJECT attribute
       //   (there is not currently a CIM-XML "object" datatype)
       // else
       //   output the real type
       if (type == CIMTYPE_OBJECT)
       {
           out << " PARAMTYPE=\"string\"";
           out << " EMBEDDEDOBJECT=\"object\"";
       }
       else
       {
     out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";     out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";
       }
  
     out << ">\n";     out << ">\n";
  
Line 1773 
Line 2211 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIReturnValueElementBegin( void XmlWriter::_appendIReturnValueElementBegin(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "<IRETURNVALUE>\n";     out << "<IRETURNVALUE>\n";
 } }
  
 void XmlWriter::_appendIReturnValueElementEnd( void XmlWriter::_appendIReturnValueElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</IRETURNVALUE>\n";     out << "</IRETURNVALUE>\n";
 } }
Line 1791 
Line 2229 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendBooleanIParameter( void XmlWriter::appendBooleanIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     Boolean flag)     Boolean flag)
 { {
Line 1809 
Line 2247 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendStringIParameter( void XmlWriter::appendStringIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const String& str)     const String& str)
 { {
Line 1827 
Line 2265 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierNameIParameter( void XmlWriter::appendQualifierNameIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const String& qualifierName)     const String& qualifierName)
 { {
Line 1851 
Line 2289 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameIParameter( void XmlWriter::appendClassNameIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMName& className)     const CIMName& className)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
   
       //
       //  A NULL (unassigned) value for a parameter is specified by an
       //  <IPARAMVALUE> element with no subelement
       //
       if (!className.isNull ())
       {
     appendClassNameElement(out, className);     appendClassNameElement(out, className);
       }
   
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 1867 
Line 2314 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameIParameter( void XmlWriter::appendInstanceNameIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
Line 1877 
Line 2324 
 } }
  
 void XmlWriter::appendObjectNameIParameter( void XmlWriter::appendObjectNameIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMObjectPath& objectName)     const CIMObjectPath& objectName)
 { {
Line 1906 
Line 2353 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassIParameter( void XmlWriter::appendClassIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMConstClass& cimClass)     const CIMConstClass& cimClass)
 { {
Line 1922 
Line 2369 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceIParameter( void XmlWriter::appendInstanceIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
Line 1938 
Line 2385 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNamedInstanceIParameter( void XmlWriter::appendNamedInstanceIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
Line 1957 
Line 2404 
 //     USE: Create parameter for getProperty operation //     USE: Create parameter for getProperty operation
 //========================================================== //==========================================================
 void XmlWriter::appendPropertyNameIParameter( void XmlWriter::appendPropertyNameIParameter(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& propertyName)     const CIMName& propertyName)
 { {
     _appendIParamValueElementBegin(out, "PropertyName");     _appendIParamValueElementBegin(out, "PropertyName");
Line 1972 
Line 2419 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyValueIParameter( void XmlWriter::appendPropertyValueIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMValue& value)     const CIMValue& value)
 { {
Line 1988 
Line 2435 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyListIParameter( void XmlWriter::appendPropertyListIParameter(
     Array<Sint8>& out,      Buffer& out,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
     // ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list  
     _appendIParamValueElementBegin(out, "PropertyList");     _appendIParamValueElementBegin(out, "PropertyList");
  
       //
       //  A NULL (unassigned) value for a parameter is specified by an
       //  <IPARAMVALUE> element with no subelement
       //
       if (!propertyList.isNull ())
       {
     out << "<VALUE.ARRAY>\n";     out << "<VALUE.ARRAY>\n";
     for (Uint32 i = 0; i < propertyList.size(); i++)     for (Uint32 i = 0; i < propertyList.size(); i++)
     {     {
         out << "<VALUE>" << propertyList[i] << "</VALUE>\n";         out << "<VALUE>" << propertyList[i] << "</VALUE>\n";
     }     }
     out << "</VALUE.ARRAY>\n";     out << "</VALUE.ARRAY>\n";
       }
  
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
Line 2011 
Line 2464 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclarationIParameter( void XmlWriter::appendQualifierDeclarationIParameter(
     Array<Sint8>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
Line 2026 
Line 2479 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatHttpErrorRspMessage(  Buffer XmlWriter::formatHttpErrorRspMessage(
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
 { {
     Array<Sint8> out;      Buffer out;
  
     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
  
     return out;     return out;
 } }
  
   // l10n - add content language support to the format methods below
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleMethodReqMessage() // XmlWriter::formatSimpleMethodReqMessage()
Line 2045 
Line 2500 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(  Buffer XmlWriter::formatSimpleMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMObjectPath& path,     const CIMObjectPath& path,
     const CIMName& methodName,     const CIMName& methodName,
     const Array<CIMParamValue>& parameters,     const Array<CIMParamValue>& parameters,
     const String& messageId,     const String& messageId,
     const String& authenticationHeader)      HttpMethod httpMethod,
       const String& authenticationHeader,
       const AcceptLanguages& httpAcceptLanguages,
       const ContentLanguages& httpContentLanguages)
 { {
     Array<Sint8> out;      Buffer out;
     Array<Sint8> tmp;      Buffer tmp;
     CIMObjectPath localObjectPath = path;     CIMObjectPath localObjectPath = path;
     localObjectPath.setNameSpace(nameSpace.getString());     localObjectPath.setNameSpace(nameSpace.getString());
     localObjectPath.setHost(String::EMPTY);     localObjectPath.setHost(String::EMPTY);
Line 2078 
Line 2536 
         methodName,         methodName,
         localObjectPath.toString(),         localObjectPath.toString(),
         authenticationHeader,         authenticationHeader,
           httpMethod,
           httpAcceptLanguages,
           httpContentLanguages,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
 } }
  
 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(  //PEP 128 adding serverRsponseTime to header
   Buffer XmlWriter::formatSimpleMethodRspMessage(
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
     const Array<Sint8>& body)      HttpMethod httpMethod,
 {      const ContentLanguages & httpContentLanguages,
     Array<Sint8> out;      const Buffer& body,
     Array<Sint8> tmp;                  Uint32 serverResponseTime,
                   Boolean isFirst,
                   Boolean isLast)
   {
           Buffer out;
   
           if (isFirst == true)
           {
                   // NOTE: temporarily put zero for content length. the http code
                   // will later decide to fill in the length or remove it altogether
                   appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
                                                                                                                            serverResponseTime);
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
     _appendMethodResponseElementBegin(out, methodName);     _appendMethodResponseElementBegin(out, methodName);
           }
   
           if (body.size() != 0)
           {
     out << body;     out << body;
           }
   
           if (isLast == true)
           {
     _appendMethodResponseElementEnd(out);     _appendMethodResponseElementEnd(out);
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
           }
  
     appendMethodResponseHeader(tmp, out.size());          return out;
     tmp << out;  
   
     return tmp;  
 } }
  
   
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleMethodErrorRspMessage() // XmlWriter::formatSimpleMethodErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(  Buffer XmlWriter::formatSimpleMethodErrorRspMessage(
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
       HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<Sint8> out;      Buffer out;
     Array<Sint8> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2128 
Line 2609 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, out.size());  // l10n
       appendMethodResponseHeader(tmp,
           httpMethod,
           cimException.getContentLanguages(),
           out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2140 
Line 2625 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(  Buffer XmlWriter::formatSimpleIMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
       HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
     const Array<Sint8>& body)      const AcceptLanguages& httpAcceptLanguages,
       const ContentLanguages& httpContentLanguages,
       const Buffer& body)
 { {
     Array<Sint8> out;      Buffer out;
     Array<Sint8> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleReqElementBegin(out);     _appendSimpleReqElementBegin(out);
Line 2166 
Line 2654 
         iMethodName,         iMethodName,
         nameSpace.getString(),         nameSpace.getString(),
         authenticationHeader,         authenticationHeader,
           httpMethod,
           httpAcceptLanguages,
           httpContentLanguages,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
Line 2178 
Line 2669 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(  Buffer XmlWriter::formatSimpleIMethodRspMessage(
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
     const Array<Sint8>& body)      HttpMethod httpMethod,
 {      const ContentLanguages & httpContentLanguages,
     Array<Sint8> out;      const Buffer& body,
     Array<Sint8> tmp;      Uint32 serverResponseTime,
       Boolean isFirst,
       Boolean isLast)
   {
       Buffer out;
   
                   if (isFirst == true)
                   {
                           // NOTE: temporarily put zero for content length. the http code
                           // will later decide to fill in the length or remove it altogether
                           appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
                                                                                                                                    serverResponseTime);
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
     _appendIMethodResponseElementBegin(out, iMethodName);     _appendIMethodResponseElementBegin(out, iMethodName);
   
                           // output the start of the return tag. Test if there is response data by:
                           // 1. there is data on the first chunk OR
                           // 2. there is no data on the first chunk but isLast is false implying
                           //    there is more non-empty data to come. If all subsequent chunks
                           //    are empty, then this generates and empty response.
                           if (body.size() != 0 || isLast == false)
                                   _appendIReturnValueElementBegin(out);
                   }
   
     if (body.size() != 0)     if (body.size() != 0)
     {     {
         _appendIReturnValueElementBegin(out);  
         out << body;         out << body;
         _appendIReturnValueElementEnd(out);  
     }     }
   
                   if (isLast == true)
                   {
                           if (body.size() != 0 || isFirst == false)
                                   _appendIReturnValueElementEnd(out);
     _appendIMethodResponseElementEnd(out);     _appendIMethodResponseElementEnd(out);
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
                   }
  
     appendMethodResponseHeader(tmp, out.size());      return out;
     tmp << out;  
   
     return tmp;  
 } }
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleIMethodErrorRspMessage() // XmlWriter::formatSimpleIMethodErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(  Buffer XmlWriter::formatSimpleIMethodErrorRspMessage(
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
       HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<Sint8> out;      Buffer out;
     Array<Sint8> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2227 
Line 2741 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, out.size());  // l10n
       appendMethodResponseHeader(tmp,
            httpMethod,
            cimException.getContentLanguages(),
            out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2248 
Line 2766 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodRequestHeader( void XmlWriter::appendEMethodRequestHeader(
     Array<Sint8>& out,      Buffer& out,
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
       HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
       const AcceptLanguages& acceptLanguages,
       const ContentLanguages& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
       if (httpMethod == HTTP_METHOD_M_POST)
       {
     out << "M-POST " << requestUri << " HTTP/1.1\r\n";     out << "M-POST " << requestUri << " HTTP/1.1\r\n";
       }
       else
       {
         out << "POST " << requestUri << " HTTP/1.1\r\n";
       }
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";                  OUTPUT_CONTENTLENGTH;
     out << "Man: http://www.hp.com; ns=";  
       if (acceptLanguages.size() > 0)
       {
           out << "Accept-Language: " << acceptLanguages << "\r\n";
       }
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\r\n";
       }
   
   #ifdef PEGASUS_DEBUG
                   // backdoor environment variable to turn OFF client requesting transfer
                   // encoding. The default is on. to turn off, set this variable to zero.
                   // This should be removed when stable. This should only be turned off in
                   // a debugging/testing environment.
   
                   static const char *clientTransferEncodingOff =
                           getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
                   if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
   #endif
                           out << "TE: chunked, trailers" << "\r\n";
   
       if (httpMethod == HTTP_METHOD_M_POST)
       {
                             out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
     out << nn <<"\r\n";     out << nn <<"\r\n";
     out << nn << "-CIMExport: MethodRequest\r\n";     out << nn << "-CIMExport: MethodRequest\r\n";
     out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";     out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
       }
       else
       {
           out << "CIMExport: MethodRequest\r\n";
           out << "CIMExportMethod: " << cimMethod << "\r\n";
       }
   
     if (authenticationHeader.size())     if (authenticationHeader.size())
     {     {
         out << authenticationHeader << "\r\n";         out << authenticationHeader << "\r\n";
     }     }
   
     out << "\r\n";     out << "\r\n";
 } }
  
Line 2281 
Line 2841 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodResponseHeader( void XmlWriter::appendEMethodResponseHeader(
     Array<Sint8>& out,      Buffer& out,
       HttpMethod httpMethod,
       const ContentLanguages& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";                  OUTPUT_CONTENTLENGTH;
   
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\r\n";
       }
       if (httpMethod == HTTP_METHOD_M_POST)
       {
     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 << "-CIMExport: MethodResponse\r\n\r\n";     out << nn << "-CIMExport: MethodResponse\r\n\r\n";
 } }
       else
       {
           out << "CIMExport: MethodResponse\r\n\r\n";
       }
   }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
Line 2306 
Line 2880 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportReqElementBegin( void XmlWriter::_appendSimpleExportReqElementBegin(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "<SIMPLEEXPREQ>\n";     out << "<SIMPLEEXPREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleExportReqElementEnd( void XmlWriter::_appendSimpleExportReqElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</SIMPLEEXPREQ>\n";     out << "</SIMPLEEXPREQ>\n";
 } }
Line 2328 
Line 2902 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodCallElementBegin( void XmlWriter::_appendEMethodCallElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodCallElementEnd( void XmlWriter::_appendEMethodCallElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</EXPMETHODCALL>\n";     out << "</EXPMETHODCALL>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // _appendEParamValueElementBegin()
   // _appendEParamValueElementEnd()
   //
   //     <!ELEMENT EXPPARAMVALUE (INSTANCE)>
   //     <!ATTLIST EXPPARAMVALUE
   //         %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendEParamValueElementBegin(
       Buffer& out,
       const char* name)
   {
       out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";
   }
   
   void XmlWriter::_appendEParamValueElementEnd(
       Buffer& out)
   {
       out << "</EXPPARAMVALUE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendInstanceEParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendInstanceEParameter(
       Buffer& out,
       const char* name,
       const CIMInstance& instance)
   {
       _appendEParamValueElementBegin(out, name);
       appendInstanceElement(out, instance);
       _appendEParamValueElementEnd(out);
   }
   
   //------------------------------------------------------------------------------
   //
 // _appendSimpleExportRspElementBegin() // _appendSimpleExportRspElementBegin()
 // _appendSimpleExportRspElementEnd() // _appendSimpleExportRspElementEnd()
 // //
Line 2350 
Line 2964 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportRspElementBegin( void XmlWriter::_appendSimpleExportRspElementBegin(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "<SIMPLEEXPRSP>\n";     out << "<SIMPLEEXPRSP>\n";
 } }
  
 void XmlWriter::_appendSimpleExportRspElementEnd( void XmlWriter::_appendSimpleExportRspElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</SIMPLEEXPRSP>\n";     out << "</SIMPLEEXPRSP>\n";
 } }
Line 2372 
Line 2986 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodResponseElementBegin( void XmlWriter::_appendEMethodResponseElementBegin(
     Array<Sint8>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodResponseElementEnd( void XmlWriter::_appendEMethodResponseElementEnd(
     Array<Sint8>& out)      Buffer& out)
 { {
     out << "</EXPMETHODRESPONSE>\n";     out << "</EXPMETHODRESPONSE>\n";
 } }
Line 2390 
Line 3004 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(  Buffer XmlWriter::formatSimpleEMethodReqMessage(
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
       HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
     const Array<Sint8>& body)      const AcceptLanguages& httpAcceptLanguages,
       const ContentLanguages& httpContentLanguages,
       const Buffer& body)
 { {
     Array<Sint8> out;      Buffer out;
     Array<Sint8> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportReqElementBegin(out);     _appendSimpleExportReqElementBegin(out);
Line 2414 
Line 3031 
         requestUri,         requestUri,
         host,         host,
         eMethodName,         eMethodName,
           httpMethod,
         authenticationHeader,         authenticationHeader,
           httpAcceptLanguages,
           httpContentLanguages,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
Line 2427 
Line 3047 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(  Buffer XmlWriter::formatSimpleEMethodRspMessage(
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
     const Array<Sint8>& body)      HttpMethod httpMethod,
       const ContentLanguages& httpContentLanguages,
       const Buffer& body)
 { {
     Array<Sint8> out;      Buffer out;
     Array<Sint8> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);
Line 2443 
Line 3065 
     _appendSimpleExportRspElementEnd(out);     _appendSimpleExportRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendEMethodResponseHeader(tmp, out.size());      appendEMethodResponseHeader(tmp,
           httpMethod,
           httpContentLanguages,
           out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2455 
Line 3080 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(  Buffer XmlWriter::formatSimpleEMethodErrorRspMessage(
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
       HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<Sint8> out;      Buffer out;
     Array<Sint8> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);
Line 2471 
Line 3097 
     _appendSimpleExportRspElementEnd(out);     _appendSimpleExportRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendEMethodResponseHeader(tmp, out.size());  // l10n
       appendEMethodResponseHeader(tmp,
            httpMethod,
            cimException.getContentLanguages(),
                    out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2479 
Line 3109 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _printAttributes()  // _xmlWritter_printAttributes()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _printAttributes(  void _xmlWritter_printAttributes(
     PEGASUS_STD(ostream)& os,     PEGASUS_STD(ostream)& os,
     const XmlAttribute* attributes,     const XmlAttribute* attributes,
     Uint32 attributeCount)     Uint32 attributeCount)
Line 2493 
Line 3123 
         os << attributes[i].name << "=";         os << attributes[i].name << "=";
  
         os << '"';         os << '"';
         _appendSpecial(os, attributes[i].value);          _xmlWritter_appendSpecial(os, attributes[i].value);
         os << '"';         os << '"';
  
         if (i + 1 != attributeCount)         if (i + 1 != attributeCount)
Line 2503 
Line 3133 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _indent()  // _xmlWritter_indent()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)  void _xmlWritter_indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
 { {
     Uint32 n = level * indentChars;     Uint32 n = level * indentChars;
  
Line 2526 
Line 3156 
     const char* text,     const char* text,
     Uint32 indentChars)     Uint32 indentChars)
 { {
     char* tmp = strcpy(new char[strlen(text) + 1], text);      AutoArrayPtr<char> tmp(strcpy(new char[strlen(text) + 1], text));
  
     XmlParser parser(tmp);      XmlParser parser(tmp.get());
     XmlEntry entry;     XmlEntry entry;
     Stack<const char*> stack;     Stack<const char*> stack;
  
Line 2538 
Line 3168 
         {         {
             case XmlEntry::XML_DECLARATION:             case XmlEntry::XML_DECLARATION:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<?" << entry.text << " ";                 os << "<?" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
                 os << "?>";                 os << "?>";
                 break;                 break;
             }             }
  
             case XmlEntry::START_TAG:             case XmlEntry::START_TAG:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text;                 os << "<" << entry.text;
  
                 if (entry.attributeCount)                 if (entry.attributeCount)
                     os << ' ';                     os << ' ';
  
                 _printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
                 os << ">";                 os << ">";
                 stack.push(entry.text);                 stack.push(entry.text);
                 break;                 break;
Line 2563 
Line 3193 
  
             case XmlEntry::EMPTY_TAG:             case XmlEntry::EMPTY_TAG:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text << " ";                 os << "<" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
                 os << "/>";                 os << "/>";
                 break;                 break;
             }             }
Line 2576 
Line 3206 
                 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.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "</" << entry.text << ">";                 os << "</" << entry.text << ">";
                 break;                 break;
Line 2585 
Line 3215 
             case XmlEntry::COMMENT:             case XmlEntry::COMMENT:
             {             {
  
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<!--";                 os << "<!--";
                 _appendSpecial(os, entry.text);                  _xmlWritter_appendSpecial(os, entry.text);
                 os << "-->";                 os << "-->";
                 break;                 break;
             }             }
  
             case XmlEntry::CONTENT:             case XmlEntry::CONTENT:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 _appendSpecial(os, entry.text);                  _xmlWritter_appendSpecial(os, entry.text);
                 break;                 break;
             }             }
  
             case XmlEntry::CDATA:             case XmlEntry::CDATA:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<![CDATA[...]]>";                 os << "<![CDATA[...]]>";
                 break;                 break;
             }             }
  
             case XmlEntry::DOCTYPE:             case XmlEntry::DOCTYPE:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<!DOCTYPE...>";                 os << "<!DOCTYPE...>";
                 break;                 break;
             }             }
Line 2617 
Line 3247 
         os << PEGASUS_STD(endl);         os << PEGASUS_STD(endl);
     }     }
  
     delete [] tmp;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2668 
Line 3297 
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   
   

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