(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.124.2.4 and 1.147

version 1.124.2.4, 2005/10/02 02:16:42 version 1.147, 2007/01/11 16:21:54
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 27 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)  
 //              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)  
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                  (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  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
Line 71 
Line 57 
 #include "Tracer.h" #include "Tracer.h"
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
 #include "CommonUTF.h" #include "CommonUTF.h"
   #include "Buffer.h"
   #include "StrLit.h"
   #include "LanguageParser.h"
   #include "IDFactory.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 84 
Line 74 
 #define OUTPUT_CONTENTLENGTH                                            \ #define OUTPUT_CONTENTLENGTH                                            \
 {                                                                       \ {                                                                       \
     char contentLengthP[11];                                            \     char contentLengthP[11];                                            \
     sprintf(contentLengthP,"%.10u", contentLength);                     \      int n = sprintf(contentLengthP,"%.10u", contentLength);                \
     out << LIT("content-length: ") << contentLengthP << LIT("\r\n");    \      out << STRLIT("content-length: ");                                     \
       out.append(contentLengthP, n);                                         \
       out << STRLIT("\r\n");                                                 \
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 94 
Line 86 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   // Note: we cannot use StrLit here since it has a constructur (forbits
   // structure initialization).
   
 struct SpecialChar struct SpecialChar
 { {
     const char* str;     const char* str;
Line 105 
Line 100 
 // length in bytes. // length in bytes.
 static const SpecialChar _specialChars[] = static const SpecialChar _specialChars[] =
 { {
     { "&#0;", 4 },      {STRLIT_ARGS("&#0;")},
     { "&#1;", 4 },      {STRLIT_ARGS("&#1;")},
     { "&#2;", 4 },      {STRLIT_ARGS("&#2;")},
     { "&#3;", 4 },      {STRLIT_ARGS("&#3;")},
     { "&#4;", 4 },      {STRLIT_ARGS("&#4;")},
     { "&#5;", 4 },      {STRLIT_ARGS("&#5;")},
     { "&#6;", 4 },      {STRLIT_ARGS("&#6;")},
     { "&#7;", 4 },      {STRLIT_ARGS("&#7;")},
     { "&#8;", 4 },      {STRLIT_ARGS("&#8;")},
     { "&#9;", 4 },      {STRLIT_ARGS("&#9;")},
     { "&#10;", 5 },      {STRLIT_ARGS("&#10;")},
     { "&#11;", 5 },      {STRLIT_ARGS("&#11;")},
     { "&#12;", 5 },      {STRLIT_ARGS("&#12;")},
     { "&#13;", 5 },      {STRLIT_ARGS("&#13;")},
     { "&#14;", 5 },      {STRLIT_ARGS("&#14;")},
     { "&#15;", 5 },      {STRLIT_ARGS("&#15;")},
     { "&#16;", 5 },      {STRLIT_ARGS("&#16;")},
     { "&#17;", 5 },      {STRLIT_ARGS("&#17;")},
     { "&#18;", 5 },      {STRLIT_ARGS("&#18;")},
     { "&#19;", 5 },      {STRLIT_ARGS("&#19;")},
     { "&#20;", 5 },      {STRLIT_ARGS("&#20;")},
     { "&#21;", 5 },      {STRLIT_ARGS("&#21;")},
     { "&#22;", 5 },      {STRLIT_ARGS("&#22;")},
     { "&#23;", 5 },      {STRLIT_ARGS("&#23;")},
     { "&#24;", 5 },      {STRLIT_ARGS("&#24;")},
     { "&#25;", 5 },      {STRLIT_ARGS("&#25;")},
     { "&#26;", 5 },      {STRLIT_ARGS("&#26;")},
     { "&#27;", 5 },      {STRLIT_ARGS("&#27;")},
     { "&#28;", 5 },      {STRLIT_ARGS("&#28;")},
     { "&#29;", 5 },      {STRLIT_ARGS("&#29;")},
     { "&#30;", 5 },      {STRLIT_ARGS("&#30;")},
     { "&#31;", 5 },      {STRLIT_ARGS("&#31;")},
     { " ", 1 },      {STRLIT_ARGS(" ")},
     { "!", 1 },      {STRLIT_ARGS("!")},
     { "&quot;", 6 },      {STRLIT_ARGS("&quot;")},
     { "#", 1 },      {STRLIT_ARGS("#")},
     { "$", 1 },      {STRLIT_ARGS("$")},
     { "%", 1 },      {STRLIT_ARGS("%")},
     { "&amp;", 5 },      {STRLIT_ARGS("&amp;")},
     { "&apos;", 6 },      {STRLIT_ARGS("&apos;")},
     { "(", 1 },      {STRLIT_ARGS("(")},
     { ")", 1 },      {STRLIT_ARGS(")")},
     { "*", 1 },      {STRLIT_ARGS("*")},
     { "+", 1 },      {STRLIT_ARGS("+")},
     { ",", 1 },      {STRLIT_ARGS(",")},
     { "-", 1 },      {STRLIT_ARGS("-")},
     { ".", 1 },      {STRLIT_ARGS(".")},
     { "/", 1 },      {STRLIT_ARGS("/")},
     { "0", 1 },      {STRLIT_ARGS("0")},
     { "1", 1 },      {STRLIT_ARGS("1")},
     { "2", 1 },      {STRLIT_ARGS("2")},
     { "3", 1 },      {STRLIT_ARGS("3")},
     { "4", 1 },      {STRLIT_ARGS("4")},
     { "5", 1 },      {STRLIT_ARGS("5")},
     { "6", 1 },      {STRLIT_ARGS("6")},
     { "7", 1 },      {STRLIT_ARGS("7")},
     { "8", 1 },      {STRLIT_ARGS("8")},
     { "9", 1 },      {STRLIT_ARGS("9")},
     { ":", 1 },      {STRLIT_ARGS(":")},
     { ";", 1 },      {STRLIT_ARGS(";")},
     { "&lt;", 4 },      {STRLIT_ARGS("&lt;")},
     { "=", 1 },      {STRLIT_ARGS("=")},
     { "&gt;", 4 },      {STRLIT_ARGS("&gt;")},
     { "?", 1 },      {STRLIT_ARGS("?")},
     { "@", 1 },      {STRLIT_ARGS("@")},
     { "A", 1 },      {STRLIT_ARGS("A")},
     { "B", 1 },      {STRLIT_ARGS("B")},
     { "C", 1 },      {STRLIT_ARGS("C")},
     { "D", 1 },      {STRLIT_ARGS("D")},
     { "E", 1 },      {STRLIT_ARGS("E")},
     { "F", 1 },      {STRLIT_ARGS("F")},
     { "G", 1 },      {STRLIT_ARGS("G")},
     { "H", 1 },      {STRLIT_ARGS("H")},
     { "I", 1 },      {STRLIT_ARGS("I")},
     { "J", 1 },      {STRLIT_ARGS("J")},
     { "K", 1 },      {STRLIT_ARGS("K")},
     { "L", 1 },      {STRLIT_ARGS("L")},
     { "M", 1 },      {STRLIT_ARGS("M")},
     { "N", 1 },      {STRLIT_ARGS("N")},
     { "O", 1 },      {STRLIT_ARGS("O")},
     { "P", 1 },      {STRLIT_ARGS("P")},
     { "Q", 1 },      {STRLIT_ARGS("Q")},
     { "R", 1 },      {STRLIT_ARGS("R")},
     { "S", 1 },      {STRLIT_ARGS("S")},
     { "T", 1 },      {STRLIT_ARGS("T")},
     { "U", 1 },      {STRLIT_ARGS("U")},
     { "V", 1 },      {STRLIT_ARGS("V")},
     { "W", 1 },      {STRLIT_ARGS("W")},
     { "X", 1 },      {STRLIT_ARGS("X")},
     { "Y", 1 },      {STRLIT_ARGS("Y")},
     { "Z", 1 },      {STRLIT_ARGS("Z")},
     { "[", 1 },      {STRLIT_ARGS("[")},
     { "\\", 1 },      {STRLIT_ARGS("\\")},
     { "]", 1 },      {STRLIT_ARGS("]")},
     { "^", 1 },      {STRLIT_ARGS("^")},
     { "_", 1 },      {STRLIT_ARGS("_")},
     { "`", 1 },      {STRLIT_ARGS("`")},
     { "a", 1 },      {STRLIT_ARGS("a")},
     { "b", 1 },      {STRLIT_ARGS("b")},
     { "c", 1 },      {STRLIT_ARGS("c")},
     { "d", 1 },      {STRLIT_ARGS("d")},
     { "e", 1 },      {STRLIT_ARGS("e")},
     { "f", 1 },      {STRLIT_ARGS("f")},
     { "g", 1 },      {STRLIT_ARGS("g")},
     { "h", 1 },      {STRLIT_ARGS("h")},
     { "i", 1 },      {STRLIT_ARGS("i")},
     { "j", 1 },      {STRLIT_ARGS("j")},
     { "k", 1 },      {STRLIT_ARGS("k")},
     { "l", 1 },      {STRLIT_ARGS("l")},
     { "m", 1 },      {STRLIT_ARGS("m")},
     { "n", 1 },      {STRLIT_ARGS("n")},
     { "o", 1 },      {STRLIT_ARGS("o")},
     { "p", 1 },      {STRLIT_ARGS("p")},
     { "q", 1 },      {STRLIT_ARGS("q")},
     { "r", 1 },      {STRLIT_ARGS("r")},
     { "s", 1 },      {STRLIT_ARGS("s")},
     { "t", 1 },      {STRLIT_ARGS("t")},
     { "u", 1 },      {STRLIT_ARGS("u")},
     { "v", 1 },      {STRLIT_ARGS("v")},
     { "w", 1 },      {STRLIT_ARGS("w")},
     { "x", 1 },      {STRLIT_ARGS("x")},
     { "y", 1 },      {STRLIT_ARGS("y")},
     { "z", 1 },      {STRLIT_ARGS("z")},
     { "{", 1 },      {STRLIT_ARGS("{")},
     { "|", 1 },      {STRLIT_ARGS("|")},
     { "}", 1 },      {STRLIT_ARGS("}")},
     { "~", 1 },      {STRLIT_ARGS("~")},
     { "&#127;", 6 },      {STRLIT_ARGS("&#127;")},
 }; };
  
 // If _isSpecialChar7[ch] is true, then ch is a special character, which must // If _isSpecialChar7[ch] is true, then ch is a special character, which must
Line 241 
Line 236 
 static const int _isSpecialChar7[] = static const int _isSpecialChar7[] =
 { {
     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,
     0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,      0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
 }; };
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 Buffer& operator<<(Buffer& out, const char* x)  
 {  
     XmlWriter::append(out, x);  
     return out;  
 }  
   
 Buffer& operator<<(Buffer& out, char x)  
 {  
     XmlWriter::append(out, x);  
     return out;  
 }  
   
 Buffer& operator<<(Buffer& out, const Char16& x) Buffer& operator<<(Buffer& out, const Char16& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
Line 297 
Line 280 
 } }
  
  
 // l10n  Buffer& operator<<(Buffer& out, const AcceptLanguageList& al)
 Buffer& operator<<(Buffer& out, const AcceptLanguages& al)  
 { {
     XmlWriter::append(out, al.toString ());      XmlWriter::append(out, LanguageParser::buildAcceptLanguageHeader(al));
     return out;     return out;
 } }
  
 // l10n  Buffer& operator<<(Buffer& out, const ContentLanguageList& cl)
 Buffer& operator<<(Buffer& out, const ContentLanguages& cl)  
 { {
     XmlWriter::append(out, cl.toString ());      XmlWriter::append(out, LanguageParser::buildContentLanguageHeader(cl));
     return out;     return out;
 } }
  
Line 330 
Line 311 
     return os;     return os;
 } }
  
 inline void _xmlWritter_appendChar(Buffer& out, const Char16& c)  static void _xmlWritter_appendChar(Buffer& out, const Char16& c)
 { {
     // We need to convert the Char16 to UTF8 then append the UTF8     // We need to convert the Char16 to UTF8 then append the UTF8
     // character into the array.     // character into the array.
Line 347 
Line 328 
     Uint8 *strtgt = (Uint8 *)str;     Uint8 *strtgt = (Uint8 *)str;
     Uint8 *endtgt = (Uint8 *)&str[5];     Uint8 *endtgt = (Uint8 *)&str[5];
  
     UTF16toUTF8(&strsrc,      UTF16toUTF8(
           &strsrc,
                 endsrc,                 endsrc,
                 &strtgt,                 &strtgt,
                 endtgt);                 endtgt);
Line 355 
Line 337 
     out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);     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)) )  
     {  
         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;  
   
             default:  
                 {  
                     // 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 _appendSpecialChar7(Buffer& out, char c) inline void _appendSpecialChar7(Buffer& out, char c)
 { {
     if (_isSpecialChar7[int(c)])     if (_isSpecialChar7[int(c)])
Line 425 
Line 345 
         out.append(c);         out.append(c);
 } }
  
 inline void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)  inline void _xmlWritter_appendSpecialChar(Buffer& out, const Char16& c)
   {
       if (c < 128)
           _appendSpecialChar7(out, char(c));
       else
           _xmlWritter_appendChar(out, c);
   }
   
   static void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
 { {
     if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )     if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
     {     {
Line 476 
Line 404 
     Uint8 *strtgt = (Uint8 *)str;     Uint8 *strtgt = (Uint8 *)str;
     Uint8 *endtgt = (Uint8 *)&str[5];     Uint8 *endtgt = (Uint8 *)&str[5];
  
     UTF16toUTF8(&strsrc,      UTF16toUTF8(
           &strsrc,
                 endsrc,                 endsrc,
                 &strtgt,                 &strtgt,
                 endtgt);                 endtgt);
Line 542 
Line 471 
 void XmlWriter::append(Buffer& out, Real64 x) void XmlWriter::append(Buffer& out, Real64 x)
 { {
     char buffer[128];     char buffer[128];
     // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format      // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible
     // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec      // with the format given in the CIM/XML spec, and the precision required
     // (8 byte IEEE floating point)      // by the CIM 2.2 spec (8 byte IEEE floating point)
     sprintf(buffer, "%.16e", x);     sprintf(buffer, "%.16e", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Buffer& out, const char* str) void XmlWriter::append(Buffer& out, const char* str)
 { {
     while (*str)      size_t n = strlen(str);
       XmlWriter::append(out, *str++);      out.append(str, n);
 } }
  
 void XmlWriter::append(Buffer& out, const String& str) void XmlWriter::append(Buffer& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)      const Uint16* p = (const Uint16*)str.getChar16Data();
       size_t n = str.size();
   
       // Handle leading ASCII 7 characers in these next two loops (use unrolling).
   
       while (n >= 8 && ((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)
       {
           out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
           p += 8;
           n -= 8;
       }
   
       while (n >= 4 && ((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)
     {     {
         Uint16 c = str[i];          out.append(p[0], p[1], p[2], p[3]);
           p += 4;
           n -= 4;
       }
   
       while (n--)
       {
           Uint16 c = *p++;
   
           // Special processing for UTF8 case:
   
           if (c < 128)
           {
               out.append(c);
               continue;
           }
   
           // Handle UTF8 case (if reached).
   
         if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||         if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
            ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))            ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
         {         {
             Char16 highSurrogate = str[i];              Char16 highSurrogate = p[-1];
             Char16 lowSurrogate = str[++i];              Char16 lowSurrogate = p[0];
               p++;
               n--;
  
             _xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));              _xmlWritter_appendSurrogatePair(
                   out, Uint16(highSurrogate),Uint16(lowSurrogate));
         }         }
         else         else
         {         {
             _xmlWritter_appendChar(out, str[i]);              _xmlWritter_appendChar(out, c);
         }         }
     }     }
 } }
Line 600 
Line 562 
 void XmlWriter::appendSpecial(Buffer& out, const String& str) void XmlWriter::appendSpecial(Buffer& out, const String& str)
 { {
     const Uint16* p = (const Uint16*)str.getChar16Data();     const Uint16* p = (const Uint16*)str.getChar16Data();
     size_t n = str.size();      // prevCharIsSpace is true when the last character written to the Buffer
       // is a space character (not a character reference).
     // Handle leading ASCII 7 characers in these next two loos (use unrolling).      Boolean prevCharIsSpace = false;
   
     while (n >= 8)      // If the first character is a space, use a character reference to avoid
       // space compression.
       if (*p == ' ')
     {     {
         // The following condition is equivalent to this:          out.append(STRLIT_ARGS("&#32;"));
         //     (p[0] < 128 && p[1] < 128 && p[2] < 128 && p[3] < 128 &&          p++;
         //      p[4] < 128 && p[5] < 128 && p[6] < 128 && p[7] < 128)      }
  
         if (((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)      Uint16 c;
       while ((c = *p++) != 0)
         {         {
             // Note: "|" is faster than "||" and achieves the same effect          if (c < 128)
             // since p[i] is either 0 or 1.          {
               if (_isSpecialChar7[c])
             if (_isSpecialChar7[p[0]] | _isSpecialChar7[p[1]] |  
                 _isSpecialChar7[p[2]] | _isSpecialChar7[p[3]] |  
                 _isSpecialChar7[p[4]] | _isSpecialChar7[p[5]] |  
                 _isSpecialChar7[p[6]] | _isSpecialChar7[p[7]])  
             {             {
                 // Rare case.                  // Write the character reference for the special character
                 _appendSpecialChar7(out, p[0]);                  out.append(
                 _appendSpecialChar7(out, p[1]);                      _specialChars[int(c)].str, _specialChars[int(c)].size);
                 _appendSpecialChar7(out, p[2]);                  prevCharIsSpace = false;
                 _appendSpecialChar7(out, p[3]);              }
                 _appendSpecialChar7(out, p[4]);              else if (prevCharIsSpace && (c == ' '))
                 _appendSpecialChar7(out, p[5]);              {
                 _appendSpecialChar7(out, p[6]);                  // Write the character reference for the space character, to
                 _appendSpecialChar7(out, p[7]);                  // avoid compression
                   out.append(STRLIT_ARGS("&#32;"));
                   prevCharIsSpace = false;
             }             }
             else             else
             {             {
                 // Common case.                  out.append(c);
                 out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);                  prevCharIsSpace = (c == ' ');
             }             }
             p += 8;  
             n -= 8;  
         }         }
         else         else
             break;  
     }  
   
     while (n >= 4)  
     {     {
         // The following condition is equivalent to this:              // Handle UTF8 case
         //     (p[0] < 128 && p[1] < 128 && p[2] < 128 && p[3] < 128)  
  
         if (((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)              if ((((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
                    ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE))) &&
                   *p)
         {         {
             if (_isSpecialChar7[p[0]] | _isSpecialChar7[p[1]] |                  _xmlWritter_appendSurrogatePair(out, c, *p++);
                 _isSpecialChar7[p[2]] | _isSpecialChar7[p[3]])  
             {  
                 // Rare case:  
                 _appendSpecialChar7(out, p[0]);  
                 _appendSpecialChar7(out, p[1]);  
                 _appendSpecialChar7(out, p[2]);  
                 _appendSpecialChar7(out, p[3]);  
             }             }
             else             else
             {             {
                 // Common case:                  _xmlWritter_appendChar(out, c);
                 out.append(p[0], p[1], p[2], p[3]);  
             }             }
  
             p += 4;              prevCharIsSpace = false;
             n -= 4;  
         }         }
         else  
             break;  
     }     }
  
     // Process remaining characters. A UTF8 character must have been      // If the last character is a space, use a character reference to avoid
     // encountered or this would have never been reached.      // space compression.
       if (prevCharIsSpace)
     while (n--)  
     {  
         Uint16 c = *p++;  
   
         // Special processing for UTF8 case:  
   
         if (c < 128)  
         {         {
             _appendSpecialChar7(out, c);          out.remove(out.size() - 1);
             continue;          out.append(STRLIT_ARGS("&#32;"));
         }  
   
         // Hanlde UTF8 case (if reached).  
   
         if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||  
            ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))  
         {  
             Char16 highSurrogate = p[-1];  
             Char16 lowSurrogate = p[0];  
             p++;  
             n--;  
   
             _xmlWritter_appendSurrogatePair(  
                 out, Uint16(highSurrogate),Uint16(lowSurrogate));  
         }  
         else  
         {  
             _xmlWritter_appendSpecialChar(out, c);  
         }  
     }     }
 } }
  
Line 715 
Line 636 
 //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`' //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'
 // //
  
 inline void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)  static const char _is_uri[128] =
   {
       1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,
       1,1,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
       0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,
   };
   
   // Perform the necessary URI encoding of characters in HTTP header values.
   // This is required by the HTTP/1.1 specification and the CIM/HTTP
   // Specification (section 3.3.2).
   static void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)
 { {
     Uint8 c = (Uint8)char8;     Uint8 c = (Uint8)char8;
  
 #ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING #ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING
     if ( (c <= 0x20) ||                     // Control characters + space char      if (c > 127 || _is_uri[int(c)])
          ( (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];         char hexencoding[4];
           int n = sprintf(hexencoding, "%%%X%X", c/16, c%16);
         sprintf(hexencoding, "%%%X%X", c/16, c%16);  #ifdef PEGASUS_USE_STRING_EXTENSIONS
           outString.append(hexencoding, n);
   #else /* PEGASUS_USE_STRING_EXTENSIONS */
         outString.append(hexencoding);         outString.append(hexencoding);
   #endif /* PEGASUS_USE_STRING_EXTENSIONS */
     }     }
     else     else
 #endif #endif
Line 781 
Line 707 
             Char16 highSurrogate = uriString[i];             Char16 highSurrogate = uriString[i];
             Char16 lowSurrogate = uriString[++i];             Char16 lowSurrogate = uriString[++i];
  
             _xmlWritter_appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));              _xmlWritter_appendSurrogatePair(
                   utf8, Uint16(highSurrogate),Uint16(lowSurrogate));
         }         }
         else         else
         {         {
Line 810 
Line 737 
     Buffer& out,     Buffer& out,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
     out << LIT("<LOCALNAMESPACEPATH>\n");      out << STRLIT("<LOCALNAMESPACEPATH>\n");
  
     char* nameSpaceCopy = strdup(nameSpace.getString().getCString());     char* nameSpaceCopy = strdup(nameSpace.getString().getCString());
  
 #if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \  #if !defined(PEGASUS_COMPILER_MSVC) && !defined(PEGASUS_OS_ZOS)
     defined(PEGASUS_OS_HPUX) || \  
     defined(PEGASUS_OS_LINUX)  
     char *last;     char *last;
     for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;     for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;
          p = strtok_r(NULL, "/", &last))          p = strtok_r(NULL, "/", &last))
Line 824 
Line 749 
     for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))     for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))
 #endif #endif
     {     {
         out << LIT("<NAMESPACE NAME=\"") << p << LIT("\"/>\n");          out << STRLIT("<NAMESPACE NAME=\"") << p << STRLIT("\"/>\n");
     }     }
     free(nameSpaceCopy);     free(nameSpaceCopy);
  
     out << LIT("</LOCALNAMESPACEPATH>\n");      out << STRLIT("</LOCALNAMESPACEPATH>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 844 
Line 769 
     const String& host,     const String& host,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
     out << LIT("<NAMESPACEPATH>\n");      out << STRLIT("<NAMESPACEPATH>\n");
     out << LIT("<HOST>") << host << LIT("</HOST>\n");      out << STRLIT("<HOST>") << host << STRLIT("</HOST>\n");
     appendLocalNameSpacePathElement(out, nameSpace);     appendLocalNameSpacePathElement(out, nameSpace);
     out << LIT("</NAMESPACEPATH>\n");      out << STRLIT("</NAMESPACEPATH>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 864 
Line 789 
     Buffer& out,     Buffer& out,
     const CIMName& className)     const CIMName& className)
 { {
     out << LIT("<CLASSNAME NAME=\"") << className << LIT("\"/>\n");      out << STRLIT("<CLASSNAME NAME=\"") << className << STRLIT("\"/>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 881 
Line 806 
     Buffer& out,     Buffer& out,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
     out << LIT("<INSTANCENAME CLASSNAME=\"");      out << STRLIT("<INSTANCENAME CLASSNAME=\"");
     out << instanceName.getClassName() << LIT("\">\n");      out << instanceName.getClassName() << STRLIT("\">\n");
  
     Array<CIMKeyBinding> keyBindings = instanceName.getKeyBindings();      const Array<CIMKeyBinding>& keyBindings = instanceName.getKeyBindings();
     for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)     for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)
     {     {
         out << LIT("<KEYBINDING NAME=\"");          out << STRLIT("<KEYBINDING NAME=\"");
         out << keyBindings[i].getName() << LIT("\">\n");          out << keyBindings[i].getName() << STRLIT("\">\n");
  
         if (keyBindings[i].getType() == CIMKeyBinding::REFERENCE)         if (keyBindings[i].getType() == CIMKeyBinding::REFERENCE)
         {         {
             CIMObjectPath ref = keyBindings[i].getValue();             CIMObjectPath ref = keyBindings[i].getValue();
             appendValueReferenceElement(out, ref, true);             appendValueReferenceElement(out, ref, true);
         }         }
         else {          else
             out << LIT("<KEYVALUE VALUETYPE=\"");          {
               out << STRLIT("<KEYVALUE VALUETYPE=\"");
             out << keyBindingTypeToString(keyBindings[i].getType());             out << keyBindingTypeToString(keyBindings[i].getType());
             out << LIT("\">");              out << STRLIT("\">");
  
             // fixed the special character problem - Markus             // fixed the special character problem - Markus
  
             appendSpecial(out, keyBindings[i].getValue());             appendSpecial(out, keyBindings[i].getValue());
             out << LIT("</KEYVALUE>\n");              out << STRLIT("</KEYVALUE>\n");
         }         }
         out << LIT("</KEYBINDING>\n");          out << STRLIT("</KEYBINDING>\n");
     }     }
     out << LIT("</INSTANCENAME>\n");      out << STRLIT("</INSTANCENAME>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 922 
Line 848 
     Buffer& out,     Buffer& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << LIT("<CLASSPATH>\n");      out << STRLIT("<CLASSPATH>\n");
     appendNameSpacePathElement(out,     appendNameSpacePathElement(out,
                                classPath.getHost(),                                classPath.getHost(),
                                classPath.getNameSpace());                                classPath.getNameSpace());
     appendClassNameElement(out, classPath.getClassName());     appendClassNameElement(out, classPath.getClassName());
     out << LIT("</CLASSPATH>\n");      out << STRLIT("</CLASSPATH>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 942 
Line 868 
     Buffer& out,     Buffer& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << LIT("<INSTANCEPATH>\n");      out << STRLIT("<INSTANCEPATH>\n");
     appendNameSpacePathElement(out,     appendNameSpacePathElement(out,
                                instancePath.getHost(),                                instancePath.getHost(),
                                instancePath.getNameSpace());                                instancePath.getNameSpace());
     appendInstanceNameElement(out, instancePath);     appendInstanceNameElement(out, instancePath);
     out << LIT("</INSTANCEPATH>\n");      out << STRLIT("</INSTANCEPATH>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 962 
Line 888 
     Buffer& out,     Buffer& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << LIT("<LOCALCLASSPATH>\n");      out << STRLIT("<LOCALCLASSPATH>\n");
     appendLocalNameSpacePathElement(out, classPath.getNameSpace());     appendLocalNameSpacePathElement(out, classPath.getNameSpace());
     appendClassNameElement(out, classPath.getClassName());     appendClassNameElement(out, classPath.getClassName());
     out << LIT("</LOCALCLASSPATH>\n");      out << STRLIT("</LOCALCLASSPATH>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 980 
Line 906 
     Buffer& out,     Buffer& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << LIT("<LOCALINSTANCEPATH>\n");      out << STRLIT("<LOCALINSTANCEPATH>\n");
     appendLocalNameSpacePathElement(out, instancePath.getNameSpace());     appendLocalNameSpacePathElement(out, instancePath.getNameSpace());
     appendInstanceNameElement(out, instancePath);     appendInstanceNameElement(out, instancePath);
     out << LIT("</LOCALINSTANCEPATH>\n");      out << STRLIT("</LOCALINSTANCEPATH>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1088 
Line 1014 
  
 inline void _xmlWritter_appendValue(Buffer& out, const CIMDateTime& x) inline void _xmlWritter_appendValue(Buffer& out, const CIMDateTime& x)
 { {
     out << x.toString();  //ATTN: append() method?      // It is not necessary to use XmlWriter::appendSpecial(), because
       // CIMDateTime values do not contain special characters.
       out << x.toString();
 } }
  
 inline void _xmlWritter_appendValue(Buffer& out, const CIMObjectPath& x) inline void _xmlWritter_appendValue(Buffer& out, const CIMObjectPath& x)
Line 1102 
Line 1030 
     _xmlWritter_appendValue(out, myStr);     _xmlWritter_appendValue(out, myStr);
 } }
  
 void _xmlWritter_appendValueArray(Buffer& out, const CIMObjectPath* p, Uint32 size)  void _xmlWritter_appendValueArray(
       Buffer& out, const CIMObjectPath* p, Uint32 size)
 { {
     out << LIT("<VALUE.REFARRAY>\n");      out << STRLIT("<VALUE.REFARRAY>\n");
     while (size--)     while (size--)
     {     {
         _xmlWritter_appendValue(out, *p++);         _xmlWritter_appendValue(out, *p++);
     }     }
     out << LIT("</VALUE.REFARRAY>\n");      out << STRLIT("</VALUE.REFARRAY>\n");
 } }
  
 template<class T> template<class T>
 void _xmlWritter_appendValueArray(Buffer& out, const T* p, Uint32 size) void _xmlWritter_appendValueArray(Buffer& out, const T* p, Uint32 size)
 { {
     out << LIT("<VALUE.ARRAY>\n");      out << STRLIT("<VALUE.ARRAY>\n");
  
     while (size--)     while (size--)
     {     {
         out << LIT("<VALUE>");          out << STRLIT("<VALUE>");
         _xmlWritter_appendValue(out, *p++);         _xmlWritter_appendValue(out, *p++);
         out << LIT("</VALUE>\n");          out << STRLIT("</VALUE>\n");
     }     }
  
     out << LIT("</VALUE.ARRAY>\n");      out << STRLIT("</VALUE.ARRAY>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1250 
Line 1179 
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
             {             {
                 Array<String> a;                  const String* data;
                 value.get(a);                  Uint32 size;
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());                  value._get(data, size);
                   _xmlWritter_appendValueArray(out, data, size);
                 break;                 break;
             }             }
  
Line 1279 
Line 1209 
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());                 _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               case CIMTYPE_INSTANCE:
               {
                   Array<CIMInstance> a;
                   value.get(a);
                   _xmlWritter_appendValueArray(out, a.getData(), a.size());
                   break;
               }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1293 
Line 1231 
     }     }
     else     else
     {     {
         out << LIT("<VALUE>");          out << STRLIT("<VALUE>");
  
         switch (value.getType())         switch (value.getType())
         {         {
Line 1416 
Line 1354 
                 _xmlWritter_appendValue(out, v);                 _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               case CIMTYPE_INSTANCE:
               {
                   CIMInstance v;
                   value.get(v);
                   _xmlWritter_appendValue(out, v);
                   break;
               }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
  
         out << LIT("</VALUE>\n");          out << STRLIT("</VALUE>\n");
     }     }
 } }
  
Line 1448 
Line 1394 
     Buffer& out,     Buffer& out,
     const CIMObject& objectWithPath)     const CIMObject& objectWithPath)
 { {
     out << LIT("<VALUE.OBJECTWITHPATH>\n");      out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
  
     appendValueReferenceElement(out, objectWithPath.getPath (), false);     appendValueReferenceElement(out, objectWithPath.getPath (), false);
     appendObjectElement(out, objectWithPath);     appendObjectElement(out, objectWithPath);
  
     out << LIT("</VALUE.OBJECTWITHPATH>\n");      out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1472 
Line 1418 
     Boolean putValueWrapper)     Boolean putValueWrapper)
 { {
     if (putValueWrapper)     if (putValueWrapper)
         out << LIT("<VALUE.REFERENCE>\n");          out << STRLIT("<VALUE.REFERENCE>\n");
  
     // See if it is a class or instance reference (instance references have     // See if it is a class or instance reference (instance references have
     // key-bindings; class references do not).     // key-bindings; class references do not).
Line 1483 
Line 1429 
     //  key bindings     //  key bindings
     //     //
  
     Array<CIMKeyBinding> kbs = reference.getKeyBindings();      const Array<CIMKeyBinding>& kbs = reference.getKeyBindings();
  
     if (kbs.size())     if (kbs.size())
     {     {
Line 1517 
Line 1463 
     }     }
  
     if (putValueWrapper)     if (putValueWrapper)
         out << LIT("</VALUE.REFERENCE>\n");          out << STRLIT("</VALUE.REFERENCE>\n");
 } }
  
 void XmlWriter::printValueReferenceElement( void XmlWriter::printValueReferenceElement(
Line 1542 
Line 1488 
     Buffer& out,     Buffer& out,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
     out << LIT("<VALUE.NAMEDINSTANCE>\n");      out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
  
     appendInstanceNameElement(out, namedInstance.getPath ());     appendInstanceNameElement(out, namedInstance.getPath ());
     appendInstanceElement(out, namedInstance);     appendInstanceElement(out, namedInstance);
  
     out << LIT("</VALUE.NAMEDINSTANCE>\n");      out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1865 
Line 1811 
     const CIMFlavor & flavor)     const CIMFlavor & flavor)
 { {
     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))
         out << LIT(" OVERRIDABLE=\"false\"");          out << STRLIT(" OVERRIDABLE=\"false\"");
  
     if (!(flavor.hasFlavor (CIMFlavor::TOSUBCLASS)))     if (!(flavor.hasFlavor (CIMFlavor::TOSUBCLASS)))
         out << LIT(" TOSUBCLASS=\"false\"");          out << STRLIT(" TOSUBCLASS=\"false\"");
  
     if (flavor.hasFlavor (CIMFlavor::TOINSTANCE))     if (flavor.hasFlavor (CIMFlavor::TOINSTANCE))
         out << LIT(" TOINSTANCE=\"true\"");          out << STRLIT(" TOINSTANCE=\"true\"");
  
     if (flavor.hasFlavor (CIMFlavor::TRANSLATABLE))     if (flavor.hasFlavor (CIMFlavor::TRANSLATABLE))
         out << LIT(" TRANSLATABLE=\"true\"");          out << STRLIT(" TRANSLATABLE=\"true\"");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1899 
Line 1845 
 { {
     if (!(scope.equal (CIMScope ())))     if (!(scope.equal (CIMScope ())))
     {     {
         out << LIT("<SCOPE");          out << STRLIT("<SCOPE");
  
         if (scope.hasScope (CIMScope::CLASS))         if (scope.hasScope (CIMScope::CLASS))
             out << LIT(" CLASS=\"true\"");              out << STRLIT(" CLASS=\"true\"");
  
         if (scope.hasScope (CIMScope::ASSOCIATION))         if (scope.hasScope (CIMScope::ASSOCIATION))
             out << LIT(" ASSOCIATION=\"true\"");              out << STRLIT(" ASSOCIATION=\"true\"");
  
         if (scope.hasScope (CIMScope::REFERENCE))         if (scope.hasScope (CIMScope::REFERENCE))
             out << LIT(" REFERENCE=\"true\"");              out << STRLIT(" REFERENCE=\"true\"");
  
         if (scope.hasScope (CIMScope::PROPERTY))         if (scope.hasScope (CIMScope::PROPERTY))
             out << LIT(" PROPERTY=\"true\"");              out << STRLIT(" PROPERTY=\"true\"");
  
         if (scope.hasScope (CIMScope::METHOD))         if (scope.hasScope (CIMScope::METHOD))
             out << LIT(" METHOD=\"true\"");              out << STRLIT(" METHOD=\"true\"");
  
         if (scope.hasScope (CIMScope::PARAMETER))         if (scope.hasScope (CIMScope::PARAMETER))
             out << LIT(" PARAMETER=\"true\"");              out << STRLIT(" PARAMETER=\"true\"");
  
         if (scope.hasScope (CIMScope::INDICATION))         if (scope.hasScope (CIMScope::INDICATION))
             out << LIT(" INDICATION=\"true\"");              out << STRLIT(" INDICATION=\"true\"");
  
         out << LIT("/>");          out << STRLIT("/>");
     }     }
 } }
  
Line 1944 
Line 1890 
     const String& cimObject,     const String& cimObject,
     const String& authenticationHeader,     const String& authenticationHeader,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const AcceptLanguages & acceptLanguages,      const AcceptLanguageList& acceptLanguages,
     const ContentLanguages & contentLanguages,      const ContentLanguageList& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
Line 1958 
Line 1904 
     // installed.  Required because of change to wbemservices cimom     // installed.  Required because of change to wbemservices cimom
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << LIT("M-POST /cimom HTTP/1.1\r\n");          out << STRLIT("M-POST /cimom HTTP/1.1\r\n");
     }     }
     else     else
     {     {
         out << LIT("POST /cimom HTTP/1.1\r\n");          out << STRLIT("POST /cimom HTTP/1.1\r\n");
     }     }
     out << LIT("HOST: ") << host << LIT("\r\n");      out << STRLIT("HOST: ") << host << STRLIT("\r\n");
     out << LIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");      out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
     OUTPUT_CONTENTLENGTH;     OUTPUT_CONTENTLENGTH;
     if (acceptLanguages.size() > 0)     if (acceptLanguages.size() > 0)
     {     {
         out << LIT("Accept-Language: ") << acceptLanguages << LIT("\r\n");          out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
     }     }
     if (contentLanguages.size() > 0)     if (contentLanguages.size() > 0)
     {     {
         out << LIT("Content-Language: ") << contentLanguages << LIT("\r\n");          out << STRLIT("Content-Language: ") << contentLanguages <<
               STRLIT("\r\n");
     }     }
  
 #ifdef PEGASUS_DEBUG #ifdef PEGASUS_DEBUG
Line 1984 
Line 1931 
  
                 static const char *clientTransferEncodingOff =                 static const char *clientTransferEncodingOff =
                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
   
                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
 #endif #endif
  
                         out << LIT("TE: chunked, trailers\r\n");      out << STRLIT("TE: chunked, trailers\r\n");
  
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << LIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");          out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
         out << nn << LIT("\r\n");          out << nn << STRLIT("\r\n");
         out << nn << LIT("-CIMOperation: MethodCall\r\n");          out << nn << STRLIT("-CIMOperation: MethodCall\r\n");
         out << nn << LIT("-CIMMethod: ")          out << nn << STRLIT("-CIMMethod: ")
             << encodeURICharacters(cimMethod.getString()) << LIT("\r\n");              << encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n");
         out << nn << LIT("-CIMObject: ") << encodeURICharacters(cimObject)          out << nn << STRLIT("-CIMObject: ") << encodeURICharacters(cimObject)
             << LIT("\r\n");              << STRLIT("\r\n");
     }     }
     else     else
     {     {
         out << LIT("CIMOperation: MethodCall\r\n");          out << STRLIT("CIMOperation: MethodCall\r\n");
         out << LIT("CIMMethod: ") << encodeURICharacters(cimMethod.getString())          out << STRLIT("CIMMethod: ")
             << LIT("\r\n");              << encodeURICharacters(cimMethod.getString())
         out << LIT("CIMObject: ") << encodeURICharacters(cimObject)              << STRLIT("\r\n");
             << LIT("\r\n");          out << STRLIT("CIMObject: ") << encodeURICharacters(cimObject)
               << STRLIT("\r\n");
     }     }
  
     if (authenticationHeader.size())     if (authenticationHeader.size())
     {     {
         out << authenticationHeader << LIT("\r\n");          out << authenticationHeader << STRLIT("\r\n");
     }     }
  
     out << LIT("\r\n");      out << STRLIT("\r\n");
 } }
  
  
 void XmlWriter::appendMethodResponseHeader( void XmlWriter::appendMethodResponseHeader(
      Buffer& out,      Buffer& out,
      HttpMethod httpMethod,      HttpMethod httpMethod,
      const ContentLanguages & contentLanguages,       const ContentLanguageList& contentLanguages,
      Uint32 contentLength,      Uint32 contentLength,
      Uint32 serverResponseTime)       Uint64 serverResponseTime)
 { {
      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
      out << LIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");       out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");
      STAT_SERVERTIME  
      out << LIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");  #ifndef PEGASUS_DISABLE_PERFINST
        if (StatisticalData::current()->copyGSD)
        {
            out << STRLIT("WBEMServerResponseTime: ") <<
                CIMValue(serverResponseTime).toString() << STRLIT("\r\n");
        }
   #endif
   
        out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
      OUTPUT_CONTENTLENGTH;      OUTPUT_CONTENTLENGTH;
  
      if (contentLanguages.size() > 0)      if (contentLanguages.size() > 0)
      {      {
          out << LIT("Content-Language: ") << contentLanguages << LIT("\r\n");           out << STRLIT("Content-Language: ") << contentLanguages <<
                STRLIT("\r\n");
      }      }
      if (httpMethod == HTTP_METHOD_M_POST)      if (httpMethod == HTTP_METHOD_M_POST)
      {      {
          out << LIT("Ext:\r\n");           out << STRLIT("Ext:\r\n");
          out << LIT("Cache-Control: no-cache\r\n");           out << STRLIT("Cache-Control: no-cache\r\n");
          out << LIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");           out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
          out << nn << LIT("\r\n");           out << nn << STRLIT("\r\n");
          out << nn << LIT("-CIMOperation: MethodResponse\r\n\r\n");           out << nn << STRLIT("-CIMOperation: MethodResponse\r\n\r\n");
      }      }
      else      else
      {      {
          out << LIT("CIMOperation: MethodResponse\r\n\r\n");           out << STRLIT("CIMOperation: MethodResponse\r\n\r\n");
      }      }
 } }
  
Line 2069 
Line 2027 
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
 { {
     out << LIT("HTTP/1.1 ") << status << LIT("\r\n");      out << STRLIT("HTTP/1.1 ") << status << STRLIT("\r\n");
     if (cimError != String::EMPTY)     if (cimError != String::EMPTY)
     {     {
         out << LIT("CIMError: ") << cimError << LIT("\r\n");          out << STRLIT("CIMError: ") << cimError << STRLIT("\r\n");
     }     }
     if (errorDetail != String::EMPTY)     if (errorDetail != String::EMPTY)
     {     {
         // ATTN-RK-P3-20020404: It is critical that this text not contain '\n'          out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")
         // ATTN-RK-P3-20020404: Need to encode this value properly.  (See              << encodeURICharacters(errorDetail) << STRLIT("\r\n");
         // CIM/HTTP Specification section 3.3.2  
         out << LIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")  
             << encodeURICharacters(errorDetail) << LIT("\r\n");  
     }     }
     out << LIT("\r\n");      out << STRLIT("\r\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2108 
Line 2063 
     Buffer& out,     Buffer& out,
     const String& content)     const String& content)
 { {
     out << LIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n");      out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n");
     out << content << LIT("\r\n");      out << content << STRLIT("\r\n");
     out << LIT("\r\n");      out << STRLIT("\r\n");
  
 //ATTN: We may need to include the following line, so that the browsers //ATTN: We may need to include the following line, so that the browsers
 //      can display the error message. //      can display the error message.
Line 2147 
Line 2102 
     Buffer& out,     Buffer& out,
     const String& content)     const String& content)
 { {
     out << LIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");      out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");
     // Content-Length header needs to be added because 200 OK record     // Content-Length header needs to be added because 200 OK record
     // is usually intended to have content.  But, for Kerberos this     // is usually intended to have content.  But, for Kerberos this
     // may not always be the case so we need to indicate that there     // may not always be the case so we need to indicate that there
     // is no content     // is no content
                 Uint32 contentLength = 0;                 Uint32 contentLength = 0;
                 OUTPUT_CONTENTLENGTH;                 OUTPUT_CONTENTLENGTH;
     out << content << LIT("\r\n");      out << content << STRLIT("\r\n");
     out << LIT("\r\n");      out << STRLIT("\r\n");
  
 //ATTN: We may need to include the following line, so that the browsers //ATTN: We may need to include the following line, so that the browsers
 //      can display the error message. //      can display the error message.
Line 2184 
Line 2139 
     Buffer& out,     Buffer& out,
     const String& messageId)     const String& messageId)
 { {
     out << LIT("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");      out << STRLIT("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
     out << LIT("<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n");      out << STRLIT("<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n");
     out << LIT("<MESSAGE ID=\"") << messageId;      out << STRLIT("<MESSAGE ID=\"") << messageId;
     out << LIT("\" PROTOCOLVERSION=\"1.0\">\n");      out << STRLIT("\" PROTOCOLVERSION=\"1.0\">\n");
 } }
  
 void XmlWriter::_appendMessageElementEnd( void XmlWriter::_appendMessageElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</MESSAGE>\n");      out << STRLIT("</MESSAGE>\n");
     out << LIT("</CIM>\n");      out << STRLIT("</CIM>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2209 
Line 2164 
 void XmlWriter::_appendSimpleReqElementBegin( void XmlWriter::_appendSimpleReqElementBegin(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("<SIMPLEREQ>\n");      out << STRLIT("<SIMPLEREQ>\n");
 } }
  
 void XmlWriter::_appendSimpleReqElementEnd( void XmlWriter::_appendSimpleReqElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</SIMPLEREQ>\n");      out << STRLIT("</SIMPLEREQ>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2232 
Line 2187 
     Buffer& out,     Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << LIT("<METHODCALL NAME=\"") << name << LIT("\">\n");      out << STRLIT("<METHODCALL NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendMethodCallElementEnd( void XmlWriter::_appendMethodCallElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</METHODCALL>\n");      out << STRLIT("</METHODCALL>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2255 
Line 2210 
     Buffer& out,     Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << LIT("<IMETHODCALL NAME=\"") << name << LIT("\">\n");      out << STRLIT("<IMETHODCALL NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendIMethodCallElementEnd( void XmlWriter::_appendIMethodCallElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</IMETHODCALL>\n");      out << STRLIT("</IMETHODCALL>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2280 
Line 2235 
     Buffer& out,     Buffer& out,
     const char* name)     const char* name)
 { {
     out << LIT("<IPARAMVALUE NAME=\"") << name << LIT("\">\n");      out << STRLIT("<IPARAMVALUE NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendIParamValueElementEnd( void XmlWriter::_appendIParamValueElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</IPARAMVALUE>\n");      out << STRLIT("</IPARAMVALUE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2301 
Line 2256 
 void XmlWriter::_appendSimpleRspElementBegin( void XmlWriter::_appendSimpleRspElementBegin(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("<SIMPLERSP>\n");      out << STRLIT("<SIMPLERSP>\n");
 } }
  
 void XmlWriter::_appendSimpleRspElementEnd( void XmlWriter::_appendSimpleRspElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</SIMPLERSP>\n");      out << STRLIT("</SIMPLERSP>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2324 
Line 2279 
     Buffer& out,     Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << LIT("<METHODRESPONSE NAME=\"") << name << LIT("\">\n");      out << STRLIT("<METHODRESPONSE NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendMethodResponseElementEnd( void XmlWriter::_appendMethodResponseElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</METHODRESPONSE>\n");      out << STRLIT("</METHODRESPONSE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2347 
Line 2302 
     Buffer& out,     Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << LIT("<IMETHODRESPONSE NAME=\"") << name << LIT("\">\n");      out << STRLIT("<IMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendIMethodResponseElementEnd( void XmlWriter::_appendIMethodResponseElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</IMETHODRESPONSE>\n");      out << STRLIT("</IMETHODRESPONSE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2368 
Line 2323 
 { {
     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);
  
     out << LIT("<ERROR");      out << STRLIT("<ERROR");
     out << LIT(" CODE=\"") << Uint32(cimException.getCode());      out << STRLIT(" CODE=\"") << Uint32(cimException.getCode());
     out.append('"');     out.append('"');
   
     String description = TraceableCIMException(cimException).getDescription();     String description = TraceableCIMException(cimException).getDescription();
   
     if (description != String::EMPTY)     if (description != String::EMPTY)
     {     {
         out << LIT(" DESCRIPTION=\"");          out << STRLIT(" DESCRIPTION=\"");
         appendSpecial(out, description);         appendSpecial(out, description);
         out.append('"');         out.append('"');
     }     }
     out << LIT("/>");  
       if (cimException.getErrorCount())
       {
           out << STRLIT(">");
   
           for (Uint32 i = 0, n = cimException.getErrorCount(); i < n; i++)
               appendInstanceElement(out, cimException.getError(i));
   
           out << STRLIT("</ERROR>");
       }
       else
           out << STRLIT("/>");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2396 
Line 2364 
     Buffer& out,     Buffer& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     out << LIT("<RETURNVALUE");      out << STRLIT("<RETURNVALUE");
  
     CIMType type = value.getType();     CIMType type = value.getType();
     // If the property type is CIMObject, then     // If the property type is CIMObject, then
     //   encode the property in CIM-XML as a string with the EMBEDDEDOBJECT attribute      //   encode the property in CIM-XML as a string with the EMBEDDEDOBJECT
     //   (there is not currently a CIM-XML "object" datatype)      //   attribute (there is not currently a CIM-XML "object" datatype)
     // else     // else
     //   output the real type     //   output the real type
     if (type == CIMTYPE_OBJECT)     if (type == CIMTYPE_OBJECT)
     {     {
         out << LIT(" PARAMTYPE=\"string\"");          out << STRLIT(" PARAMTYPE=\"string\"");
         out << LIT(" EMBEDDEDOBJECT=\"object\"");          out << STRLIT(" EMBEDDEDOBJECT=\"object\"");
     }     }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       else if (type == CIMTYPE_INSTANCE)
       {
           out << STRLIT(" PARAMTYPE=\"string\"");
           out << STRLIT(" EMBEDDEDOBJECT=\"instance\"");
       }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
     else     else
     {     {
         out << LIT(" PARAMTYPE=\"") << cimTypeToString (type);          out << STRLIT(" PARAMTYPE=\"") << cimTypeToString (type);
         out.append('"');         out.append('"');
     }     }
  
     out << LIT(">\n");      out << STRLIT(">\n");
  
     // Add value.     // Add value.
     appendValueElement(out, value);     appendValueElement(out, value);
     out << LIT("</RETURNVALUE>\n");      out << STRLIT("</RETURNVALUE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2437 
Line 2412 
 void XmlWriter::_appendIReturnValueElementBegin( void XmlWriter::_appendIReturnValueElementBegin(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("<IRETURNVALUE>\n");      out << STRLIT("<IRETURNVALUE>\n");
 } }
  
 void XmlWriter::_appendIReturnValueElementEnd( void XmlWriter::_appendIReturnValueElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</IRETURNVALUE>\n");      out << STRLIT("</IRETURNVALUE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2458 
Line 2433 
     Boolean flag)     Boolean flag)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     out << LIT("<VALUE>");      out << STRLIT("<VALUE>");
     append(out, flag);     append(out, flag);
     out << LIT("</VALUE>\n");      out << STRLIT("</VALUE>\n");
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 2476 
Line 2451 
     const String& str)     const String& str)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     out << LIT("<VALUE>");      out << STRLIT("<VALUE>");
     appendSpecial(out, str);     appendSpecial(out, str);
     out << LIT("</VALUE>\n");      out << STRLIT("</VALUE>\n");
     _appendIParamValueElementEnd(out);  
 }  
   
 //------------------------------------------------------------------------------  
 //  
 // appendQualifierNameIParameter()  
 //  
 //------------------------------------------------------------------------------  
   
 void XmlWriter::appendQualifierNameIParameter(  
     Buffer& out,  
     const char* name,  
     const String& qualifierName)  
 {  
     // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE  
     //     |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION  
     //     |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>  
     //  
     // ATTN: notice that there is really no way to pass a qualifier name  
     // as an IPARAMVALUE element according to the spec (look above). So we  
     // just pass it as a class name. An answer must be obtained later.  
   
     _appendIParamValueElementBegin(out, name);  
     appendClassNameElement(out, qualifierName);  
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 2632 
Line 2583 
     const CIMName& propertyName)     const CIMName& propertyName)
 { {
     _appendIParamValueElementBegin(out, "PropertyName");     _appendIParamValueElementBegin(out, "PropertyName");
     out << LIT("<VALUE>") << propertyName << LIT("</VALUE>\n");      out << STRLIT("<VALUE>") << propertyName << STRLIT("</VALUE>\n");
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 2670 
Line 2621 
     //     //
     if (!propertyList.isNull ())     if (!propertyList.isNull ())
     {     {
         out << LIT("<VALUE.ARRAY>\n");          out << STRLIT("<VALUE.ARRAY>\n");
         for (Uint32 i = 0; i < propertyList.size(); i++)         for (Uint32 i = 0; i < propertyList.size(); i++)
         {         {
             out << LIT("<VALUE>") << propertyList[i] << LIT("</VALUE>\n");              out << STRLIT("<VALUE>") << propertyList[i] << STRLIT("</VALUE>\n");
         }         }
         out << LIT("</VALUE.ARRAY>\n");          out << STRLIT("</VALUE.ARRAY>\n");
     }     }
  
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
Line 2733 
Line 2684 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,      const AcceptLanguageList& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages)      const ContentLanguageList& httpContentLanguages)
 { {
     Buffer out;     Buffer out;
     Buffer tmp;     Buffer tmp;
Line 2763 
Line 2714 
         httpMethod,         httpMethod,
         httpAcceptLanguages,         httpAcceptLanguages,
         httpContentLanguages,         httpContentLanguages,
         out.size());          (Uint32)out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2774 
Line 2725 
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,      const ContentLanguageList& httpContentLanguages,
     const Buffer& body,     const Buffer& body,
                 Uint32 serverResponseTime,      Uint64 serverResponseTime,
                 Boolean isFirst,                 Boolean isFirst,
                 Boolean isLast)                 Boolean isLast)
 { {
Line 2786 
Line 2737 
         {         {
                 // NOTE: temporarily put zero for content length. the http code                 // NOTE: temporarily put zero for content length. the http code
                 // will later decide to fill in the length or remove it altogether                 // will later decide to fill in the length or remove it altogether
                 appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,          appendMethodResponseHeader(
                                                                                                                          serverResponseTime);              out, httpMethod, httpContentLanguages, 0, serverResponseTime);
                 _appendMessageElementBegin(out, messageId);                 _appendMessageElementBegin(out, messageId);
                 _appendSimpleRspElementBegin(out);                 _appendSimpleRspElementBegin(out);
                 _appendMethodResponseElementBegin(out, methodName);                 _appendMethodResponseElementBegin(out, methodName);
Line 2809 
Line 2760 
 } }
  
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleMethodErrorRspMessage() // XmlWriter::formatSimpleMethodErrorRspMessage()
Line 2833 
Line 2783 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
 // l10n      appendMethodResponseHeader(
     appendMethodResponseHeader(tmp,          tmp,
         httpMethod,         httpMethod,
         cimException.getContentLanguages(),         cimException.getContentLanguages(),
         out.size());          (Uint32)out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2856 
Line 2806 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,      const AcceptLanguageList& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,      const ContentLanguageList& httpContentLanguages,
     const Buffer& body)     const Buffer& body)
 { {
     Buffer out;     Buffer out;
Line 2881 
Line 2831 
         httpMethod,         httpMethod,
         httpAcceptLanguages,         httpAcceptLanguages,
         httpContentLanguages,         httpContentLanguages,
         out.size());          (Uint32)out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2897 
Line 2847 
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,      const ContentLanguageList& httpContentLanguages,
     const Buffer& body,     const Buffer& body,
     Uint32 serverResponseTime,      Uint64 serverResponseTime,
     Boolean isFirst,     Boolean isFirst,
     Boolean isLast)     Boolean isLast)
 { {
Line 2909 
Line 2859 
                 {                 {
                         // NOTE: temporarily put zero for content length. the http code                         // NOTE: temporarily put zero for content length. the http code
                         // will later decide to fill in the length or remove it altogether                         // will later decide to fill in the length or remove it altogether
                         appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,          appendMethodResponseHeader(
                                                                                                                                  serverResponseTime);              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:          // output the start of the return tag. Test if there is response data
           // by:
                         // 1. there is data on the first chunk OR                         // 1. there is data on the first chunk OR
                         // 2. there is no data on the first chunk but isLast is false implying                         // 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                         //    there is more non-empty data to come. If all subsequent chunks
Line 2965 
Line 2916 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
 // l10n  
     appendMethodResponseHeader(tmp,     appendMethodResponseHeader(tmp,
          httpMethod,          httpMethod,
          cimException.getContentLanguages(),          cimException.getContentLanguages(),
          out.size());          (Uint32)out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2996 
Line 2946 
     const CIMName& cimMethod,     const CIMName& cimMethod,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& acceptLanguages,      const AcceptLanguageList& acceptLanguages,
     const ContentLanguages& contentLanguages,      const ContentLanguageList& 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)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
       out << LIT("M-POST ") << requestUri << LIT(" HTTP/1.1\r\n");        out << STRLIT("M-POST ") << requestUri << STRLIT(" HTTP/1.1\r\n");
     }     }
     else     else
     {     {
       out << LIT("POST ") << requestUri << LIT(" HTTP/1.1\r\n");        out << STRLIT("POST ") << requestUri << STRLIT(" HTTP/1.1\r\n");
     }     }
     out << LIT("HOST: ") << host << LIT("\r\n");      out << STRLIT("HOST: ") << host << STRLIT("\r\n");
     out << LIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");      out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
     OUTPUT_CONTENTLENGTH;     OUTPUT_CONTENTLENGTH;
  
     if (acceptLanguages.size() > 0)     if (acceptLanguages.size() > 0)
     {     {
         out << LIT("Accept-Language: ") << acceptLanguages << LIT("\r\n");          out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
     }     }
     if (contentLanguages.size() > 0)     if (contentLanguages.size() > 0)
     {     {
         out << LIT("Content-Language: ") << contentLanguages << LIT("\r\n");          out << STRLIT("Content-Language: ") << contentLanguages <<
               STRLIT("\r\n");
     }     }
  
 #ifdef PEGASUS_DEBUG #ifdef PEGASUS_DEBUG
Line 3033 
Line 2984 
                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
 #endif #endif
                         out << LIT("TE: chunked, trailers\r\n");      out << STRLIT("TE: chunked, trailers\r\n");
  
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << LIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");          out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
         out << nn << LIT("\r\n");          out << nn << STRLIT("\r\n");
         out << nn << LIT("-CIMExport: MethodRequest\r\n");          out << nn << STRLIT("-CIMExport: MethodRequest\r\n");
         out << nn << LIT("-CIMExportMethod: ") << cimMethod << LIT("\r\n");          out << nn << STRLIT("-CIMExportMethod: ") << cimMethod <<
               STRLIT("\r\n");
     }     }
     else     else
     {     {
         out << LIT("CIMExport: MethodRequest\r\n");          out << STRLIT("CIMExport: MethodRequest\r\n");
         out << LIT("CIMExportMethod: ") << cimMethod << LIT("\r\n");          out << STRLIT("CIMExportMethod: ") << cimMethod << STRLIT("\r\n");
     }     }
  
     if (authenticationHeader.size())     if (authenticationHeader.size())
     {     {
         out << authenticationHeader << LIT("\r\n");          out << authenticationHeader << STRLIT("\r\n");
     }     }
  
     out << LIT("\r\n");      out << STRLIT("\r\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3067 
Line 3019 
 void XmlWriter::appendEMethodResponseHeader( void XmlWriter::appendEMethodResponseHeader(
     Buffer& out,     Buffer& out,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages& contentLanguages,      const ContentLanguageList& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     out << LIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");      out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");
     out << LIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");      out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
     OUTPUT_CONTENTLENGTH;     OUTPUT_CONTENTLENGTH;
  
     if (contentLanguages.size() > 0)     if (contentLanguages.size() > 0)
     {     {
         out << LIT("Content-Language: ") << contentLanguages << LIT("\r\n");          out << STRLIT("Content-Language: ") << contentLanguages <<
               STRLIT("\r\n");
     }     }
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << LIT("Ext:\r\n");          out << STRLIT("Ext:\r\n");
         out << LIT("Cache-Control: no-cache\r\n");          out << STRLIT("Cache-Control: no-cache\r\n");
         out << LIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");          out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
         out << nn << LIT("\r\n");          out << nn << STRLIT("\r\n");
         out << nn << LIT("-CIMExport: MethodResponse\r\n\r\n");          out << nn << STRLIT("-CIMExport: MethodResponse\r\n\r\n");
     }     }
     else     else
     {     {
         out << LIT("CIMExport: MethodResponse\r\n\r\n");          out << STRLIT("CIMExport: MethodResponse\r\n\r\n");
     }     }
 } }
  
Line 3106 
Line 3059 
 void XmlWriter::_appendSimpleExportReqElementBegin( void XmlWriter::_appendSimpleExportReqElementBegin(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("<SIMPLEEXPREQ>\n");      out << STRLIT("<SIMPLEEXPREQ>\n");
 } }
  
 void XmlWriter::_appendSimpleExportReqElementEnd( void XmlWriter::_appendSimpleExportReqElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</SIMPLEEXPREQ>\n");      out << STRLIT("</SIMPLEEXPREQ>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3129 
Line 3082 
     Buffer& out,     Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << LIT("<EXPMETHODCALL NAME=\"") << name << LIT("\">\n");      out << STRLIT("<EXPMETHODCALL NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendEMethodCallElementEnd( void XmlWriter::_appendEMethodCallElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</EXPMETHODCALL>\n");      out << STRLIT("</EXPMETHODCALL>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3153 
Line 3106 
     Buffer& out,     Buffer& out,
     const char* name)     const char* name)
 { {
     out << LIT("<EXPPARAMVALUE NAME=\"") << name << LIT("\">\n");      out << STRLIT("<EXPPARAMVALUE NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendEParamValueElementEnd( void XmlWriter::_appendEParamValueElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</EXPPARAMVALUE>\n");      out << STRLIT("</EXPPARAMVALUE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3190 
Line 3143 
 void XmlWriter::_appendSimpleExportRspElementBegin( void XmlWriter::_appendSimpleExportRspElementBegin(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("<SIMPLEEXPRSP>\n");      out << STRLIT("<SIMPLEEXPRSP>\n");
 } }
  
 void XmlWriter::_appendSimpleExportRspElementEnd( void XmlWriter::_appendSimpleExportRspElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</SIMPLEEXPRSP>\n");      out << STRLIT("</SIMPLEEXPRSP>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3213 
Line 3166 
     Buffer& out,     Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << LIT("<EXPMETHODRESPONSE NAME=\"") << name << LIT("\">\n");      out << STRLIT("<EXPMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");
 } }
  
 void XmlWriter::_appendEMethodResponseElementEnd( void XmlWriter::_appendEMethodResponseElementEnd(
     Buffer& out)     Buffer& out)
 { {
     out << LIT("</EXPMETHODRESPONSE>\n");      out << STRLIT("</EXPMETHODRESPONSE>\n");
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3235 
Line 3188 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,      const AcceptLanguageList& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,      const ContentLanguageList& httpContentLanguages,
     const Buffer& body)     const Buffer& body)
 { {
     Buffer out;     Buffer out;
Line 3259 
Line 3212 
         authenticationHeader,         authenticationHeader,
         httpAcceptLanguages,         httpAcceptLanguages,
         httpContentLanguages,         httpContentLanguages,
         out.size());          (Uint32)out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 3275 
Line 3228 
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages& httpContentLanguages,      const ContentLanguageList& httpContentLanguages,
     const Buffer& body)     const Buffer& body)
 { {
     Buffer out;     Buffer out;
Line 3292 
Line 3245 
     appendEMethodResponseHeader(tmp,     appendEMethodResponseHeader(tmp,
         httpMethod,         httpMethod,
         httpContentLanguages,         httpContentLanguages,
         out.size());          (Uint32)out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 3321 
Line 3274 
     _appendSimpleExportRspElementEnd(out);     _appendSimpleExportRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
 // l10n      appendEMethodResponseHeader(
     appendEMethodResponseHeader(tmp,          tmp,
          httpMethod,          httpMethod,
          cimException.getContentLanguages(),          cimException.getContentLanguages(),
                  out.size());          (Uint32)out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 3361 
Line 3314 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void _xmlWritter_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 3395 
Line 3351 
                 _xmlWritter_indent(os, stack.size(), indentChars);                 _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<?" << entry.text << " ";                 os << "<?" << entry.text << " ";
                 _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(
                       os, entry.attributes, entry.attributeCount);
                 os << "?>";                 os << "?>";
                 break;                 break;
             }             }
Line 3409 
Line 3366 
                 if (entry.attributeCount)                 if (entry.attributeCount)
                     os << ' ';                     os << ' ';
  
                 _xmlWritter_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 3420 
Line 3378 
                 _xmlWritter_indent(os, stack.size(), indentChars);                 _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text << " ";                 os << "<" << entry.text << " ";
                 _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(
                       os, entry.attributes, entry.attributeCount);
                 os << "/>";                 os << "/>";
                 break;                 break;
             }             }
Line 3438 
Line 3397 
  
             case XmlEntry::COMMENT:             case XmlEntry::COMMENT:
             {             {
   
                 _xmlWritter_indent(os, stack.size(), indentChars);                 _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<!--";                 os << "<!--";
                 _xmlWritter_appendSpecial(os, entry.text);                 _xmlWritter_appendSpecial(os, entry.text);
Line 3456 
Line 3414 
             case XmlEntry::CDATA:             case XmlEntry::CDATA:
             {             {
                 _xmlWritter_indent(os, stack.size(), indentChars);                 _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<![CDATA[...]]>";                  os << "<![CDATA[" << entry.text << "]]>";
                 break;                 break;
             }             }
  
Line 3470 
Line 3428 
  
         os << PEGASUS_STD(endl);         os << PEGASUS_STD(endl);
     }     }
   
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3479 
Line 3436 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
   static IDFactory _messageIDFactory(1000);
   
 String XmlWriter::getNextMessageId() String XmlWriter::getNextMessageId()
 { {
     // ATTN: make thread-safe:  
     static Uint32 messageId = 1000;  
   
     messageId++;  
   
     if (messageId < 1000)  
         messageId = 1001;  
   
     char buffer[16];     char buffer[16];
     sprintf(buffer, "%d", messageId);      sprintf(buffer, "%u", _messageIDFactory.getID());
     return buffer;     return buffer;
 } }
  
Line 3521 
Line 3472 
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   
   

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