version 1.146, 2006/11/10 18:14:59
|
version 1.157.4.1, 2008/07/01 15:18:03
|
|
|
#include "CIMQualifierDeclRep.h" | #include "CIMQualifierDeclRep.h" |
#include "CIMValue.h" | #include "CIMValue.h" |
#include "XmlWriter.h" | #include "XmlWriter.h" |
#include "XmlParser.h" |
|
#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 "Buffer.h" |
#include "StrLit.h" | #include "StrLit.h" |
#include "LanguageParser.h" |
|
#include "IDFactory.h" | #include "IDFactory.h" |
|
#include "StringConversion.h" |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
// 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]; \ |
|
int n = sprintf(contentLengthP,"%.10u", contentLength); \ |
|
out << STRLIT("content-length: "); \ |
|
out.append(contentLengthP, n); \ |
|
out << STRLIT("\r\n"); \ |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// SpecialChar and table. |
|
// |
|
//////////////////////////////////////////////////////////////////////////////// |
|
|
|
// Note: we cannot use StrLit here since it has a constructur (forbits |
|
// structure initialization). |
|
|
|
struct SpecialChar |
|
{ |
|
const char* str; |
|
size_t size; |
|
}; |
|
|
|
// Defines encodings of special characters. Just use a 7-bit ASCII character |
|
// as an index into this array to retrieve its string encoding and encoding |
|
// length in bytes. |
|
static const SpecialChar _specialChars[] = |
|
{ |
|
{STRLIT_ARGS("�")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("	")}, |
|
{STRLIT_ARGS(" ")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS(" ")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS("")}, |
|
{STRLIT_ARGS(" ")}, |
|
{STRLIT_ARGS("!")}, |
|
{STRLIT_ARGS(""")}, |
|
{STRLIT_ARGS("#")}, |
|
{STRLIT_ARGS("$")}, |
|
{STRLIT_ARGS("%")}, |
|
{STRLIT_ARGS("&")}, |
|
{STRLIT_ARGS("'")}, |
|
{STRLIT_ARGS("(")}, |
|
{STRLIT_ARGS(")")}, |
|
{STRLIT_ARGS("*")}, |
|
{STRLIT_ARGS("+")}, |
|
{STRLIT_ARGS(",")}, |
|
{STRLIT_ARGS("-")}, |
|
{STRLIT_ARGS(".")}, |
|
{STRLIT_ARGS("/")}, |
|
{STRLIT_ARGS("0")}, |
|
{STRLIT_ARGS("1")}, |
|
{STRLIT_ARGS("2")}, |
|
{STRLIT_ARGS("3")}, |
|
{STRLIT_ARGS("4")}, |
|
{STRLIT_ARGS("5")}, |
|
{STRLIT_ARGS("6")}, |
|
{STRLIT_ARGS("7")}, |
|
{STRLIT_ARGS("8")}, |
|
{STRLIT_ARGS("9")}, |
|
{STRLIT_ARGS(":")}, |
|
{STRLIT_ARGS(";")}, |
|
{STRLIT_ARGS("<")}, |
|
{STRLIT_ARGS("=")}, |
|
{STRLIT_ARGS(">")}, |
|
{STRLIT_ARGS("?")}, |
|
{STRLIT_ARGS("@")}, |
|
{STRLIT_ARGS("A")}, |
|
{STRLIT_ARGS("B")}, |
|
{STRLIT_ARGS("C")}, |
|
{STRLIT_ARGS("D")}, |
|
{STRLIT_ARGS("E")}, |
|
{STRLIT_ARGS("F")}, |
|
{STRLIT_ARGS("G")}, |
|
{STRLIT_ARGS("H")}, |
|
{STRLIT_ARGS("I")}, |
|
{STRLIT_ARGS("J")}, |
|
{STRLIT_ARGS("K")}, |
|
{STRLIT_ARGS("L")}, |
|
{STRLIT_ARGS("M")}, |
|
{STRLIT_ARGS("N")}, |
|
{STRLIT_ARGS("O")}, |
|
{STRLIT_ARGS("P")}, |
|
{STRLIT_ARGS("Q")}, |
|
{STRLIT_ARGS("R")}, |
|
{STRLIT_ARGS("S")}, |
|
{STRLIT_ARGS("T")}, |
|
{STRLIT_ARGS("U")}, |
|
{STRLIT_ARGS("V")}, |
|
{STRLIT_ARGS("W")}, |
|
{STRLIT_ARGS("X")}, |
|
{STRLIT_ARGS("Y")}, |
|
{STRLIT_ARGS("Z")}, |
|
{STRLIT_ARGS("[")}, |
|
{STRLIT_ARGS("\\")}, |
|
{STRLIT_ARGS("]")}, |
|
{STRLIT_ARGS("^")}, |
|
{STRLIT_ARGS("_")}, |
|
{STRLIT_ARGS("`")}, |
|
{STRLIT_ARGS("a")}, |
|
{STRLIT_ARGS("b")}, |
|
{STRLIT_ARGS("c")}, |
|
{STRLIT_ARGS("d")}, |
|
{STRLIT_ARGS("e")}, |
|
{STRLIT_ARGS("f")}, |
|
{STRLIT_ARGS("g")}, |
|
{STRLIT_ARGS("h")}, |
|
{STRLIT_ARGS("i")}, |
|
{STRLIT_ARGS("j")}, |
|
{STRLIT_ARGS("k")}, |
|
{STRLIT_ARGS("l")}, |
|
{STRLIT_ARGS("m")}, |
|
{STRLIT_ARGS("n")}, |
|
{STRLIT_ARGS("o")}, |
|
{STRLIT_ARGS("p")}, |
|
{STRLIT_ARGS("q")}, |
|
{STRLIT_ARGS("r")}, |
|
{STRLIT_ARGS("s")}, |
|
{STRLIT_ARGS("t")}, |
|
{STRLIT_ARGS("u")}, |
|
{STRLIT_ARGS("v")}, |
|
{STRLIT_ARGS("w")}, |
|
{STRLIT_ARGS("x")}, |
|
{STRLIT_ARGS("y")}, |
|
{STRLIT_ARGS("z")}, |
|
{STRLIT_ARGS("{")}, |
|
{STRLIT_ARGS("|")}, |
|
{STRLIT_ARGS("}")}, |
|
{STRLIT_ARGS("~")}, |
|
{STRLIT_ARGS("")}, |
|
}; |
|
|
|
// If _isSpecialChar7[ch] is true, then ch is a special character, which must |
|
// have a special encoding in XML. But only use 7-bit ASCII characters to |
|
// index this array. |
|
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, |
|
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,1, |
|
}; |
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
|
|
Buffer& operator<<(Buffer& out, const Char16& x) |
|
{ |
|
XmlWriter::append(out, x); |
|
return out; |
|
} |
|
|
|
Buffer& operator<<(Buffer& out, const String& x) |
|
{ |
|
XmlWriter::append(out, x); |
|
return out; |
|
} |
|
|
|
Buffer& operator<<(Buffer& out, const Indentor& x) |
|
{ |
|
XmlWriter::append(out, x); |
|
return out; |
|
} |
|
|
|
Buffer& operator<<(Buffer& out, const Buffer& x) |
|
{ |
|
out.append(x.getData(), x.size()); |
|
return out; |
|
} |
|
|
|
Buffer& operator<<(Buffer& out, Uint32 x) |
|
{ |
|
XmlWriter::append(out, x); |
|
return out; |
|
} |
|
|
|
Buffer& operator<<(Buffer& out, const CIMName& name) |
|
{ |
|
XmlWriter::append(out, name.getString ()); |
|
return out; |
|
} |
|
|
|
|
|
Buffer& operator<<(Buffer& out, const AcceptLanguageList& al) |
|
{ |
|
XmlWriter::append(out, LanguageParser::buildAcceptLanguageHeader(al)); |
|
return out; |
|
} |
|
|
|
Buffer& operator<<(Buffer& out, const ContentLanguageList& cl) |
|
{ |
|
XmlWriter::append(out, LanguageParser::buildContentLanguageHeader(cl)); |
|
return out; |
|
} |
|
|
|
|
|
PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x) |
|
{ |
|
return os << x.toString(); |
|
} |
|
|
|
PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMName& name) |
|
{ |
|
os << name.getString(); |
|
return os; |
|
} |
|
|
|
PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, |
|
const CIMNamespaceName& name) |
|
{ |
|
os << name.getString(); |
|
return os; |
|
} |
|
|
|
static 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 _appendSpecialChar7(Buffer& out, char c) |
|
{ |
|
if (_isSpecialChar7[int(c)]) |
|
out.append(_specialChars[int(c)].str, _specialChars[int(c)].size); |
|
else |
|
out.append(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) ) |
|
{ |
|
char charref[7]; |
|
sprintf(charref, "&#%u;", static_cast<Uint8>(c)); |
|
os << charref; |
|
} |
|
else |
|
{ |
|
switch (c) |
|
{ |
|
case '&': |
|
os << "&"; |
|
break; |
|
|
|
case '<': |
|
os << "<"; |
|
break; |
|
|
|
case '>': |
|
os << ">"; |
|
break; |
|
|
|
case '"': |
|
os << """; |
|
break; |
|
|
|
case '\'': |
|
os << "'"; |
|
break; |
|
|
|
default: |
|
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); |
|
} |
|
|
|
inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str) |
|
{ |
|
while (*str) |
|
_xmlWritter_appendSpecialChar(os, *str++); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, const Char16& x) |
|
{ |
|
_xmlWritter_appendChar(out, x); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, Boolean x) |
|
{ |
|
append(out, (x ? "TRUE" : "FALSE")); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, Uint32 x) |
|
{ |
|
char buffer[32]; |
|
sprintf(buffer, "%u", x); |
|
append(out, buffer); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, Sint32 x) |
|
{ |
|
char buffer[32]; |
|
sprintf(buffer, "%d", x); |
|
append(out, buffer); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, Uint64 x) |
|
{ |
|
char buffer[32]; // Should need 21 chars max |
|
sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x); |
|
append(out, buffer); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, Sint64 x) |
|
{ |
|
char buffer[32]; // Should need 21 chars max |
|
sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x); |
|
append(out, buffer); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, Real32 x) |
|
{ |
|
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); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, Real64 x) |
|
{ |
|
char buffer[128]; |
|
// %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible |
|
// with the format 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); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, const char* str) |
|
{ |
|
size_t n = strlen(str); |
|
out.append(str, n); |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, const String& str) |
|
{ |
|
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) |
|
{ |
|
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)) || |
|
((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_appendChar(out, c); |
|
} |
|
} |
|
} |
|
|
|
void XmlWriter::append(Buffer& out, const Indentor& x) |
|
{ |
|
for (Uint32 i = 0; i < 4 * x.getLevel(); i++) |
|
out.append(' '); |
|
} |
|
|
|
void XmlWriter::appendSpecial(Buffer& out, const Char16& x) |
|
{ |
|
_xmlWritter_appendSpecialChar(out, x); |
|
} |
|
|
|
void XmlWriter::appendSpecial(Buffer& out, char x) |
|
{ |
|
_appendSpecialChar7(out, x); |
|
} |
|
|
|
void XmlWriter::appendSpecial(Buffer& out, const char* str) |
|
{ |
|
while (*str) |
|
_appendSpecialChar7(out, *str++); |
|
} |
|
|
|
void XmlWriter::appendSpecial(Buffer& out, const String& str) |
|
{ |
|
const Uint16* p = (const Uint16*)str.getChar16Data(); |
|
// prevCharIsSpace is true when the last character written to the Buffer |
|
// is a space character (not a character reference). |
|
Boolean prevCharIsSpace = false; |
|
|
|
// If the first character is a space, use a character reference to avoid |
|
// space compression. |
|
if (*p == ' ') |
|
{ |
|
out.append(STRLIT_ARGS(" ")); |
|
p++; |
|
} |
|
|
|
Uint16 c; |
|
while ((c = *p++) != 0) |
|
{ |
|
if (c < 128) |
|
{ |
|
if (_isSpecialChar7[c]) |
|
{ |
|
// Write the character reference for the special character |
|
out.append( |
|
_specialChars[int(c)].str, _specialChars[int(c)].size); |
|
prevCharIsSpace = false; |
|
} |
|
else if (prevCharIsSpace && (c == ' ')) |
|
{ |
|
// Write the character reference for the space character, to |
|
// avoid compression |
|
out.append(STRLIT_ARGS(" ")); |
|
prevCharIsSpace = false; |
|
} |
|
else |
|
{ |
|
out.append(c); |
|
prevCharIsSpace = (c == ' '); |
|
} |
|
} |
|
else |
|
{ |
|
// Handle UTF8 case |
|
|
|
if ((((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) || |
|
((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE))) && |
|
*p) |
|
{ |
|
_xmlWritter_appendSurrogatePair(out, c, *p++); |
|
} |
|
else |
|
{ |
|
_xmlWritter_appendChar(out, c); |
|
} |
|
|
|
prevCharIsSpace = false; |
|
} |
|
} |
|
|
|
// If the last character is a space, use a character reference to avoid |
|
// space compression. |
|
if (prevCharIsSpace) |
|
{ |
|
out.remove(out.size() - 1); |
|
out.append(STRLIT_ARGS(" ")); |
|
} |
|
} |
|
|
|
// See http://www.ietf.org/rfc/rfc2396.txt section 2 |
|
// Reserved characters = ';' '/' '?' ':' '@' '&' '=' '+' '$' ',' |
|
// Excluded characters: |
|
// Control characters = 0x00-0x1f, 0x7f |
|
// Space character = 0x20 |
|
// Delimiters = '<' '>' '#' '%' '"' |
|
// Unwise = '{' '}' '|' '\\' '^' '[' ']' '`' |
|
// |
|
|
|
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; |
|
|
|
#ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING |
|
if (c > 127 || _is_uri[int(c)]) |
|
{ |
|
char hexencoding[4]; |
|
int n = 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); |
|
#endif /* PEGASUS_USE_STRING_EXTENSIONS */ |
|
} |
|
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() |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendValueElement(tmp, value); | appendValueElement(tmp, value); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendValueReferenceElement(tmp, reference, true); | appendValueReferenceElement(tmp, reference, true); |
tmp.append('\0'); |
|
indentedPrint(os, tmp.getData()); | indentedPrint(os, tmp.getData()); |
} | } |
| |
|
|
| |
void XmlWriter::appendClassElement( | void XmlWriter::appendClassElement( |
Buffer& out, | Buffer& out, |
const CIMConstClass& cimclass) |
const CIMConstClass& cimClass) |
|
{ |
|
CheckRep(cimClass._rep); |
|
const CIMClassRep* rep = cimClass._rep; |
|
|
|
// Class opening element: |
|
|
|
out << STRLIT("<CLASS NAME=\"") |
|
<< rep->getClassName() |
|
<< STRLIT("\" "); |
|
|
|
if (!rep->getSuperClassName().isNull()) |
{ | { |
cimclass._checkRep(); |
out << STRLIT(" SUPERCLASS=\"") |
cimclass._rep->toXml(out); |
<< rep->getSuperClassName() |
|
<< STRLIT("\" "); |
|
} |
|
|
|
out << STRLIT(">\n"); |
|
|
|
// Append Class Qualifiers: |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
// Append Property definitions: |
|
|
|
for (Uint32 i = 0, n = rep->getPropertyCount(); i < n; i++) |
|
XmlWriter::appendPropertyElement(out, rep->getProperty(i)); |
|
|
|
// Append Method definitions: |
|
|
|
for (Uint32 i = 0, n = rep->getMethodCount(); i < n; i++) |
|
XmlWriter::appendMethodElement(out, rep->getMethod(i)); |
|
|
|
// Class closing element: |
|
|
|
out << STRLIT("</CLASS>\n"); |
} | } |
| |
void XmlWriter::printClassElement( | void XmlWriter::printClassElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendClassElement(tmp, cimclass); | appendClassElement(tmp, cimclass); |
tmp.append('\0'); |
|
indentedPrint(os, tmp.getData(), 4); | indentedPrint(os, tmp.getData(), 4); |
} | } |
| |
|
|
Buffer& out, | Buffer& out, |
const CIMConstInstance& instance) | const CIMConstInstance& instance) |
{ | { |
instance._checkRep(); |
CheckRep(instance._rep); |
instance._rep->toXml(out); |
const CIMInstanceRep* rep = instance._rep; |
|
|
|
// Class opening element: |
|
|
|
out << STRLIT("<INSTANCE CLASSNAME=\"") |
|
<< rep->getClassName() |
|
<< STRLIT("\" >\n"); |
|
|
|
// Append Instance Qualifiers: |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
// Append Properties: |
|
|
|
for (Uint32 i = 0, n = rep->getPropertyCount(); i < n; i++) |
|
XmlWriter::appendPropertyElement(out, rep->getProperty(i)); |
|
|
|
// Instance closing element: |
|
|
|
out << STRLIT("</INSTANCE>\n"); |
} | } |
| |
void XmlWriter::printInstanceElement( | void XmlWriter::printInstanceElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendInstanceElement(tmp, instance); | appendInstanceElement(tmp, instance); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
CIMConstClass c(object); | CIMConstClass c(object); |
appendClassElement(out, c); | appendClassElement(out, c); |
} | } |
else if (object.isInstance()) |
else if (object.isInstance()) |
|
{ |
|
CIMConstInstance i(object); |
|
appendInstanceElement(out, i); |
|
} |
|
// else PEGASUS_ASSERT(0); |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// appendPropertyElement() |
|
// |
|
// <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)> |
|
// <!ATTLIST PROPERTY |
|
// %CIMName; |
|
// %CIMType; #REQUIRED |
|
// %ClassOrigin; |
|
// %Propagated;> |
|
// |
|
// <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)> |
|
// <!ATTLIST PROPERTY.ARRAY |
|
// %CIMName; |
|
// %CIMType; #REQUIRED |
|
// %ArraySize; |
|
// %ClassOrigin; |
|
// %Propagated;> |
|
// |
|
// <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)> |
|
// <!ATTLIST PROPERTY.REFERENCE |
|
// %CIMName; |
|
// %ReferenceClass; |
|
// %ClassOrigin; |
|
// %Propagated;> |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void XmlWriter::appendPropertyElement( |
|
Buffer& out, |
|
const CIMConstProperty& property) |
|
{ |
|
CheckRep(property._rep); |
|
const CIMPropertyRep* rep = property._rep; |
|
|
|
if (rep->getValue().isArray()) |
|
{ |
|
out << STRLIT("<PROPERTY.ARRAY NAME=\"") |
|
<< rep->getName() |
|
<< STRLIT("\" "); |
|
|
|
if (rep->getValue().getType() == CIMTYPE_OBJECT) |
|
{ |
|
// If the property array type is CIMObject, then |
|
// encode the property in CIM-XML as a string array with the |
|
// EmbeddedObject attribute (there is not currently a CIM-XML |
|
// "object" datatype) |
|
|
|
Array<CIMObject> a; |
|
rep->getValue().get(a); |
|
out << STRLIT(" TYPE=\"string\""); |
|
// If the Embedded Object is an instance, always add the |
|
// EmbeddedObject attribute. |
|
if (a.size() > 0 && a[0].isInstance()) |
|
{ |
|
out << STRLIT(" EmbeddedObject=\"object\""); |
|
out << STRLIT(" EMBEDDEDOBJECT=\"object\""); |
|
} |
|
#ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY |
|
else |
|
#endif |
|
{ |
|
// Else the Embedded Object is a class, always add the |
|
// EmbeddedObject qualifier. Note that if the macro |
|
// PEGASUS_SNIA_INTEROP_COMPATIBILITY is defined, then |
|
// the EmbeddedObject qualifier will always be added, |
|
// whether it's a class or an instance. |
|
if (rep->findQualifier(CIMName("EmbeddedObject")) == |
|
PEG_NOT_FOUND) |
|
{ |
|
// Note that addQualifiers() cannot be called on a const |
|
// CIMQualifierRep. In this case we really do want to add |
|
// the EmbeddedObject qualifier, so we cast away the |
|
// constness. |
|
CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep); |
|
tmpRep->addQualifier( |
|
CIMQualifier(CIMName("EmbeddedObject"), true)); |
|
} |
|
} |
|
} |
|
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else if (rep->getValue().getType() == CIMTYPE_INSTANCE) |
|
{ |
|
// If the property array type is CIMInstance, then |
|
// encode the property in CIM-XML as a string array with the |
|
// EmbeddedObject attribute (there is not currently a CIM-XML |
|
// "instance" datatype) |
|
|
|
Array<CIMInstance> a; |
|
rep->getValue().get(a); |
|
out << STRLIT(" TYPE=\"string\""); |
|
|
|
// add the EmbeddedObject attribute |
|
if (a.size() > 0) |
|
{ |
|
out << STRLIT(" EmbeddedObject=\"instance\""); |
|
out << STRLIT(" EMBEDDEDOBJECT=\"instance\""); |
|
|
|
// Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY is |
|
// defined, then the EmbeddedInstance qualifier will be added |
|
# ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY |
|
if (rep->findQualifier(CIMName("EmbeddedInstance")) == |
|
PEG_NOT_FOUND) |
|
{ |
|
// Note that addQualifiers() cannot be called on a const |
|
// CIMQualifierRep. In this case we really do want to add |
|
// the EmbeddedInstance qualifier, so we cast away the |
|
// constness. |
|
|
|
// For now, we assume that all the embedded instances in |
|
// the array are of the same type |
|
CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep); |
|
tmpRep->addQualifier(CIMQualifier( |
|
CIMName("EmbeddedInstance"), |
|
a[0].getClassName().getString())); |
|
} |
|
# endif |
|
} |
|
} |
|
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else |
|
{ |
|
out << STRLIT(" TYPE=\"") |
|
<< cimTypeToString(rep->getValue().getType()); |
|
out.append('"'); |
|
} |
|
|
|
if (rep->getArraySize()) |
|
{ |
|
char buffer[32]; |
|
sprintf(buffer, "%u", rep->getArraySize()); |
|
out << STRLIT(" ARRAYSIZE=\"") << buffer; |
|
out.append('"'); |
|
} |
|
|
|
if (!rep->getClassOrigin().isNull()) |
|
{ |
|
out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin(); |
|
out.append('"'); |
|
} |
|
|
|
if (rep->getPropagated()) |
|
{ |
|
out << STRLIT(" PROPAGATED=\"true\""); |
|
} |
|
|
|
out << STRLIT(">\n"); |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
XmlWriter::appendValueElement(out, rep->getValue()); |
|
|
|
out << STRLIT("</PROPERTY.ARRAY>\n"); |
|
} |
|
else if (rep->getValue().getType() == CIMTYPE_REFERENCE) |
|
{ |
|
out << STRLIT("<PROPERTY.REFERENCE"); |
|
|
|
out << STRLIT(" NAME=\"") << rep->getName() << STRLIT("\" "); |
|
|
|
if (!rep->getReferenceClassName().isNull()) |
|
{ |
|
out << STRLIT(" REFERENCECLASS=\"") << rep->getReferenceClassName(); |
|
out.append('"'); |
|
} |
|
|
|
if (!rep->getClassOrigin().isNull()) |
|
{ |
|
out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin(); |
|
out.append('"'); |
|
} |
|
|
|
if (rep->getPropagated()) |
|
{ |
|
out << STRLIT(" PROPAGATED=\"true\""); |
|
} |
|
|
|
out << STRLIT(">\n"); |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
XmlWriter::appendValueElement(out, rep->getValue()); |
|
|
|
out << STRLIT("</PROPERTY.REFERENCE>\n"); |
|
} |
|
else |
|
{ |
|
out << STRLIT("<PROPERTY NAME=\"") << rep->getName() << STRLIT("\" "); |
|
|
|
if (!rep->getClassOrigin().isNull()) |
|
{ |
|
out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin(); |
|
out.append('"'); |
|
} |
|
|
|
if (rep->getPropagated()) |
|
{ |
|
out << STRLIT(" PROPAGATED=\"true\""); |
|
} |
|
|
|
if (rep->getValue().getType() == CIMTYPE_OBJECT) |
|
{ |
|
// 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) |
|
|
|
CIMObject a; |
|
rep->getValue().get(a); |
|
out << STRLIT(" TYPE=\"string\""); |
|
|
|
// If the Embedded Object is an instance, always add the |
|
// EmbeddedObject attribute. |
|
if (a.isInstance()) |
|
{ |
|
out << STRLIT(" EmbeddedObject=\"object\""); |
|
out << STRLIT(" EMBEDDEDOBJECT=\"object\""); |
|
} |
|
// Else the Embedded Object is a class, always add the |
|
// EmbeddedObject qualifier. |
|
#ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY |
|
else |
|
#endif |
|
{ |
|
// Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY |
|
// is defined, then the EmbeddedObject qualifier will always |
|
// be added, whether it's a class or an instance. |
|
if (rep->findQualifier(CIMName("EmbeddedObject")) == |
|
PEG_NOT_FOUND) |
|
{ |
|
// Note that addQualifiers() cannot be called on a const |
|
// CIMQualifierRep. In this case we really do want to add |
|
// the EmbeddedObject qualifier, so we cast away the |
|
// constness. |
|
CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep); |
|
tmpRep->addQualifier( |
|
CIMQualifier(CIMName("EmbeddedObject"), true)); |
|
} |
|
} |
|
} |
|
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else if (rep->getValue().getType() == CIMTYPE_INSTANCE) |
{ | { |
CIMConstInstance i(object); |
CIMInstance a; |
appendInstanceElement(out, i); |
rep->getValue().get(a); |
|
out << " TYPE=\"string\""; |
|
out << " EmbeddedObject=\"instance\""; |
|
out << " EMBEDDEDOBJECT=\"instance\""; |
|
|
|
# ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY |
|
if (rep->findQualifier(CIMName("EmbeddedObject")) == PEG_NOT_FOUND) |
|
{ |
|
// Note that addQualifiers() cannot be called on a const |
|
// CIMQualifierRep. In this case we really do want to add |
|
// the EmbeddedInstance qualifier, so we cast away the |
|
// constness. |
|
CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep); |
|
tmpRep->addQualifier(CIMQualifier( |
|
CIMName("EmbeddedInstance"), |
|
a.getClassName().getString())); |
} | } |
// else PEGASUS_ASSERT(0); |
# endif |
|
} |
|
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
else |
|
{ |
|
out << STRLIT(" TYPE=\"") |
|
<< cimTypeToString(rep->getValue().getType()); |
|
out.append('"'); |
} | } |
| |
//------------------------------------------------------------------------------ |
out << STRLIT(">\n"); |
// |
|
// appendPropertyElement() |
|
// |
|
// <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)> |
|
// <!ATTLIST PROPERTY |
|
// %CIMName; |
|
// %CIMType; #REQUIRED |
|
// %ClassOrigin; |
|
// %Propagated;> |
|
// |
|
// <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)> |
|
// <!ATTLIST PROPERTY.ARRAY |
|
// %CIMName; |
|
// %CIMType; #REQUIRED |
|
// %ArraySize; |
|
// %ClassOrigin; |
|
// %Propagated;> |
|
// |
|
// <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)> |
|
// <!ATTLIST PROPERTY.REFERENCE |
|
// %CIMName; |
|
// %ReferenceClass; |
|
// %ClassOrigin; |
|
// %Propagated;> |
|
// |
|
//------------------------------------------------------------------------------ |
|
| |
void XmlWriter::appendPropertyElement( |
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
Buffer& out, |
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
const CIMConstProperty& property) |
|
{ |
XmlWriter::appendValueElement(out, rep->getValue()); |
property._checkRep(); |
|
property._rep->toXml(out); |
out << STRLIT("</PROPERTY>\n"); |
|
} |
} | } |
| |
void XmlWriter::printPropertyElement( | void XmlWriter::printPropertyElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendPropertyElement(tmp, property); | appendPropertyElement(tmp, property); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
Buffer& out, | Buffer& out, |
const CIMConstMethod& method) | const CIMConstMethod& method) |
{ | { |
method._checkRep(); |
CheckRep(method._rep); |
method._rep->toXml(out); |
const CIMMethodRep* rep = method._rep; |
|
|
|
out << STRLIT("<METHOD NAME=\"") << rep->getName(); |
|
out.append('"'); |
|
|
|
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getType()); |
|
out.append('"'); |
|
|
|
if (!rep->getClassOrigin().isNull()) |
|
{ |
|
out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin(); |
|
out.append('"'); |
|
} |
|
|
|
if (rep->getPropagated()) |
|
{ |
|
out << STRLIT(" PROPAGATED=\"true\""); |
|
} |
|
|
|
out << STRLIT(">\n"); |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
for (Uint32 i = 0, n = rep->getParameterCount(); i < n; i++) |
|
XmlWriter::appendParameterElement(out, rep->getParameter(i)); |
|
|
|
out << STRLIT("</METHOD>\n"); |
} | } |
| |
void XmlWriter::printMethodElement( | void XmlWriter::printMethodElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendMethodElement(tmp, method); | appendMethodElement(tmp, method); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
Buffer& out, | Buffer& out, |
const CIMConstParameter& parameter) | const CIMConstParameter& parameter) |
{ | { |
parameter._checkRep(); |
CheckRep(parameter._rep); |
parameter._rep->toXml(out); |
const CIMParameterRep* rep = parameter._rep; |
|
|
|
if (rep->isArray()) |
|
{ |
|
if (rep->getType() == CIMTYPE_REFERENCE) |
|
{ |
|
out << STRLIT("<PARAMETER.REFARRAY NAME=\"") << rep->getName(); |
|
out.append('"'); |
|
|
|
if (!rep->getReferenceClassName().isNull()) |
|
{ |
|
out << STRLIT(" REFERENCECLASS=\""); |
|
out << rep->getReferenceClassName().getString(); |
|
out.append('"'); |
|
} |
|
|
|
if (rep->getArraySize()) |
|
{ |
|
char buffer[32]; |
|
int n = sprintf(buffer, "%u", rep->getArraySize()); |
|
out << STRLIT(" ARRAYSIZE=\""); |
|
out.append(buffer, n); |
|
out.append('"'); |
|
} |
|
|
|
out << STRLIT(">\n"); |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
out << STRLIT("</PARAMETER.REFARRAY>\n"); |
|
} |
|
else |
|
{ |
|
out << STRLIT("<PARAMETER.ARRAY"); |
|
out << STRLIT(" NAME=\"") << rep->getName(); |
|
out << STRLIT("\" "); |
|
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getType()); |
|
out.append('"'); |
|
|
|
if (rep->getArraySize()) |
|
{ |
|
char buffer[32]; |
|
sprintf(buffer, "%u", rep->getArraySize()); |
|
out << STRLIT(" ARRAYSIZE=\"") << buffer; |
|
out.append('"'); |
|
} |
|
|
|
out << STRLIT(">\n"); |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
out << STRLIT("</PARAMETER.ARRAY>\n"); |
|
} |
|
} |
|
else if (rep->getType() == CIMTYPE_REFERENCE) |
|
{ |
|
out << STRLIT("<PARAMETER.REFERENCE"); |
|
out << STRLIT(" NAME=\"") << rep->getName(); |
|
out.append('"'); |
|
|
|
if (!rep->getReferenceClassName().isNull()) |
|
{ |
|
out << STRLIT(" REFERENCECLASS=\""); |
|
out << rep->getReferenceClassName().getString(); |
|
out.append('"'); |
|
} |
|
out << STRLIT(">\n"); |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
out << STRLIT("</PARAMETER.REFERENCE>\n"); |
|
} |
|
else |
|
{ |
|
out << STRLIT("<PARAMETER"); |
|
out << STRLIT(" NAME=\"") << rep->getName(); |
|
out << STRLIT("\" "); |
|
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getType()); |
|
out << STRLIT("\">\n"); |
|
|
|
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
|
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
|
|
|
out << STRLIT("</PARAMETER>\n"); |
|
} |
} | } |
| |
void XmlWriter::printParameterElement( | void XmlWriter::printParameterElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendParameterElement(tmp, parameter); | appendParameterElement(tmp, parameter); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
// | // |
// <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?> | // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?> |
// <!ATTLIST PARAMVALUE | // <!ATTLIST PARAMVALUE |
// %CIMName;> |
// %CIMName; |
|
// %EmbeddedObject; #IMPLIED |
|
// %ParamType;> |
// | // |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
| |
|
|
Buffer& out, | Buffer& out, |
const CIMParamValue& paramValue) | const CIMParamValue& paramValue) |
{ | { |
paramValue._checkRep(); |
CheckRep(paramValue._rep); |
paramValue._rep->toXml(out); |
const CIMParamValueRep* rep = paramValue._rep; |
|
|
|
out << STRLIT("<PARAMVALUE NAME=\"") << rep->getParameterName(); |
|
out.append('"'); |
|
|
|
CIMType type = rep->getValue().getType(); |
|
|
|
if (rep->isTyped()) |
|
{ |
|
XmlWriter::appendParamTypeAndEmbeddedObjAttrib(out, type); |
|
} |
|
|
|
out << STRLIT(">\n"); |
|
XmlWriter::appendValueElement(out, rep->getValue()); |
|
|
|
out << STRLIT("</PARAMVALUE>\n"); |
} | } |
| |
void XmlWriter::printParamValueElement( | void XmlWriter::printParamValueElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendParamValueElement(tmp, paramValue); | appendParamValueElement(tmp, paramValue); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
Buffer& out, | Buffer& out, |
const CIMConstQualifier& qualifier) | const CIMConstQualifier& qualifier) |
{ | { |
qualifier._checkRep(); |
CheckRep(qualifier._rep); |
qualifier._rep->toXml(out); |
const CIMQualifierRep* rep = qualifier._rep; |
|
|
|
out << STRLIT("<QUALIFIER NAME=\"") << rep->getName(); |
|
out.append('"'); |
|
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getValue().getType()); |
|
out.append('"'); |
|
|
|
if (rep->getPropagated()) |
|
{ |
|
out << STRLIT(" PROPAGATED=\"true\""); |
|
} |
|
|
|
XmlWriter::appendQualifierFlavorEntity(out, rep->getFlavor()); |
|
|
|
out << STRLIT(">\n"); |
|
|
|
XmlWriter::appendValueElement(out, rep->getValue()); |
|
|
|
out << STRLIT("</QUALIFIER>\n"); |
} | } |
| |
void XmlWriter::printQualifierElement( | void XmlWriter::printQualifierElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendQualifierElement(tmp, qualifier); | appendQualifierElement(tmp, qualifier); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
Buffer& out, | Buffer& out, |
const CIMConstQualifierDecl& qualifierDecl) | const CIMConstQualifierDecl& qualifierDecl) |
{ | { |
qualifierDecl._checkRep(); |
CheckRep(qualifierDecl._rep); |
qualifierDecl._rep->toXml(out); |
const CIMQualifierDeclRep* rep = qualifierDecl._rep; |
|
|
|
out << STRLIT("<QUALIFIER.DECLARATION NAME=\"") << rep->getName(); |
|
out.append('"'); |
|
out << STRLIT(" TYPE=\"") << cimTypeToString(rep->getValue().getType()); |
|
out.append('"'); |
|
|
|
if (rep->getValue().isArray()) |
|
{ |
|
out << STRLIT(" ISARRAY=\"true\""); |
|
|
|
if (rep->getArraySize()) |
|
{ |
|
char buffer[64]; |
|
int n = sprintf(buffer, " ARRAYSIZE=\"%u\"", rep->getArraySize()); |
|
out.append(buffer, n); |
|
} |
|
} |
|
|
|
XmlWriter::appendQualifierFlavorEntity(out, rep->getFlavor()); |
|
|
|
out << STRLIT(">\n"); |
|
|
|
XmlWriter::appendScopeElement(out, rep->getScope()); |
|
XmlWriter::appendValueElement(out, rep->getValue()); |
|
|
|
out << STRLIT("</QUALIFIER.DECLARATION>\n"); |
} | } |
| |
void XmlWriter::printQualifierDeclElement( | void XmlWriter::printQualifierDeclElement( |
|
|
{ | { |
Buffer tmp; | Buffer tmp; |
appendQualifierDeclElement(tmp, qualifierDecl); | appendQualifierDeclElement(tmp, qualifierDecl); |
tmp.append('\0'); |
|
os << tmp.getData() << PEGASUS_STD(endl); | os << tmp.getData() << PEGASUS_STD(endl); |
} | } |
| |
|
|
} | } |
out << STRLIT("HOST: ") << host << STRLIT("\r\n"); | out << STRLIT("HOST: ") << host << STRLIT("\r\n"); |
out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); | out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
OUTPUT_CONTENTLENGTH; |
OUTPUT_CONTENTLENGTH(out, contentLength); |
if (acceptLanguages.size() > 0) | if (acceptLanguages.size() > 0) |
{ | { |
out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n"); | out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n"); |
|
|
out << nn << STRLIT("-CIMOperation: MethodCall\r\n"); | out << nn << STRLIT("-CIMOperation: MethodCall\r\n"); |
out << nn << STRLIT("-CIMMethod: ") | out << nn << STRLIT("-CIMMethod: ") |
<< encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n"); | << encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n"); |
out << nn << STRLIT("-CIMObject: ") << encodeURICharacters(cimObject) |
out << nn << STRLIT("-CIMObject: ") |
<< STRLIT("\r\n"); |
<< encodeURICharacters(cimObject) << STRLIT("\r\n"); |
} | } |
else | else |
{ | { |
out << STRLIT("CIMOperation: MethodCall\r\n"); | out << STRLIT("CIMOperation: MethodCall\r\n"); |
out << STRLIT("CIMMethod: ") | out << STRLIT("CIMMethod: ") |
<< encodeURICharacters(cimMethod.getString()) |
<< encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n"); |
<< STRLIT("\r\n"); |
|
out << STRLIT("CIMObject: ") << encodeURICharacters(cimObject) | out << STRLIT("CIMObject: ") << encodeURICharacters(cimObject) |
<< STRLIT("\r\n"); | << STRLIT("\r\n"); |
} | } |
|
|
#endif | #endif |
| |
out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); | out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
OUTPUT_CONTENTLENGTH; |
OUTPUT_CONTENTLENGTH(out, contentLength); |
| |
if (contentLanguages.size() > 0) | if (contentLanguages.size() > 0) |
{ | { |
|
|
const String& content) | const String& content) |
{ | { |
out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n"); | out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n"); |
|
OUTPUT_CONTENTLENGTH(out, 0); |
out << content << STRLIT("\r\n"); | out << content << STRLIT("\r\n"); |
out << STRLIT("\r\n"); | out << STRLIT("\r\n"); |
| |
|
|
// 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; |
OUTPUT_CONTENTLENGTH(out, 0); |
OUTPUT_CONTENTLENGTH; |
|
out << content << STRLIT("\r\n"); | out << content << STRLIT("\r\n"); |
out << STRLIT("\r\n"); | out << STRLIT("\r\n"); |
| |
|
|
out << STRLIT("/>"); | out << STRLIT("/>"); |
} | } |
| |
//------------------------------------------------------------------------------ |
//---------------------------------------------------------------------- |
// |
|
// appendReturnValueElement() |
|
// | // |
// <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)> |
// appendParamTypeAndEmbeddedObjAttrib |
// <!ATTLIST RETURNVALUE |
// Appends the Param type and EmbeddedObject Info to the buffer |
// %EmbeddedObject; #IMPLIED | // %EmbeddedObject; #IMPLIED |
// %ParamType;> | // %ParamType;> |
// | // |
//------------------------------------------------------------------------------ |
//--------------------------------------------------------------------- |
| |
void XmlWriter::appendReturnValueElement( |
void XmlWriter::appendParamTypeAndEmbeddedObjAttrib( |
Buffer& out, | Buffer& out, |
const CIMValue& value) |
const CIMType& type) |
{ | { |
out << STRLIT("<RETURNVALUE"); |
|
| |
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 |
// encode the property in CIM-XML as a string with the EmbeddedObject |
// attribute (there is not currently a CIM-XML "object" datatype) |
// attribute (there is not currently a CIM-XML "object" |
|
// datatype). |
|
// Because of an error in Pegasus we were earlier outputting |
|
// upper case "EMBEDDEDOBJECT" as the attribute name. The |
|
// spec calls for mixed case "EmbeddedObject. Fixed in |
|
// bug 7131 to output EmbeddedObject attribute in upper |
|
// case and mixed case. Receiver will ignore one or the |
|
// other. |
// else | // else |
// output the real type | // output the real type |
if (type == CIMTYPE_OBJECT) | if (type == CIMTYPE_OBJECT) |
{ | { |
|
|
out << STRLIT(" PARAMTYPE=\"string\""); | out << STRLIT(" PARAMTYPE=\"string\""); |
|
out << STRLIT(" EmbeddedObject=\"object\""); |
out << STRLIT(" EMBEDDEDOBJECT=\"object\""); | out << STRLIT(" EMBEDDEDOBJECT=\"object\""); |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT | #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
else if (type == CIMTYPE_INSTANCE) | else if (type == CIMTYPE_INSTANCE) |
{ | { |
out << STRLIT(" PARAMTYPE=\"string\""); | out << STRLIT(" PARAMTYPE=\"string\""); |
|
out << STRLIT(" EmbeddedObject=\"instance\""); |
out << STRLIT(" EMBEDDEDOBJECT=\"instance\""); | out << STRLIT(" EMBEDDEDOBJECT=\"instance\""); |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT | #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
|
out << STRLIT(" PARAMTYPE=\"") << cimTypeToString (type); | out << STRLIT(" PARAMTYPE=\"") << cimTypeToString (type); |
out.append('"'); | out.append('"'); |
} | } |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// appendReturnValueElement() |
|
// |
|
// <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)> |
|
// <!ATTLIST RETURNVALUE |
|
// %EmbeddedObject; #IMPLIED |
|
// %ParamType;> |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void XmlWriter::appendReturnValueElement( |
|
Buffer& out, |
|
const CIMValue& value) |
|
{ |
|
out << STRLIT("<RETURNVALUE"); |
|
|
|
CIMType type = value.getType(); |
|
|
|
appendParamTypeAndEmbeddedObjAttrib(out, type); |
| |
out << STRLIT(">\n"); | out << STRLIT(">\n"); |
| |
|
|
return tmp; | return tmp; |
} | } |
| |
//PEP 128 adding serverRsponseTime to header |
|
Buffer XmlWriter::formatSimpleMethodRspMessage( | Buffer XmlWriter::formatSimpleMethodRspMessage( |
const CIMName& methodName, | const CIMName& methodName, |
const String& messageId, | const String& messageId, |
|
|
} | } |
out << STRLIT("HOST: ") << host << STRLIT("\r\n"); | out << STRLIT("HOST: ") << host << STRLIT("\r\n"); |
out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); | out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
OUTPUT_CONTENTLENGTH; |
OUTPUT_CONTENTLENGTH(out, contentLength); |
| |
if (acceptLanguages.size() > 0) | if (acceptLanguages.size() > 0) |
{ | { |
|
|
| |
out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n"); | out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n"); |
out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); | out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n"); |
OUTPUT_CONTENTLENGTH; |
OUTPUT_CONTENTLENGTH(out, contentLength); |
| |
if (contentLanguages.size() > 0) | if (contentLanguages.size() > 0) |
{ | { |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// _xmlWritter_printAttributes() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void _xmlWritter_printAttributes( |
|
PEGASUS_STD(ostream)& os, |
|
const XmlAttribute* attributes, |
|
Uint32 attributeCount) |
|
{ |
|
for (Uint32 i = 0; i < attributeCount; i++) |
|
{ |
|
os << attributes[i].name << "="; |
|
|
|
os << '"'; |
|
_xmlWritter_appendSpecial(os, attributes[i].value); |
|
os << '"'; |
|
|
|
if (i + 1 != attributeCount) |
|
os << ' '; |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// _xmlWritter_indent() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void _xmlWritter_indent( |
|
PEGASUS_STD(ostream)& os, |
|
Uint32 level, |
|
Uint32 indentChars) |
|
{ |
|
Uint32 n = level * indentChars; |
|
|
|
for (Uint32 i = 0; i < n; i++) |
|
os << ' '; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// indentedPrint() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void XmlWriter::indentedPrint( |
|
PEGASUS_STD(ostream)& os, |
|
const char* text, |
|
Uint32 indentChars) |
|
{ |
|
AutoArrayPtr<char> tmp(strcpy(new char[strlen(text) + 1], text)); |
|
|
|
XmlParser parser(tmp.get()); |
|
XmlEntry entry; |
|
Stack<const char*> stack; |
|
|
|
while (parser.next(entry)) |
|
{ |
|
switch (entry.type) |
|
{ |
|
case XmlEntry::XML_DECLARATION: |
|
{ |
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
|
|
os << "<?" << entry.text << " "; |
|
_xmlWritter_printAttributes( |
|
os, entry.attributes, entry.attributeCount); |
|
os << "?>"; |
|
break; |
|
} |
|
|
|
case XmlEntry::START_TAG: |
|
{ |
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
|
|
os << "<" << entry.text; |
|
|
|
if (entry.attributeCount) |
|
os << ' '; |
|
|
|
_xmlWritter_printAttributes( |
|
os, entry.attributes, entry.attributeCount); |
|
os << ">"; |
|
stack.push(entry.text); |
|
break; |
|
} |
|
|
|
case XmlEntry::EMPTY_TAG: |
|
{ |
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
|
|
os << "<" << entry.text << " "; |
|
_xmlWritter_printAttributes( |
|
os, entry.attributes, entry.attributeCount); |
|
os << "/>"; |
|
break; |
|
} |
|
|
|
case XmlEntry::END_TAG: |
|
{ |
|
if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0) |
|
stack.pop(); |
|
|
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
|
|
os << "</" << entry.text << ">"; |
|
break; |
|
} |
|
|
|
case XmlEntry::COMMENT: |
|
{ |
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
os << "<!--"; |
|
_xmlWritter_appendSpecial(os, entry.text); |
|
os << "-->"; |
|
break; |
|
} |
|
|
|
case XmlEntry::CONTENT: |
|
{ |
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
_xmlWritter_appendSpecial(os, entry.text); |
|
break; |
|
} |
|
|
|
case XmlEntry::CDATA: |
|
{ |
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
os << "<![CDATA[" << entry.text << "]]>"; |
|
break; |
|
} |
|
|
|
case XmlEntry::DOCTYPE: |
|
{ |
|
_xmlWritter_indent(os, stack.size(), indentChars); |
|
os << "<!DOCTYPE...>"; |
|
break; |
|
} |
|
} |
|
|
|
os << PEGASUS_STD(endl); |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// XmlWriter::getNextMessageId() | // XmlWriter::getNextMessageId() |
// | // |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
| |
String XmlWriter::getNextMessageId() | String XmlWriter::getNextMessageId() |
{ | { |
char buffer[16]; |
char scratchBuffer[22]; |
sprintf(buffer, "%u", _messageIDFactory.getID()); |
Uint32 n; |
return buffer; |
const char * startP = Uint32ToString(scratchBuffer, |
|
_messageIDFactory.getID(), |
|
n); |
|
return String(startP, n); |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |