1 karl 1.116 //%2005////////////////////////////////////////////////////////////////////////
|
2 mike 1.23 //
|
3 karl 1.112 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 karl 1.100 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.112 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.116 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 mike 1.23 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
|
13 kumpf 1.63 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
16 mike 1.23 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
|
18 david.dillard 1.121 //
|
19 kumpf 1.63 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
|
20 mike 1.23 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
|
22 kumpf 1.63 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
25 mike 1.23 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
30 // Author: Mike Brasher (mbrasher@bmc.com)
31 //
|
32 mike 1.24 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
33 // Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
34 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
35 kumpf 1.61 // Carol Ann Krug Graves, Hewlett-Packard Company
36 // (carolann_graves@hp.com)
|
37 a.arora 1.106 // Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
|
38 brian.campbell 1.113 // Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
|
39 david.dillard 1.130 // Willis White (whiwill@us.ibm.com) PEP 127 and 128
|
40 brian.campbell 1.113 // Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
|
41 dave.sudlik 1.114 // Dave Sudlik, IBM (dsudlik@us.ibm.com)
|
42 david.dillard 1.130 // David Dillard, Symantec Corp. (david_dillard@symantec.com)
|
43 vijay.eli 1.118 // Vijay Eli, vijayeli@in.ibm.com, fix for #2571
|
44 mike 1.23 //
45 //%/////////////////////////////////////////////////////////////////////////////
46
|
47 sage 1.49 #include <Pegasus/Common/Config.h>
|
48 mike 1.23 #include <cstdlib>
49 #include <cstdio>
|
50 kumpf 1.46 #include "Constants.h"
|
51 mike 1.23 #include "CIMClass.h"
|
52 kumpf 1.55 #include "CIMClassRep.h"
|
53 mike 1.23 #include "CIMInstance.h"
|
54 kumpf 1.55 #include "CIMInstanceRep.h"
|
55 kumpf 1.56 #include "CIMProperty.h"
56 #include "CIMPropertyRep.h"
57 #include "CIMMethod.h"
58 #include "CIMMethodRep.h"
59 #include "CIMParameter.h"
60 #include "CIMParameterRep.h"
61 #include "CIMParamValue.h"
62 #include "CIMParamValueRep.h"
63 #include "CIMQualifier.h"
64 #include "CIMQualifierRep.h"
65 #include "CIMQualifierDecl.h"
66 #include "CIMQualifierDeclRep.h"
|
67 kumpf 1.54 #include "CIMValue.h"
|
68 mike 1.23 #include "XmlWriter.h"
69 #include "XmlParser.h"
|
70 kumpf 1.44 #include "Tracer.h"
|
71 sage 1.49 #include <Pegasus/Common/StatisticalData.h>
|
72 david 1.92 #include "CommonUTF.h"
|
73 mike 1.125 #include "Buffer.h"
|
74 mike 1.127 #include "StrLit.h"
|
75 kumpf 1.132 #include "LanguageParser.h"
|
76 mike 1.23
77 PEGASUS_NAMESPACE_BEGIN
78
|
79 brian.campbell 1.107 // This is a shortcut macro for outputing content length. This
80 // pads the output number to the max characters representing a Uint32 number
81 // so that it can be overwritten easily with a transfer encoding line later
82 // on in HTTPConnection if required. This is strictly for performance since
83 // messages can be very large. This overwriting shortcut allows us to NOT have
84 // to repackage a large message later.
85
|
86 mike 1.126 #define OUTPUT_CONTENTLENGTH \
87 { \
88 char contentLengthP[11]; \
|
89 mike 1.129 int n = sprintf(contentLengthP,"%.10u", contentLength); \
90 out << STRLIT("content-length: "); \
91 out.append(contentLengthP, n); \
92 out << STRLIT("\r\n"); \
|
93 mike 1.126 }
94
95 ////////////////////////////////////////////////////////////////////////////////
96 //
97 // SpecialChar and table.
98 //
99 ////////////////////////////////////////////////////////////////////////////////
100
|
101 david.dillard 1.130 // Note: we cannot use StrLit here since it has a constructur (forbits
|
102 mike 1.127 // structure initialization).
103
|
104 mike 1.126 struct SpecialChar
105 {
106 const char* str;
107 size_t size;
108 };
109
110 // Defines encodings of special characters. Just use a 7-bit ASCII character
111 // as an index into this array to retrieve its string encoding and encoding
112 // length in bytes.
113 static const SpecialChar _specialChars[] =
114 {
|
115 mike 1.127 {STRLIT_ARGS("�")},
116 {STRLIT_ARGS("")},
117 {STRLIT_ARGS("")},
118 {STRLIT_ARGS("")},
119 {STRLIT_ARGS("")},
120 {STRLIT_ARGS("")},
121 {STRLIT_ARGS("")},
122 {STRLIT_ARGS("")},
123 {STRLIT_ARGS("")},
124 {STRLIT_ARGS("	")},
125 {STRLIT_ARGS(" ")},
126 {STRLIT_ARGS("")},
127 {STRLIT_ARGS("")},
128 {STRLIT_ARGS(" ")},
129 {STRLIT_ARGS("")},
130 {STRLIT_ARGS("")},
131 {STRLIT_ARGS("")},
132 {STRLIT_ARGS("")},
133 {STRLIT_ARGS("")},
134 {STRLIT_ARGS("")},
135 {STRLIT_ARGS("")},
136 mike 1.127 {STRLIT_ARGS("")},
137 {STRLIT_ARGS("")},
138 {STRLIT_ARGS("")},
139 {STRLIT_ARGS("")},
140 {STRLIT_ARGS("")},
141 {STRLIT_ARGS("")},
142 {STRLIT_ARGS("")},
143 {STRLIT_ARGS("")},
144 {STRLIT_ARGS("")},
145 {STRLIT_ARGS("")},
146 {STRLIT_ARGS("")},
147 {STRLIT_ARGS(" ")},
148 {STRLIT_ARGS("!")},
149 {STRLIT_ARGS(""")},
150 {STRLIT_ARGS("#")},
151 {STRLIT_ARGS("$")},
152 {STRLIT_ARGS("%")},
153 {STRLIT_ARGS("&")},
154 {STRLIT_ARGS("'")},
155 {STRLIT_ARGS("(")},
156 {STRLIT_ARGS(")")},
157 mike 1.127 {STRLIT_ARGS("*")},
158 {STRLIT_ARGS("+")},
159 {STRLIT_ARGS(",")},
160 {STRLIT_ARGS("-")},
161 {STRLIT_ARGS(".")},
162 {STRLIT_ARGS("/")},
163 {STRLIT_ARGS("0")},
164 {STRLIT_ARGS("1")},
165 {STRLIT_ARGS("2")},
166 {STRLIT_ARGS("3")},
167 {STRLIT_ARGS("4")},
168 {STRLIT_ARGS("5")},
169 {STRLIT_ARGS("6")},
170 {STRLIT_ARGS("7")},
171 {STRLIT_ARGS("8")},
172 {STRLIT_ARGS("9")},
173 {STRLIT_ARGS(":")},
174 {STRLIT_ARGS(";")},
175 {STRLIT_ARGS("<")},
176 {STRLIT_ARGS("=")},
177 {STRLIT_ARGS(">")},
178 mike 1.127 {STRLIT_ARGS("?")},
179 {STRLIT_ARGS("@")},
180 {STRLIT_ARGS("A")},
181 {STRLIT_ARGS("B")},
182 {STRLIT_ARGS("C")},
183 {STRLIT_ARGS("D")},
184 {STRLIT_ARGS("E")},
185 {STRLIT_ARGS("F")},
186 {STRLIT_ARGS("G")},
187 {STRLIT_ARGS("H")},
188 {STRLIT_ARGS("I")},
189 {STRLIT_ARGS("J")},
190 {STRLIT_ARGS("K")},
191 {STRLIT_ARGS("L")},
192 {STRLIT_ARGS("M")},
193 {STRLIT_ARGS("N")},
194 {STRLIT_ARGS("O")},
195 {STRLIT_ARGS("P")},
196 {STRLIT_ARGS("Q")},
197 {STRLIT_ARGS("R")},
198 {STRLIT_ARGS("S")},
199 mike 1.127 {STRLIT_ARGS("T")},
200 {STRLIT_ARGS("U")},
201 {STRLIT_ARGS("V")},
202 {STRLIT_ARGS("W")},
203 {STRLIT_ARGS("X")},
204 {STRLIT_ARGS("Y")},
205 {STRLIT_ARGS("Z")},
206 {STRLIT_ARGS("[")},
207 {STRLIT_ARGS("\\")},
208 {STRLIT_ARGS("]")},
209 {STRLIT_ARGS("^")},
210 {STRLIT_ARGS("_")},
211 {STRLIT_ARGS("`")},
212 {STRLIT_ARGS("a")},
213 {STRLIT_ARGS("b")},
214 {STRLIT_ARGS("c")},
215 {STRLIT_ARGS("d")},
216 {STRLIT_ARGS("e")},
217 {STRLIT_ARGS("f")},
218 {STRLIT_ARGS("g")},
219 {STRLIT_ARGS("h")},
220 mike 1.127 {STRLIT_ARGS("i")},
221 {STRLIT_ARGS("j")},
222 {STRLIT_ARGS("k")},
223 {STRLIT_ARGS("l")},
224 {STRLIT_ARGS("m")},
225 {STRLIT_ARGS("n")},
226 {STRLIT_ARGS("o")},
227 {STRLIT_ARGS("p")},
228 {STRLIT_ARGS("q")},
229 {STRLIT_ARGS("r")},
230 {STRLIT_ARGS("s")},
231 {STRLIT_ARGS("t")},
232 {STRLIT_ARGS("u")},
233 {STRLIT_ARGS("v")},
234 {STRLIT_ARGS("w")},
235 {STRLIT_ARGS("x")},
236 {STRLIT_ARGS("y")},
237 {STRLIT_ARGS("z")},
238 {STRLIT_ARGS("{")},
239 {STRLIT_ARGS("|")},
240 {STRLIT_ARGS("}")},
241 mike 1.127 {STRLIT_ARGS("~")},
242 {STRLIT_ARGS("")},
|
243 mike 1.126 };
244
245 // If _isSpecialChar7[ch] is true, then ch is a special character, which must
246 // have a special encoding in XML. But only use 7-bit ASCII characters to
247 // index this array.
|
248 david.dillard 1.130 static const int _isSpecialChar7[] =
|
249 mike 1.126 {
250 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,
251 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,
252 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,
253 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
254 };
255
256 ////////////////////////////////////////////////////////////////////////////////
|
257 brian.campbell 1.107
|
258 mike 1.125 Buffer& operator<<(Buffer& out, const Char16& x)
|
259 kumpf 1.27 {
260 XmlWriter::append(out, x);
261 return out;
262 }
263
|
264 mike 1.125 Buffer& operator<<(Buffer& out, const String& x)
|
265 kumpf 1.27 {
266 XmlWriter::append(out, x);
267 return out;
268 }
269
|
270 mike 1.125 Buffer& operator<<(Buffer& out, const Indentor& x)
|
271 kumpf 1.27 {
272 XmlWriter::append(out, x);
273 return out;
274 }
275
|
276 mike 1.125 Buffer& operator<<(Buffer& out, const Buffer& x)
|
277 kumpf 1.27 {
|
278 mike 1.125 out.append(x.getData(), x.size());
|
279 kumpf 1.27 return out;
280 }
281
|
282 mike 1.125 Buffer& operator<<(Buffer& out, Uint32 x)
|
283 kumpf 1.27 {
284 XmlWriter::append(out, x);
285 return out;
286 }
287
|
288 mike 1.125 Buffer& operator<<(Buffer& out, const CIMName& name)
|
289 kumpf 1.80 {
290 XmlWriter::append(out, name.getString ());
291 return out;
292 }
293
|
294 david.dillard 1.121
295 // l10n
|
296 mike 1.125 Buffer& operator<<(Buffer& out, const AcceptLanguages& al)
|
297 chuck 1.89 {
|
298 kumpf 1.132 XmlWriter::append(out, LanguageParser::buildAcceptLanguageHeader(al));
|
299 chuck 1.89 return out;
300 }
301
|
302 david.dillard 1.121 // l10n
|
303 mike 1.125 Buffer& operator<<(Buffer& out, const ContentLanguages& cl)
|
304 chuck 1.89 {
|
305 kumpf 1.132 XmlWriter::append(out, LanguageParser::buildContentLanguageHeader(cl));
|
306 chuck 1.89 return out;
307 }
308
309
|
310 kumpf 1.72 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x)
311 {
312 return os << x.toString();
313 }
314
|
315 kumpf 1.80 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMName& name)
316 {
317 os << name.getString();
318 return os;
319 }
320
321 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os,
322 const CIMNamespaceName& name)
323 {
324 os << name.getString();
325 return os;
326 }
327
|
328 mike 1.126 static void _xmlWritter_appendChar(Buffer& out, const Char16& c)
|
329 mike 1.23 {
|
330 david 1.92 // We need to convert the Char16 to UTF8 then append the UTF8
331 // character into the array.
332 // NOTE: The UTF8 character could be several bytes long.
333 // WARNING: This function will put in replacement character for
334 // all characters that have surogate pairs.
|
335 david.dillard 1.115 char str[6];
|
336 david 1.92 memset(str,0x00,sizeof(str));
|
337 chuck 1.94 Uint8* charIN = (Uint8 *)&c;
|
338 david 1.92
339 const Uint16 *strsrc = (Uint16 *)charIN;
340 Uint16 *endsrc = (Uint16 *)&charIN[1];
341
342 Uint8 *strtgt = (Uint8 *)str;
343 Uint8 *endtgt = (Uint8 *)&str[5];
344
345 UTF16toUTF8(&strsrc,
|
346 david.dillard 1.121 endsrc,
|
347 david 1.92 &strtgt,
348 endtgt);
349
|
350 david.dillard 1.115 out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);
|
351 mike 1.23 }
352
|
353 mike 1.126 inline void _appendSpecialChar7(Buffer& out, char c)
|
354 mike 1.23 {
|
355 mike 1.126 if (_isSpecialChar7[int(c)])
|
356 david.dillard 1.131 out.append(_specialChars[int(c)].str, _specialChars[int(c)].size);
|
357 david 1.92 else
|
358 david.dillard 1.131 out.append(c);
|
359 david 1.92 }
|
360 mike 1.23
|
361 mike 1.126 inline void _xmlWritter_appendSpecialChar(Buffer& out, const Char16& c)
|
362 david 1.92 {
|
363 mike 1.126 if (c < 128)
|
364 david.dillard 1.131 _appendSpecialChar7(out, char(c));
|
365 kumpf 1.87 else
|
366 david.dillard 1.131 _xmlWritter_appendChar(out, c);
|
367 mike 1.23 }
368
|
369 mike 1.126 static void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
|
370 kumpf 1.27 {
|
371 mateus.baur 1.119 if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
|
372 kumpf 1.27 {
|
373 kumpf 1.87 char charref[7];
|
374 david.dillard 1.121 sprintf(charref, "&#%u;", static_cast<Uint8>(c));
|
375 kumpf 1.87 os << charref;
376 }
377 else
378 {
379 switch (c)
380 {
381 case '&':
382 os << "&";
383 break;
384
385 case '<':
386 os << "<";
387 break;
388
389 case '>':
390 os << ">";
391 break;
392
393 case '"':
394 os << """;
395 break;
396 kumpf 1.87
397 case '\'':
398 os << "'";
399 break;
400
401 default:
402 os << c;
403 }
|
404 kumpf 1.27 }
405 }
406
|
407 mike 1.125 void _xmlWritter_appendSurrogatePair(Buffer& out, Uint16 high, Uint16 low)
|
408 david 1.92 {
|
409 david.dillard 1.115 char str[6];
|
410 chuck 1.94 Uint8 charIN[5];
|
411 david 1.92 memset(str,0x00,sizeof(str));
412 memcpy(&charIN,&high,2);
413 memcpy(&charIN[2],&low,2);
414 const Uint16 *strsrc = (Uint16 *)charIN;
415 Uint16 *endsrc = (Uint16 *)&charIN[3];
416
417 Uint8 *strtgt = (Uint8 *)str;
418 Uint8 *endtgt = (Uint8 *)&str[5];
419
420 UTF16toUTF8(&strsrc,
|
421 david.dillard 1.121 endsrc,
|
422 david 1.92 &strtgt,
423 endtgt);
424
|
425 chuck 1.104 Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
|
426 david.dillard 1.115 out.append(str,number1);
|
427 david 1.92 }
428
|
429 s.hills 1.99 inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
|
430 kumpf 1.27 {
431 while (*str)
|
432 david.dillard 1.131 _xmlWritter_appendSpecialChar(os, *str++);
|
433 kumpf 1.27 }
434
|
435 mike 1.125 void XmlWriter::append(Buffer& out, const Char16& x)
|
436 mike 1.23 {
|
437 s.hills 1.99 _xmlWritter_appendChar(out, x);
|
438 mike 1.23 }
439
|
440 mike 1.125 void XmlWriter::append(Buffer& out, Boolean x)
|
441 kumpf 1.54 {
442 append(out, (x ? "TRUE" : "FALSE"));
443 }
444
|
445 mike 1.125 void XmlWriter::append(Buffer& out, Uint32 x)
|
446 mike 1.23 {
447 char buffer[32];
|
448 kumpf 1.54 sprintf(buffer, "%u", x);
449 append(out, buffer);
450 }
451
|
452 mike 1.125 void XmlWriter::append(Buffer& out, Sint32 x)
|
453 kumpf 1.54 {
454 char buffer[32];
|
455 mike 1.23 sprintf(buffer, "%d", x);
456 append(out, buffer);
457 }
458
|
459 mike 1.125 void XmlWriter::append(Buffer& out, Uint64 x)
|
460 kumpf 1.54 {
461 char buffer[32]; // Should need 21 chars max
|
462 kumpf 1.88 sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);
|
463 kumpf 1.54 append(out, buffer);
464 }
465
|
466 mike 1.125 void XmlWriter::append(Buffer& out, Sint64 x)
|
467 kumpf 1.54 {
468 char buffer[32]; // Should need 21 chars max
|
469 kumpf 1.88 sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);
|
470 kumpf 1.54 append(out, buffer);
471 }
472
|
473 mike 1.125 void XmlWriter::append(Buffer& out, Real32 x)
|
474 chuck 1.102 {
475 char buffer[128];
476 // %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format
477 // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec
478 // (4 byte IEEE floating point)
479 sprintf(buffer, "%.7e", x);
480 append(out, buffer);
481 }
482
|
483 mike 1.125 void XmlWriter::append(Buffer& out, Real64 x)
|
484 kumpf 1.54 {
485 char buffer[128];
|
486 chuck 1.102 // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format
487 // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec
488 // (8 byte IEEE floating point)
489 sprintf(buffer, "%.16e", x);
|
490 kumpf 1.54 append(out, buffer);
491 }
492
|
493 mike 1.125 void XmlWriter::append(Buffer& out, const char* str)
|
494 mike 1.23 {
|
495 mike 1.126 size_t n = strlen(str);
496 out.append(str, n);
|
497 kumpf 1.27 }
498
|
499 mike 1.125 void XmlWriter::append(Buffer& out, const String& str)
|
500 kumpf 1.27 {
|
501 mike 1.126 const Uint16* p = (const Uint16*)str.getChar16Data();
502 size_t n = str.size();
503
504 // Handle leading ASCII 7 characers in these next two loops (use unrolling).
505
506 while (n >= 8 && ((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)
507 {
508 out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
509 p += 8;
510 n -= 8;
511 }
512
513 while (n >= 4 && ((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)
|
514 kumpf 1.64 {
|
515 mike 1.126 out.append(p[0], p[1], p[2], p[3]);
516 p += 4;
517 n -= 4;
518 }
519
520 while (n--)
521 {
522 Uint16 c = *p++;
523
524 // Special processing for UTF8 case:
525
526 if (c < 128)
527 {
528 out.append(c);
529 continue;
530 }
531
532 // Hanlde UTF8 case (if reached).
533
|
534 chuck 1.94 if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
535 ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
536 {
|
537 mike 1.126 Char16 highSurrogate = p[-1];
538 Char16 lowSurrogate = p[0];
539 p++;
540 n--;
|
541 david.dillard 1.121
|
542 mike 1.126 _xmlWritter_appendSurrogatePair(
543 out, Uint16(highSurrogate),Uint16(lowSurrogate));
|
544 chuck 1.94 }
545 else
546 {
|
547 mike 1.126 _xmlWritter_appendChar(out, c);
|
548 chuck 1.94 }
|
549 kumpf 1.64 }
|
550 kumpf 1.27 }
551
|
552 mike 1.125 void XmlWriter::append(Buffer& out, const Indentor& x)
|
553 kumpf 1.27 {
554 for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
555 out.append(' ');
|
556 mike 1.23 }
557
|
558 mike 1.125 void XmlWriter::appendSpecial(Buffer& out, const Char16& x)
|
559 mike 1.23 {
|
560 s.hills 1.99 _xmlWritter_appendSpecialChar(out, x);
|
561 mike 1.23 }
562
|
563 mike 1.125 void XmlWriter::appendSpecial(Buffer& out, char x)
|
564 mike 1.23 {
|
565 mike 1.126 _appendSpecialChar7(out, x);
|
566 mike 1.23 }
567
|
568 mike 1.125 void XmlWriter::appendSpecial(Buffer& out, const char* str)
|
569 mike 1.23 {
570 while (*str)
|
571 mike 1.126 _appendSpecialChar7(out, *str++);
|
572 mike 1.23 }
573
|
574 mike 1.125 void XmlWriter::appendSpecial(Buffer& out, const String& str)
|
575 mike 1.23 {
|
576 mike 1.126 const Uint16* p = (const Uint16*)str.getChar16Data();
577 size_t n = str.size();
578
579 // Handle leading ASCII 7 characers in these next two loops (use unrolling).
580
581 while (n >= 8)
582 {
583 // The following condition is equivalent to this:
584 // (p[0] < 128 && p[1] < 128 && p[2] < 128 && p[3] < 128 &&
585 // p[4] < 128 && p[5] < 128 && p[6] < 128 && p[7] < 128)
586
587 if (((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)
588 {
589 // Note: "|" is faster than "||" and achieves the same effect
590 // since p[i] is either 0 or 1.
591
592 if (_isSpecialChar7[p[0]] | _isSpecialChar7[p[1]] |
593 _isSpecialChar7[p[2]] | _isSpecialChar7[p[3]] |
594 _isSpecialChar7[p[4]] | _isSpecialChar7[p[5]] |
595 _isSpecialChar7[p[6]] | _isSpecialChar7[p[7]])
596 {
597 mike 1.126 // Rare case.
598 _appendSpecialChar7(out, p[0]);
599 _appendSpecialChar7(out, p[1]);
600 _appendSpecialChar7(out, p[2]);
601 _appendSpecialChar7(out, p[3]);
602 _appendSpecialChar7(out, p[4]);
603 _appendSpecialChar7(out, p[5]);
604 _appendSpecialChar7(out, p[6]);
605 _appendSpecialChar7(out, p[7]);
606 }
607 else
608 {
609 // Common case.
610 out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
611 }
612 p += 8;
613 n -= 8;
614 }
615 else
616 break;
617 }
618 mike 1.126
619 while (n >= 4)
|
620 kumpf 1.64 {
|
621 mike 1.126 // The following condition is equivalent to this:
622 // (p[0] < 128 && p[1] < 128 && p[2] < 128 && p[3] < 128)
623
624 if (((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)
625 {
626 if (_isSpecialChar7[p[0]] | _isSpecialChar7[p[1]] |
627 _isSpecialChar7[p[2]] | _isSpecialChar7[p[3]])
628 {
629 // Rare case:
630 _appendSpecialChar7(out, p[0]);
631 _appendSpecialChar7(out, p[1]);
632 _appendSpecialChar7(out, p[2]);
633 _appendSpecialChar7(out, p[3]);
634 }
635 else
636 {
637 // Common case:
638 out.append(p[0], p[1], p[2], p[3]);
639 }
640
641 p += 4;
642 mike 1.126 n -= 4;
643 }
644 else
645 break;
646 }
647
|
648 david.dillard 1.130 // Process remaining characters. A UTF8 character must have been
|
649 mike 1.126 // encountered or this would have never been reached.
650
651 while (n--)
652 {
653 Uint16 c = *p++;
654
655 // Special processing for UTF8 case:
656
657 if (c < 128)
658 {
659 _appendSpecialChar7(out, c);
660 continue;
661 }
662
663 // Hanlde UTF8 case (if reached).
|
664 chuck 1.94
665 if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
666 ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
|
667 david 1.92 {
|
668 mike 1.126 Char16 highSurrogate = p[-1];
669 Char16 lowSurrogate = p[0];
670 p++;
671 n--;
|
672 david.dillard 1.121
|
673 mike 1.126 _xmlWritter_appendSurrogatePair(
674 out, Uint16(highSurrogate),Uint16(lowSurrogate));
|
675 david 1.92 }
676 else
677 {
|
678 mike 1.126 _xmlWritter_appendSpecialChar(out, c);
|
679 david 1.92 }
|
680 kumpf 1.64 }
|
681 mike 1.23 }
682
|
683 kumpf 1.84 // See http://www.ietf.org/rfc/rfc2396.txt section 2
684 // Reserved characters = ';' '/' '?' ':' '@' '&' '=' '+' '$' ','
685 // Excluded characters:
686 // Control characters = 0x00-0x1f, 0x7f
687 // Space character = 0x20
688 // Delimiters = '<' '>' '#' '%' '"'
689 // Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'
|
690 chuck 1.94 //
|
691 chuck 1.95
|
692 mike 1.126 static const char _is_uri[128] =
693 {
694 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,
695 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,
696 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,
697 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,
|
698 david.dillard 1.130 };
|
699 mike 1.126
700 static void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)
|
701 kumpf 1.84 {
|
702 chuck 1.95 Uint8 c = (Uint8)char8;
|
703 david.dillard 1.121
|
704 kumpf 1.86 #ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING
|
705 mike 1.126 if (c > 127 || _is_uri[int(c)])
|
706 chuck 1.95 {
707 char hexencoding[4];
|
708 mike 1.126 int n = sprintf(hexencoding, "%%%X%X", c/16, c%16);
709 #ifdef PEGASUS_USE_STRING_EXTENSIONS
710 outString.append(hexencoding, n);
711 #else /* PEGASUS_USE_STRING_EXTENSIONS */
|
712 chuck 1.95 outString.append(hexencoding);
|
713 mike 1.126 #endif /* PEGASUS_USE_STRING_EXTENSIONS */
|
714 chuck 1.95 }
715 else
|
716 kumpf 1.84 #endif
|
717 chuck 1.95 {
718 outString.append((Uint16)c);
|
719 kumpf 1.84 }
720 }
721
|
722 mike 1.125 String XmlWriter::encodeURICharacters(const Buffer& uriString)
|
723 kumpf 1.84 {
724 String encodedString;
725
726 for (Uint32 i=0; i<uriString.size(); i++)
727 {
|
728 s.hills 1.99 _xmlWritter_encodeURIChar(encodedString, uriString[i]);
|
729 kumpf 1.84 }
730
731 return encodedString;
732 }
733
|
734 vijay.eli 1.118 String XmlWriter::encodeURICharacters(const String& uriString)
|
735 kumpf 1.84 {
736 String encodedString;
737
|
738 chuck 1.95 /* i18n remove - did not handle surrogate pairs
|
739 kumpf 1.84 for (Uint32 i=0; i<uriString.size(); i++)
740 {
|
741 s.hills 1.99 _xmlWritter_encodeURIChar(encodedString, uriString[i]);
|
742 chuck 1.95 }
743 */
744
745 // See the "CIM Operations over HTTP" spec, section 3.3.2 and
746 // 3.3.3, for the treatment of non US-ASCII (UTF-8) chars
747
748 // First, convert to UTF-8 (include handling of surrogate pairs)
|
749 mike 1.125 Buffer utf8;
|
750 chuck 1.95 for (Uint32 i = 0; i < uriString.size(); i++)
751 {
752 Uint16 c = uriString[i];
753
|
754 david.dillard 1.131 if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
755 ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
756 {
757 Char16 highSurrogate = uriString[i];
758 Char16 lowSurrogate = uriString[++i];
|
759 david.dillard 1.121
|
760 david.dillard 1.131 _xmlWritter_appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));
761 }
|
762 chuck 1.95 else
763 {
|
764 david.dillard 1.121 _xmlWritter_appendChar(utf8, uriString[i]);
|
765 chuck 1.95 }
766 }
767
768 // Second, escape the non HTTP-safe chars
769 for (Uint32 i=0; i<utf8.size(); i++)
770 {
|
771 s.hills 1.99 _xmlWritter_encodeURIChar(encodedString, utf8[i]);
|
772 kumpf 1.84 }
773
774 return encodedString;
775 }
776
|
777 kumpf 1.29 //------------------------------------------------------------------------------
778 //
779 // appendLocalNameSpacePathElement()
780 //
781 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
782 //
783 //------------------------------------------------------------------------------
784
785 void XmlWriter::appendLocalNameSpacePathElement(
|
786 mike 1.125 Buffer& out,
|
787 kumpf 1.80 const CIMNamespaceName& nameSpace)
|
788 mike 1.23 {
|
789 mike 1.126 out << STRLIT("<LOCALNAMESPACEPATH>\n");
|
790 mike 1.23
|
791 david 1.103 char* nameSpaceCopy = strdup(nameSpace.getString().getCString());
|
792 chuck 1.105
|
793 david.dillard 1.131 #if !defined(PEGASUS_COMPILER_MSVC)
|
794 keith.petley 1.91 char *last;
795 for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;
|
796 kumpf 1.93 p = strtok_r(NULL, "/", &last))
|
797 keith.petley 1.91 #else
|
798 kumpf 1.76 for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))
|
799 keith.petley 1.91 #endif
|
800 mike 1.23 {
|
801 david.dillard 1.131 out << STRLIT("<NAMESPACE NAME=\"") << p << STRLIT("\"/>\n");
|
802 mike 1.23 }
|
803 kumpf 1.96 free(nameSpaceCopy);
|
804 mike 1.23
|
805 mike 1.126 out << STRLIT("</LOCALNAMESPACEPATH>\n");
|
806 mike 1.23 }
807
808 //------------------------------------------------------------------------------
809 //
|
810 kumpf 1.29 // appendNameSpacePathElement()
811 //
812 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
813 //
814 //------------------------------------------------------------------------------
815
816 void XmlWriter::appendNameSpacePathElement(
|
817 mike 1.125 Buffer& out,
|
818 kumpf 1.29 const String& host,
|
819 kumpf 1.80 const CIMNamespaceName& nameSpace)
|
820 kumpf 1.29 {
|
821 mike 1.126 out << STRLIT("<NAMESPACEPATH>\n");
822 out << STRLIT("<HOST>") << host << STRLIT("</HOST>\n");
|
823 kumpf 1.29 appendLocalNameSpacePathElement(out, nameSpace);
|
824 mike 1.126 out << STRLIT("</NAMESPACEPATH>\n");
|
825 kumpf 1.29 }
826
827 //------------------------------------------------------------------------------
828 //
829 // appendClassNameElement()
830 //
831 // <!ELEMENT CLASSNAME EMPTY>
832 // <!ATTLIST CLASSNAME
833 // %CIMName;>
834 //
835 //------------------------------------------------------------------------------
836
837 void XmlWriter::appendClassNameElement(
|
838 mike 1.125 Buffer& out,
|
839 kumpf 1.80 const CIMName& className)
|
840 kumpf 1.29 {
|
841 mike 1.126 out << STRLIT("<CLASSNAME NAME=\"") << className << STRLIT("\"/>\n");
|
842 kumpf 1.29 }
843
844 //------------------------------------------------------------------------------
845 //
846 // appendInstanceNameElement()
847 //
848 // <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
849 // <!ATTLIST INSTANCENAME
850 // %ClassName;>
851 //
852 //------------------------------------------------------------------------------
853
854 void XmlWriter::appendInstanceNameElement(
|
855 mike 1.125 Buffer& out,
|
856 kumpf 1.59 const CIMObjectPath& instanceName)
|
857 kumpf 1.29 {
|
858 mike 1.126 out << STRLIT("<INSTANCENAME CLASSNAME=\"");
859 out << instanceName.getClassName() << STRLIT("\">\n");
|
860 kumpf 1.29
|
861 mike 1.126 const Array<CIMKeyBinding>& keyBindings = instanceName.getKeyBindings();
|
862 kumpf 1.29 for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)
863 {
|
864 mike 1.126 out << STRLIT("<KEYBINDING NAME=\"");
865 out << keyBindings[i].getName() << STRLIT("\">\n");
|
866 kumpf 1.29
|
867 kumpf 1.79 if (keyBindings[i].getType() == CIMKeyBinding::REFERENCE)
|
868 kumpf 1.29 {
|
869 kumpf 1.59 CIMObjectPath ref = keyBindings[i].getValue();
|
870 kumpf 1.56 appendValueReferenceElement(out, ref, true);
|
871 kumpf 1.29 }
872 else {
|
873 mike 1.126 out << STRLIT("<KEYVALUE VALUETYPE=\"");
|
874 kumpf 1.68 out << keyBindingTypeToString(keyBindings[i].getType());
|
875 mike 1.126 out << STRLIT("\">");
|
876 kumpf 1.29
877 // fixed the special character problem - Markus
878
879 appendSpecial(out, keyBindings[i].getValue());
|
880 mike 1.126 out << STRLIT("</KEYVALUE>\n");
|
881 kumpf 1.29 }
|
882 mike 1.126 out << STRLIT("</KEYBINDING>\n");
|
883 kumpf 1.29 }
|
884 mike 1.126 out << STRLIT("</INSTANCENAME>\n");
|
885 kumpf 1.29 }
886
887 //------------------------------------------------------------------------------
888 //
889 // appendClassPathElement()
890 //
891 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
892 //
893 //------------------------------------------------------------------------------
894
895 void XmlWriter::appendClassPathElement(
|
896 mike 1.125 Buffer& out,
|
897 kumpf 1.59 const CIMObjectPath& classPath)
|
898 kumpf 1.29 {
|
899 mike 1.126 out << STRLIT("<CLASSPATH>\n");
|
900 kumpf 1.29 appendNameSpacePathElement(out,
901 classPath.getHost(),
902 classPath.getNameSpace());
903 appendClassNameElement(out, classPath.getClassName());
|
904 mike 1.126 out << STRLIT("</CLASSPATH>\n");
|
905 kumpf 1.29 }
906
907 //------------------------------------------------------------------------------
908 //
909 // appendInstancePathElement()
910 //
911 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
912 //
913 //------------------------------------------------------------------------------
914
915 void XmlWriter::appendInstancePathElement(
|
916 mike 1.125 Buffer& out,
|
917 kumpf 1.59 const CIMObjectPath& instancePath)
|
918 kumpf 1.29 {
|
919 mike 1.126 out << STRLIT("<INSTANCEPATH>\n");
|
920 kumpf 1.29 appendNameSpacePathElement(out,
921 instancePath.getHost(),
922 instancePath.getNameSpace());
923 appendInstanceNameElement(out, instancePath);
|
924 mike 1.126 out << STRLIT("</INSTANCEPATH>\n");
|
925 kumpf 1.29 }
926
927 //------------------------------------------------------------------------------
928 //
929 // appendLocalClassPathElement()
930 //
931 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
932 //
933 //------------------------------------------------------------------------------
934
935 void XmlWriter::appendLocalClassPathElement(
|
936 mike 1.125 Buffer& out,
|
937 kumpf 1.59 const CIMObjectPath& classPath)
|
938 kumpf 1.29 {
|
939 mike 1.126 out << STRLIT("<LOCALCLASSPATH>\n");
|
940 kumpf 1.29 appendLocalNameSpacePathElement(out, classPath.getNameSpace());
941 appendClassNameElement(out, classPath.getClassName());
|
942 mike 1.126 out << STRLIT("</LOCALCLASSPATH>\n");
|
943 kumpf 1.29 }
944
945 //------------------------------------------------------------------------------
946 //
947 // appendLocalInstancePathElement()
948 //
949 // <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>
950 //
951 //------------------------------------------------------------------------------
952
953 void XmlWriter::appendLocalInstancePathElement(
|
954 mike 1.125 Buffer& out,
|
955 kumpf 1.59 const CIMObjectPath& instancePath)
|
956 kumpf 1.29 {
|
957 mike 1.126 out << STRLIT("<LOCALINSTANCEPATH>\n");
|
958 kumpf 1.29 appendLocalNameSpacePathElement(out, instancePath.getNameSpace());
959 appendInstanceNameElement(out, instancePath);
|
960 mike 1.126 out << STRLIT("</LOCALINSTANCEPATH>\n");
|
961 kumpf 1.29 }
962
963 //------------------------------------------------------------------------------
964 //
|
965 kumpf 1.30 // appendLocalObjectPathElement()
966 //
|
967 kumpf 1.31 // If the reference refers to an instance, write a LOCALINSTANCEPATH;
968 // otherwise write a LOCALCLASSPATH.
|
969 kumpf 1.30 //
970 //------------------------------------------------------------------------------
971
972 void XmlWriter::appendLocalObjectPathElement(
|
973 mike 1.125 Buffer& out,
|
974 kumpf 1.59 const CIMObjectPath& objectPath)
|
975 kumpf 1.30 {
|
976 kumpf 1.68 //
977 // ATTN-CAKG-P2-20020726: The following condition does not correctly
978 // distinguish instanceNames from classNames in every case
|
979 david.dillard 1.121 // The instanceName of a singleton instance of a keyless class has no
|
980 kumpf 1.68 // key bindings
981 //
982 if (objectPath.getKeyBindings ().size () != 0)
|
983 kumpf 1.30 {
984 appendLocalInstancePathElement(out, objectPath);
985 }
986 else
987 {
988 appendLocalClassPathElement(out, objectPath);
989 }
990 }
991
992 //------------------------------------------------------------------------------
993 //
|
994 kumpf 1.54 // Helper functions for appendValueElement()
995 //
996 //------------------------------------------------------------------------------
997
|
998 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Boolean x)
|
999 kumpf 1.54 {
1000 XmlWriter::append(out, x);
1001 }
1002
|
1003 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Uint8 x)
|
1004 kumpf 1.54 {
1005 XmlWriter::append(out, Uint32(x));
1006 }
1007
|
1008 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Sint8 x)
|
1009 kumpf 1.54 {
1010 XmlWriter::append(out, Sint32(x));
1011 }
1012
|
1013 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Uint16 x)
|
1014 kumpf 1.54 {
1015 XmlWriter::append(out, Uint32(x));
1016 }
1017
|
1018 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Sint16 x)
|
1019 kumpf 1.54 {
1020 XmlWriter::append(out, Sint32(x));
1021 }
1022
|
1023 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Uint32 x)
|
1024 kumpf 1.54 {
1025 XmlWriter::append(out, x);
1026 }
1027
|
1028 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Sint32 x)
|
1029 kumpf 1.54 {
1030 XmlWriter::append(out, x);
1031 }
1032
|
1033 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Uint64 x)
|
1034 kumpf 1.54 {
1035 XmlWriter::append(out, x);
1036 }
1037
|
1038 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Sint64 x)
|
1039 kumpf 1.54 {
1040 XmlWriter::append(out, x);
1041 }
1042
|
1043 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Real32 x)
|
1044 kumpf 1.54 {
|
1045 chuck 1.102 XmlWriter::append(out, x);
|
1046 kumpf 1.54 }
1047
|
1048 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, Real64 x)
|
1049 kumpf 1.54 {
1050 XmlWriter::append(out, x);
1051 }
1052
|
1053 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, const Char16& x)
|
1054 kumpf 1.54 {
1055 XmlWriter::appendSpecial(out, x);
1056 }
1057
|
1058 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, const String& x)
|
1059 kumpf 1.54 {
1060 XmlWriter::appendSpecial(out, x);
1061 }
1062
|
1063 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, const CIMDateTime& x)
|
1064 kumpf 1.54 {
|
1065 kumpf 1.72 out << x.toString(); //ATTN: append() method?
|
1066 kumpf 1.54 }
1067
|
1068 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, const CIMObjectPath& x)
|
1069 kumpf 1.54 {
|
1070 kumpf 1.56 XmlWriter::appendValueReferenceElement(out, x, true);
|
1071 kumpf 1.54 }
1072
|
1073 mike 1.125 inline void _xmlWritter_appendValue(Buffer& out, const CIMObject& x)
|
1074 dave.sudlik 1.114 {
|
1075 dave.sudlik 1.120 String myStr = x.toString();
1076 _xmlWritter_appendValue(out, myStr);
|
1077 dave.sudlik 1.114 }
1078
|
1079 mike 1.126 void _xmlWritter_appendValueArray(
1080 Buffer& out, const CIMObjectPath* p, Uint32 size)
|
1081 kumpf 1.54 {
|
1082 mike 1.126 out << STRLIT("<VALUE.REFARRAY>\n");
|
1083 kumpf 1.54 while (size--)
1084 {
|
1085 s.hills 1.99 _xmlWritter_appendValue(out, *p++);
|
1086 kumpf 1.54 }
|
1087 mike 1.126 out << STRLIT("</VALUE.REFARRAY>\n");
|
1088 kumpf 1.54 }
1089
1090 template<class T>
|
1091 mike 1.125 void _xmlWritter_appendValueArray(Buffer& out, const T* p, Uint32 size)
|
1092 kumpf 1.54 {
|
1093 mike 1.126 out << STRLIT("<VALUE.ARRAY>\n");
|
1094 kumpf 1.54
1095 while (size--)
1096 {
|
1097 mike 1.126 out << STRLIT("<VALUE>");
|
1098 s.hills 1.99 _xmlWritter_appendValue(out, *p++);
|
1099 mike 1.126 out << STRLIT("</VALUE>\n");
|
1100 kumpf 1.54 }
1101
|
1102 mike 1.126 out << STRLIT("</VALUE.ARRAY>\n");
|
1103 kumpf 1.54 }
1104
1105 //------------------------------------------------------------------------------
1106 //
1107 // appendValueElement()
1108 //
|
1109 kumpf 1.55 // <!ELEMENT VALUE (#PCDATA)>
1110 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1111 // <!ELEMENT VALUE.REFERENCE
1112 // (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
1113 // INSTANCENAME)>
1114 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
1115 //
|
1116 kumpf 1.54 //------------------------------------------------------------------------------
1117
1118 void XmlWriter::appendValueElement(
|
1119 mike 1.125 Buffer& out,
|
1120 kumpf 1.54 const CIMValue& value)
1121 {
1122 if (value.isNull())
1123 {
1124 return;
1125 }
1126 if (value.isArray())
1127 {
1128 switch (value.getType())
1129 {
|
1130 kumpf 1.66 case CIMTYPE_BOOLEAN:
|
1131 kumpf 1.54 {
1132 Array<Boolean> a;
1133 value.get(a);
|
1134 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1135 kumpf 1.54 break;
1136 }
1137
|
1138 kumpf 1.66 case CIMTYPE_UINT8:
|
1139 kumpf 1.54 {
1140 Array<Uint8> a;
1141 value.get(a);
|
1142 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1143 kumpf 1.54 break;
1144 }
1145
|
1146 kumpf 1.66 case CIMTYPE_SINT8:
|
1147 kumpf 1.54 {
1148 Array<Sint8> a;
1149 value.get(a);
|
1150 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1151 kumpf 1.54 break;
1152 }
1153
|
1154 kumpf 1.66 case CIMTYPE_UINT16:
|
1155 kumpf 1.54 {
1156 Array<Uint16> a;
1157 value.get(a);
|
1158 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1159 kumpf 1.54 break;
1160 }
1161
|
1162 kumpf 1.66 case CIMTYPE_SINT16:
|
1163 kumpf 1.54 {
1164 Array<Sint16> a;
1165 value.get(a);
|
1166 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1167 kumpf 1.54 break;
1168 }
1169
|
1170 kumpf 1.66 case CIMTYPE_UINT32:
|
1171 kumpf 1.54 {
1172 Array<Uint32> a;
1173 value.get(a);
|
1174 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1175 kumpf 1.54 break;
1176 }
1177
|
1178 kumpf 1.66 case CIMTYPE_SINT32:
|
1179 kumpf 1.54 {
1180 Array<Sint32> a;
1181 value.get(a);
|
1182 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1183 kumpf 1.54 break;
1184 }
1185
|
1186 kumpf 1.66 case CIMTYPE_UINT64:
|
1187 kumpf 1.54 {
1188 Array<Uint64> a;
1189 value.get(a);
|
1190 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1191 kumpf 1.54 break;
1192 }
1193
|
1194 kumpf 1.66 case CIMTYPE_SINT64:
|
1195 kumpf 1.54 {
1196 Array<Sint64> a;
1197 value.get(a);
|
1198 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1199 kumpf 1.54 break;
1200 }
1201
|
1202 kumpf 1.66 case CIMTYPE_REAL32:
|
1203 kumpf 1.54 {
1204 Array<Real32> a;
1205 value.get(a);
|
1206 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1207 kumpf 1.54 break;
1208 }
1209
|
1210 kumpf 1.66 case CIMTYPE_REAL64:
|
1211 kumpf 1.54 {
1212 Array<Real64> a;
1213 value.get(a);
|
1214 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1215 kumpf 1.54 break;
1216 }
1217
|
1218 kumpf 1.66 case CIMTYPE_CHAR16:
|
1219 kumpf 1.54 {
1220 Array<Char16> a;
1221 value.get(a);
|
1222 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1223 kumpf 1.54 break;
1224 }
1225
|
1226 kumpf 1.66 case CIMTYPE_STRING:
|
1227 kumpf 1.54 {
|
1228 mike 1.126 const String* data;
1229 Uint32 size;
1230 value._get(data, size);
1231 _xmlWritter_appendValueArray(out, data, size);
|
1232 kumpf 1.54 break;
1233 }
1234
|
1235 kumpf 1.66 case CIMTYPE_DATETIME:
|
1236 kumpf 1.54 {
1237 Array<CIMDateTime> a;
1238 value.get(a);
|
1239 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1240 kumpf 1.54 break;
1241 }
1242
|
1243 kumpf 1.66 case CIMTYPE_REFERENCE:
|
1244 kumpf 1.54 {
|
1245 kumpf 1.59 Array<CIMObjectPath> a;
|
1246 kumpf 1.54 value.get(a);
|
1247 s.hills 1.99 _xmlWritter_appendValueArray(out, a.getData(), a.size());
|
1248 kumpf 1.54 break;
1249 }
1250
|
1251 dave.sudlik 1.114 case CIMTYPE_OBJECT:
1252 {
1253 Array<CIMObject> a;
1254 value.get(a);
1255 _xmlWritter_appendValueArray(out, a.getData(), a.size());
1256 break;
1257 }
|
1258 a.dunfey 1.132.2.1 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1259 case CIMTYPE_INSTANCE:
1260 {
1261 Array<CIMInstance> a;
1262 value.get(a);
1263 _xmlWritter_appendValueArray(out, a.getData(), a.size());
1264 break;
1265 }
1266 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
1267 kumpf 1.54 default:
|
1268 kumpf 1.78 PEGASUS_ASSERT(false);
|
1269 kumpf 1.54 }
1270 }
|
1271 kumpf 1.66 else if (value.getType() == CIMTYPE_REFERENCE)
|
1272 kumpf 1.54 {
1273 // Has to be separate because it uses VALUE.REFERENCE tag
|
1274 kumpf 1.59 CIMObjectPath v;
|
1275 kumpf 1.54 value.get(v);
|
1276 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1277 kumpf 1.54 }
1278 else
1279 {
|
1280 mike 1.126 out << STRLIT("<VALUE>");
|
1281 kumpf 1.54
1282 switch (value.getType())
1283 {
|
1284 kumpf 1.66 case CIMTYPE_BOOLEAN:
|
1285 kumpf 1.54 {
1286 Boolean v;
1287 value.get(v);
|
1288 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1289 kumpf 1.54 break;
1290 }
1291
|
1292 kumpf 1.66 case CIMTYPE_UINT8:
|
1293 kumpf 1.54 {
1294 Uint8 v;
1295 value.get(v);
|
1296 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1297 kumpf 1.54 break;
1298 }
1299
|
1300 kumpf 1.66 case CIMTYPE_SINT8:
|
1301 kumpf 1.54 {
1302 Sint8 v;
1303 value.get(v);
|
1304 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1305 kumpf 1.54 break;
1306 }
1307
|
1308 kumpf 1.66 case CIMTYPE_UINT16:
|
1309 kumpf 1.54 {
1310 Uint16 v;
1311 value.get(v);
|
1312 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1313 kumpf 1.54 break;
1314 }
1315
|
1316 kumpf 1.66 case CIMTYPE_SINT16:
|
1317 kumpf 1.54 {
1318 Sint16 v;
1319 value.get(v);
|
1320 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1321 kumpf 1.54 break;
1322 }
1323
|
1324 kumpf 1.66 case CIMTYPE_UINT32:
|
1325 kumpf 1.54 {
1326 Uint32 v;
1327 value.get(v);
|
1328 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1329 kumpf 1.54 break;
1330 }
1331
|
1332 kumpf 1.66 case CIMTYPE_SINT32:
|
1333 kumpf 1.54 {
1334 Sint32 v;
1335 value.get(v);
|
1336 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1337 kumpf 1.54 break;
1338 }
1339
|
1340 kumpf 1.66 case CIMTYPE_UINT64:
|
1341 kumpf 1.54 {
1342 Uint64 v;
1343 value.get(v);
|
1344 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1345 kumpf 1.54 break;
1346 }
1347
|
1348 kumpf 1.66 case CIMTYPE_SINT64:
|
1349 kumpf 1.54 {
1350 Sint64 v;
1351 value.get(v);
|
1352 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1353 kumpf 1.54 break;
1354 }
1355
|
1356 kumpf 1.66 case CIMTYPE_REAL32:
|
1357 kumpf 1.54 {
1358 Real32 v;
1359 value.get(v);
|
1360 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1361 kumpf 1.54 break;
1362 }
1363
|
1364 kumpf 1.66 case CIMTYPE_REAL64:
|
1365 kumpf 1.54 {
1366 Real64 v;
1367 value.get(v);
|
1368 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1369 kumpf 1.54 break;
1370 }
1371
|
1372 kumpf 1.66 case CIMTYPE_CHAR16:
|
1373 kumpf 1.54 {
1374 Char16 v;
1375 value.get(v);
|
1376 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1377 kumpf 1.54 break;
1378 }
1379
|
1380 kumpf 1.66 case CIMTYPE_STRING:
|
1381 kumpf 1.54 {
1382 String v;
1383 value.get(v);
|
1384 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1385 kumpf 1.54 break;
1386 }
1387
|
1388 kumpf 1.66 case CIMTYPE_DATETIME:
|
1389 kumpf 1.54 {
1390 CIMDateTime v;
1391 value.get(v);
|
1392 s.hills 1.99 _xmlWritter_appendValue(out, v);
|
1393 kumpf 1.54 break;
1394 }
1395
|
1396 dave.sudlik 1.114 case CIMTYPE_OBJECT:
1397 {
1398 CIMObject v;
1399 value.get(v);
1400 _xmlWritter_appendValue(out, v);
1401 break;
1402 }
|
1403 a.dunfey 1.132.2.1 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1404 case CIMTYPE_INSTANCE:
1405 {
1406 CIMInstance v;
1407 value.get(v);
1408 _xmlWritter_appendValue(out, v);
1409 break;
1410 }
1411 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
1412 kumpf 1.54 default:
|
1413 kumpf 1.78 PEGASUS_ASSERT(false);
|
1414 kumpf 1.54 }
1415
|
1416 mike 1.126 out << STRLIT("</VALUE>\n");
|
1417 kumpf 1.54 }
1418 }
1419
1420 void XmlWriter::printValueElement(
1421 const CIMValue& value,
1422 PEGASUS_STD(ostream)& os)
1423 {
|
1424 mike 1.125 Buffer tmp;
|
1425 kumpf 1.54 appendValueElement(tmp, value);
1426 tmp.append('\0');
1427 os << tmp.getData() << PEGASUS_STD(endl);
1428 }
1429
1430 //------------------------------------------------------------------------------
1431 //
|
1432 kumpf 1.56 // appendValueObjectWithPathElement()
1433 //
1434 // <!ELEMENT VALUE.OBJECTWITHPATH
1435 // ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
1436 //
1437 //------------------------------------------------------------------------------
1438
1439 void XmlWriter::appendValueObjectWithPathElement(
|
1440 mike 1.125 Buffer& out,
|
1441 kumpf 1.62 const CIMObject& objectWithPath)
|
1442 kumpf 1.56 {
|
1443 mike 1.126 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
|
1444 kumpf 1.56
|
1445 kumpf 1.62 appendValueReferenceElement(out, objectWithPath.getPath (), false);
1446 appendObjectElement(out, objectWithPath);
|
1447 kumpf 1.56
|
1448 mike 1.126 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
|
1449 kumpf 1.56 }
1450
1451 //------------------------------------------------------------------------------
1452 //
1453 // appendValueReferenceElement()
1454 //
1455 // <!ELEMENT VALUE.REFERENCE
1456 // (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
1457 // INSTANCENAME)>
1458 //
1459 //------------------------------------------------------------------------------
1460
1461 void XmlWriter::appendValueReferenceElement(
|
1462 mike 1.125 Buffer& out,
|
1463 kumpf 1.59 const CIMObjectPath& reference,
|
1464 kumpf 1.56 Boolean putValueWrapper)
1465 {
1466 if (putValueWrapper)
|
1467 mike 1.126 out << STRLIT("<VALUE.REFERENCE>\n");
|
1468 kumpf 1.56
1469 // See if it is a class or instance reference (instance references have
1470 // key-bindings; class references do not).
|
1471 kumpf 1.68 //
1472 // ATTN-CAKG-P2-20020726: The following condition does not correctly
1473 // distinguish instanceNames from classNames in every case
1474 // The instanceName of a singleton instance of a keyless class has no
1475 // key bindings
1476 //
|
1477 kumpf 1.56
|
1478 mike 1.126 const Array<CIMKeyBinding>& kbs = reference.getKeyBindings();
|
1479 sage 1.60
|
1480 kumpf 1.56 if (kbs.size())
1481 {
1482 if (reference.getHost().size())
1483 {
1484 appendInstancePathElement(out, reference);
1485 }
|
1486 kumpf 1.67 else if (!reference.getNameSpace().isNull())
|
1487 kumpf 1.56 {
1488 appendLocalInstancePathElement(out, reference);
1489 }
1490 else
1491 {
1492 appendInstanceNameElement(out, reference);
1493 }
1494 }
1495 else
1496 {
1497 if (reference.getHost().size())
1498 {
1499 appendClassPathElement(out, reference);
1500 }
|
1501 kumpf 1.67 else if (!reference.getNameSpace().isNull())
|
1502 kumpf 1.56 {
1503 appendLocalClassPathElement(out, reference);
1504 }
1505 else
1506 {
1507 appendClassNameElement(out, reference.getClassName());
1508 }
1509 }
1510
1511 if (putValueWrapper)
|
1512 mike 1.126 out << STRLIT("</VALUE.REFERENCE>\n");
|
1513 kumpf 1.56 }
1514
1515 void XmlWriter::printValueReferenceElement(
|
1516 kumpf 1.59 const CIMObjectPath& reference,
|
1517 kumpf 1.56 PEGASUS_STD(ostream)& os)
1518 {
|
1519 mike 1.125 Buffer tmp;
|
1520 kumpf 1.56 appendValueReferenceElement(tmp, reference, true);
1521 tmp.append('\0');
1522 indentedPrint(os, tmp.getData());
1523 }
1524
1525 //------------------------------------------------------------------------------
1526 //
1527 // appendValueNamedInstanceElement()
1528 //
1529 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
1530 //
1531 //------------------------------------------------------------------------------
1532
1533 void XmlWriter::appendValueNamedInstanceElement(
|
1534 mike 1.125 Buffer& out,
|
1535 kumpf 1.61 const CIMInstance& namedInstance)
|
1536 kumpf 1.56 {
|
1537 mike 1.126 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
|
1538 kumpf 1.56
|
1539 kumpf 1.61 appendInstanceNameElement(out, namedInstance.getPath ());
1540 appendInstanceElement(out, namedInstance);
|
1541 kumpf 1.56
|
1542 mike 1.126 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
|
1543 kumpf 1.56 }
1544
1545 //------------------------------------------------------------------------------
1546 //
|
1547 kumpf 1.55 // appendClassElement()
1548 //
1549 // <!ELEMENT CLASS
1550 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
|
1551 kumpf 1.56 // <!ATTLIST CLASS
|
1552 kumpf 1.55 // %CIMName;
1553 // %SuperClass;>
1554 //
1555 //------------------------------------------------------------------------------
1556
1557 void XmlWriter::appendClassElement(
|
1558 mike 1.125 Buffer& out,
|
1559 kumpf 1.55 const CIMConstClass& cimclass)
1560 {
1561 cimclass._checkRep();
1562 cimclass._rep->toXml(out);
1563 }
1564
1565 void XmlWriter::printClassElement(
1566 const CIMConstClass& cimclass,
1567 PEGASUS_STD(ostream)& os)
1568 {
|
1569 mike 1.125 Buffer tmp;
|
1570 kumpf 1.55 appendClassElement(tmp, cimclass);
1571 tmp.append('\0');
1572 indentedPrint(os, tmp.getData(), 4);
1573 }
1574
1575 //------------------------------------------------------------------------------
1576 //
1577 // appendInstanceElement()
1578 //
1579 // <!ELEMENT INSTANCE
1580 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
1581 // <!ATTLIST INSTANCE
1582 // %ClassName;>
1583 //
1584 //------------------------------------------------------------------------------
1585
1586 void XmlWriter::appendInstanceElement(
|
1587 mike 1.125 Buffer& out,
|
1588 kumpf 1.55 const CIMConstInstance& instance)
1589 {
1590 instance._checkRep();
1591 instance._rep->toXml(out);
1592 }
1593
1594 void XmlWriter::printInstanceElement(
1595 const CIMConstInstance& instance,
1596 PEGASUS_STD(ostream)& os)
1597 {
|
1598 mike 1.125 Buffer tmp;
|
1599 kumpf 1.55 appendInstanceElement(tmp, instance);
1600 tmp.append('\0');
1601 os << tmp.getData() << PEGASUS_STD(endl);
1602 }
1603
1604 //------------------------------------------------------------------------------
1605 //
|
1606 kumpf 1.56 // appendObjectElement()
1607 //
1608 // May refer to a CLASS or an INSTANCE
1609 //
1610 //------------------------------------------------------------------------------
1611
1612 void XmlWriter::appendObjectElement(
|
1613 mike 1.125 Buffer& out,
|
1614 kumpf 1.56 const CIMConstObject& object)
1615 {
|
1616 kumpf 1.73 if (object.isClass())
|
1617 kumpf 1.56 {
1618 CIMConstClass c(object);
1619 appendClassElement(out, c);
1620 }
|
1621 kumpf 1.73 else if (object.isInstance())
|
1622 kumpf 1.56 {
|
1623 kumpf 1.73 CIMConstInstance i(object);
1624 appendInstanceElement(out, i);
|
1625 kumpf 1.56 }
|
1626 kumpf 1.73 // else PEGASUS_ASSERT(0);
|
1627 kumpf 1.56 }
1628
1629 //------------------------------------------------------------------------------
1630 //
1631 // appendPropertyElement()
1632 //
1633 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
1634 // <!ATTLIST PROPERTY
1635 // %CIMName;
1636 // %CIMType; #REQUIRED
1637 // %ClassOrigin;
1638 // %Propagated;>
1639 //
1640 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
1641 // <!ATTLIST PROPERTY.ARRAY
1642 // %CIMName;
1643 // %CIMType; #REQUIRED
1644 // %ArraySize;
1645 // %ClassOrigin;
1646 // %Propagated;>
1647 //
1648 kumpf 1.56 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
1649 // <!ATTLIST PROPERTY.REFERENCE
1650 // %CIMName;
1651 // %ReferenceClass;
1652 // %ClassOrigin;
1653 // %Propagated;>
1654 //
1655 //------------------------------------------------------------------------------
1656
1657 void XmlWriter::appendPropertyElement(
|
1658 mike 1.125 Buffer& out,
|
1659 kumpf 1.56 const CIMConstProperty& property)
1660 {
1661 property._checkRep();
1662 property._rep->toXml(out);
1663 }
1664
1665 void XmlWriter::printPropertyElement(
1666 const CIMConstProperty& property,
1667 PEGASUS_STD(ostream)& os)
1668 {
|
1669 mike 1.125 Buffer tmp;
|
1670 kumpf 1.56 appendPropertyElement(tmp, property);
1671 tmp.append('\0');
1672 os << tmp.getData() << PEGASUS_STD(endl);
1673 }
1674
1675 //------------------------------------------------------------------------------
1676 //
1677 // appendMethodElement()
1678 //
1679 // <!ELEMENT METHOD (QUALIFIER*,
1680 // (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
1681 // <!ATTLIST METHOD
1682 // %CIMName;
1683 // %CIMType; #IMPLIED
1684 // %ClassOrigin;
1685 // %Propagated;>
1686 //
1687 //------------------------------------------------------------------------------
1688
1689 void XmlWriter::appendMethodElement(
|
1690 mike 1.125 Buffer& out,
|
1691 kumpf 1.56 const CIMConstMethod& method)
1692 {
1693 method._checkRep();
1694 method._rep->toXml(out);
1695 }
1696
1697 void XmlWriter::printMethodElement(
1698 const CIMConstMethod& method,
1699 PEGASUS_STD(ostream)& os)
1700 {
|
1701 mike 1.125 Buffer tmp;
|
1702 kumpf 1.56 appendMethodElement(tmp, method);
1703 tmp.append('\0');
1704 os << tmp.getData() << PEGASUS_STD(endl);
1705 }
1706
1707 //------------------------------------------------------------------------------
1708 //
1709 // appendParameterElement()
1710 //
1711 // <!ELEMENT PARAMETER (QUALIFIER*)>
1712 // <!ATTLIST PARAMETER
1713 // %CIMName;
1714 // %CIMType; #REQUIRED>
1715 //
1716 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
1717 // <!ATTLIST PARAMETER.REFERENCE
1718 // %CIMName;
1719 // %ReferenceClass;>
1720 //
1721 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
1722 // <!ATTLIST PARAMETER.ARRAY
1723 kumpf 1.56 // %CIMName;
1724 // %CIMType; #REQUIRED
1725 // %ArraySize;>
1726 //
1727 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
1728 // <!ATTLIST PARAMETER.REFARRAY
1729 // %CIMName;
1730 // %ReferenceClass;
1731 // %ArraySize;>
1732 //
1733 //------------------------------------------------------------------------------
1734
1735 void XmlWriter::appendParameterElement(
|
1736 mike 1.125 Buffer& out,
|
1737 kumpf 1.56 const CIMConstParameter& parameter)
1738 {
1739 parameter._checkRep();
1740 parameter._rep->toXml(out);
1741 }
1742
1743 void XmlWriter::printParameterElement(
1744 const CIMConstParameter& parameter,
1745 PEGASUS_STD(ostream)& os)
1746 {
|
1747 mike 1.125 Buffer tmp;
|
1748 kumpf 1.56 appendParameterElement(tmp, parameter);
1749 tmp.append('\0');
1750 os << tmp.getData() << PEGASUS_STD(endl);
1751 }
1752
1753 //------------------------------------------------------------------------------
1754 //
1755 // appendParamValueElement()
1756 //
1757 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
1758 // <!ATTLIST PARAMVALUE
1759 // %CIMName;>
1760 //
1761 //------------------------------------------------------------------------------
1762
1763 void XmlWriter::appendParamValueElement(
|
1764 mike 1.125 Buffer& out,
|
1765 kumpf 1.56 const CIMParamValue& paramValue)
1766 {
1767 paramValue._checkRep();
1768 paramValue._rep->toXml(out);
1769 }
1770
1771 void XmlWriter::printParamValueElement(
1772 const CIMParamValue& paramValue,
1773 PEGASUS_STD(ostream)& os)
1774 {
|
1775 mike 1.125 Buffer tmp;
|
1776 kumpf 1.56 appendParamValueElement(tmp, paramValue);
1777 tmp.append('\0');
1778 os << tmp.getData() << PEGASUS_STD(endl);
1779 }
1780
1781 //------------------------------------------------------------------------------
1782 //
1783 // appendQualifierElement()
1784 //
1785 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
1786 // <!ATTLIST QUALIFIER
1787 // %CIMName;
1788 // %CIMType; #REQUIRED
1789 // %Propagated;
1790 // %QualifierFlavor;>
1791 //
1792 //------------------------------------------------------------------------------
1793
1794 void XmlWriter::appendQualifierElement(
|
1795 mike 1.125 Buffer& out,
|
1796 kumpf 1.56 const CIMConstQualifier& qualifier)
1797 {
1798 qualifier._checkRep();
1799 qualifier._rep->toXml(out);
1800 }
1801
1802 void XmlWriter::printQualifierElement(
1803 const CIMConstQualifier& qualifier,
1804 PEGASUS_STD(ostream)& os)
1805 {
|
1806 mike 1.125 Buffer tmp;
|
1807 kumpf 1.56 appendQualifierElement(tmp, qualifier);
1808 tmp.append('\0');
1809 os << tmp.getData() << PEGASUS_STD(endl);
1810 }
1811
1812 //------------------------------------------------------------------------------
1813 //
1814 // appendQualifierDeclElement()
1815 //
1816 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
1817 // <!ATTLIST QUALIFIER.DECLARATION
1818 // %CIMName;
1819 // %CIMType; #REQUIRED
1820 // ISARRAY (true|false) #IMPLIED
1821 // %ArraySize;
1822 // %QualifierFlavor;>
1823 //
1824 //------------------------------------------------------------------------------
1825
1826 void XmlWriter::appendQualifierDeclElement(
|
1827 mike 1.125 Buffer& out,
|
1828 kumpf 1.56 const CIMConstQualifierDecl& qualifierDecl)
1829 {
1830 qualifierDecl._checkRep();
1831 qualifierDecl._rep->toXml(out);
1832 }
1833
1834 void XmlWriter::printQualifierDeclElement(
1835 const CIMConstQualifierDecl& qualifierDecl,
1836 PEGASUS_STD(ostream)& os)
1837 {
|
1838 mike 1.125 Buffer tmp;
|
1839 kumpf 1.56 appendQualifierDeclElement(tmp, qualifierDecl);
1840 tmp.append('\0');
1841 os << tmp.getData() << PEGASUS_STD(endl);
1842 }
1843
1844 //------------------------------------------------------------------------------
1845 //
|
1846 kumpf 1.57 // appendQualifierFlavorEntity()
1847 //
1848 // <!ENTITY % QualifierFlavor "OVERRIDABLE (true|false) 'true'
1849 // TOSUBCLASS (true|false) 'true'
1850 // TOINSTANCE (true|false) 'false'
1851 // TRANSLATABLE (true|false) 'false'">
1852 //
1853 //------------------------------------------------------------------------------
1854
1855 void XmlWriter::appendQualifierFlavorEntity(
|
1856 mike 1.125 Buffer& out,
|
1857 kumpf 1.70 const CIMFlavor & flavor)
|
1858 kumpf 1.57 {
|
1859 kumpf 1.70 if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))
|
1860 mike 1.126 out << STRLIT(" OVERRIDABLE=\"false\"");
|
1861 kumpf 1.57
|
1862 kumpf 1.70 if (!(flavor.hasFlavor (CIMFlavor::TOSUBCLASS)))
|
1863 mike 1.126 out << STRLIT(" TOSUBCLASS=\"false\"");
|
1864 kumpf 1.57
|
1865 kumpf 1.70 if (flavor.hasFlavor (CIMFlavor::TOINSTANCE))
|
1866 mike 1.126 out << STRLIT(" TOINSTANCE=\"true\"");
|
1867 kumpf 1.57
|
1868 kumpf 1.70 if (flavor.hasFlavor (CIMFlavor::TRANSLATABLE))
|
1869 mike 1.126 out << STRLIT(" TRANSLATABLE=\"true\"");
|
1870 kumpf 1.57 }
1871
1872 //------------------------------------------------------------------------------
1873 //
|
1874 kumpf 1.58 // appendScopeElement()
1875 //
1876 // <!ELEMENT SCOPE EMPTY>
1877 // <!ATTLIST SCOPE
1878 // CLASS (true|false) 'false'
1879 // ASSOCIATION (true|false) 'false'
1880 // REFERENCE (true|false) 'false'
1881 // PROPERTY (true|false) 'false'
1882 // METHOD (true|false) 'false'
1883 // PARAMETER (true|false) 'false'
1884 // INDICATION (true|false) 'false'>
1885 //
1886 //------------------------------------------------------------------------------
1887
1888 void XmlWriter::appendScopeElement(
|
1889 mike 1.125 Buffer& out,
|
1890 kumpf 1.69 const CIMScope & scope)
|
1891 kumpf 1.58 {
|
1892 kumpf 1.69 if (!(scope.equal (CIMScope ())))
|
1893 kumpf 1.58 {
|
1894 mike 1.126 out << STRLIT("<SCOPE");
|
1895 kumpf 1.58
|
1896 kumpf 1.69 if (scope.hasScope (CIMScope::CLASS))
|
1897 mike 1.126 out << STRLIT(" CLASS=\"true\"");
|
1898 kumpf 1.58
|
1899 kumpf 1.69 if (scope.hasScope (CIMScope::ASSOCIATION))
|
1900 mike 1.126 out << STRLIT(" ASSOCIATION=\"true\"");
|
1901 kumpf 1.58
|
1902 kumpf 1.69 if (scope.hasScope (CIMScope::REFERENCE))
|
1903 mike 1.126 out << STRLIT(" REFERENCE=\"true\"");
|
1904 kumpf 1.58
|
1905 kumpf 1.69 if (scope.hasScope (CIMScope::PROPERTY))
|
1906 mike 1.126 out << STRLIT(" PROPERTY=\"true\"");
|
1907 kumpf 1.58
|
1908 kumpf 1.69 if (scope.hasScope (CIMScope::METHOD))
|
1909 mike 1.126 out << STRLIT(" METHOD=\"true\"");
|
1910 kumpf 1.58
|
1911 kumpf 1.69 if (scope.hasScope (CIMScope::PARAMETER))
|
1912 mike 1.126 out << STRLIT(" PARAMETER=\"true\"");
|
1913 kumpf 1.58
|
1914 kumpf 1.69 if (scope.hasScope (CIMScope::INDICATION))
|
1915 mike 1.126 out << STRLIT(" INDICATION=\"true\"");
|
1916 kumpf 1.58
|
1917 mike 1.126 out << STRLIT("/>");
|
1918 kumpf 1.58 }
1919 }
1920
|
1921 david.dillard 1.121 // l10n - added content language and accept language support to
|
1922 chuck 1.89 // the header methods below
1923
|
1924 kumpf 1.58 //------------------------------------------------------------------------------
1925 //
|
1926 kumpf 1.27 // appendMethodCallHeader()
|
1927 mike 1.23 //
|
1928 kumpf 1.31 // Build HTTP method call request header.
|
1929 mike 1.23 //
1930 //------------------------------------------------------------------------------
1931
|
1932 kumpf 1.27 void XmlWriter::appendMethodCallHeader(
|
1933 mike 1.125 Buffer& out,
|
1934 mike 1.23 const char* host,
|
1935 kumpf 1.80 const CIMName& cimMethod,
|
1936 mike 1.23 const String& cimObject,
|
1937 mike 1.24 const String& authenticationHeader,
|
1938 kumpf 1.82 HttpMethod httpMethod,
|
1939 david.dillard 1.121 const AcceptLanguages & acceptLanguages,
|
1940 chuck 1.89 const ContentLanguages & contentLanguages,
|
1941 kumpf 1.27 Uint32 contentLength)
|
1942 mike 1.23 {
1943 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
1944
|
1945 karl 1.81 // ATTN: KS 20020926 - Temporary change to issue only POST. This may
1946 // be changed in the DMTF CIM Operations standard in the future.
1947 // If we kept M-Post we would have to retry with Post. Does not
1948 // do that in client today. Permanent change is to retry until spec
1949 // updated. This change is temp to finish tests or until the retry
1950 // installed. Required because of change to wbemservices cimom
|
1951 kumpf 1.82 if (httpMethod == HTTP_METHOD_M_POST)
1952 {
|
1953 mike 1.126 out << STRLIT("M-POST /cimom HTTP/1.1\r\n");
|
1954 kumpf 1.82 }
1955 else
1956 {
|
1957 mike 1.126 out << STRLIT("POST /cimom HTTP/1.1\r\n");
|
1958 kumpf 1.82 }
|
1959 mike 1.126 out << STRLIT("HOST: ") << host << STRLIT("\r\n");
1960 out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
1961 OUTPUT_CONTENTLENGTH;
|
1962 chuck 1.89 if (acceptLanguages.size() > 0)
1963 {
|
1964 mike 1.126 out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
|
1965 chuck 1.89 }
1966 if (contentLanguages.size() > 0)
1967 {
|
1968 mike 1.126 out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
|
1969 david.dillard 1.121 }
|
1970 brian.campbell 1.107
|
1971 brian.campbell 1.113 #ifdef PEGASUS_DEBUG
|
1972 david.dillard 1.121 // backdoor environment variable to turn OFF client requesting transfer
|
1973 brian.campbell 1.107 // encoding. The default is on. to turn off, set this variable to zero.
1974 // This should be removed when stable. This should only be turned off in
1975 // a debugging/testing environment.
|
1976 brian.campbell 1.113
|
1977 david.dillard 1.121 static const char *clientTransferEncodingOff =
|
1978 brian.campbell 1.107 getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
1979 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
|
1980 a.dunfey 1.110 #endif
|
1981 brian.campbell 1.113
|
1982 mike 1.126 out << STRLIT("TE: chunked, trailers\r\n");
|
1983 brian.campbell 1.107
|
1984 kumpf 1.82 if (httpMethod == HTTP_METHOD_M_POST)
1985 {
|
1986 mike 1.126 out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
1987 out << nn << STRLIT("\r\n");
1988 out << nn << STRLIT("-CIMOperation: MethodCall\r\n");
1989 out << nn << STRLIT("-CIMMethod: ")
1990 << encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n");
|
1991 david.dillard 1.130 out << nn << STRLIT("-CIMObject: ") << encodeURICharacters(cimObject)
|
1992 mike 1.126 << STRLIT("\r\n");
|
1993 kumpf 1.82 }
|
1994 david.dillard 1.121 else
|
1995 kumpf 1.82 {
|
1996 mike 1.126 out << STRLIT("CIMOperation: MethodCall\r\n");
1997 out << STRLIT("CIMMethod: ") << encodeURICharacters(cimMethod.getString())
1998 << STRLIT("\r\n");
|
1999 david.dillard 1.130 out << STRLIT("CIMObject: ") << encodeURICharacters(cimObject)
|
2000 mike 1.126 << STRLIT("\r\n");
|
2001 kumpf 1.82 }
2002
|
2003 mike 1.24 if (authenticationHeader.size())
2004 {
|
2005 mike 1.126 out << authenticationHeader << STRLIT("\r\n");
|
2006 mike 1.24 }
|
2007 brian.campbell 1.107
|
2008 mike 1.126 out << STRLIT("\r\n");
|
2009 mike 1.23 }
2010
|
2011 chuck 1.89
|
2012 kumpf 1.27 void XmlWriter::appendMethodResponseHeader(
|
2013 mike 1.125 Buffer& out,
|
2014 w.white 1.108 HttpMethod httpMethod,
2015 const ContentLanguages & contentLanguages,
2016 Uint32 contentLength,
|
2017 david.dillard 1.130 Uint64 serverResponseTime)
|
2018 brian.campbell 1.113 {
|
2019 w.white 1.108 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
|
2020 mike 1.126 out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");
|
2021 w.white 1.108 STAT_SERVERTIME
|
2022 mike 1.126 out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
|
2023 w.white 1.108 OUTPUT_CONTENTLENGTH;
2024
2025 if (contentLanguages.size() > 0)
2026 {
|
2027 mike 1.126 out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
|
2028 w.white 1.108 }
2029 if (httpMethod == HTTP_METHOD_M_POST)
2030 {
|
2031 mike 1.126 out << STRLIT("Ext:\r\n");
2032 out << STRLIT("Cache-Control: no-cache\r\n");
2033 out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
2034 out << nn << STRLIT("\r\n");
2035 out << nn << STRLIT("-CIMOperation: MethodResponse\r\n\r\n");
|
2036 w.white 1.108 }
2037 else
2038 {
|
2039 mike 1.126 out << STRLIT("CIMOperation: MethodResponse\r\n\r\n");
|
2040 w.white 1.108 }
|
2041 brian.campbell 1.113 }
|
2042 w.white 1.108
2043
|
2044 mike 1.23 //------------------------------------------------------------------------------
2045 //
|
2046 kumpf 1.40 // appendHttpErrorResponseHeader()
2047 //
2048 // Build HTTP error response header.
2049 //
2050 // Returns error response message in the following format:
2051 //
|
2052 kumpf 1.41 // HTTP/1.1 400 Bad Request (using specified status code)
2053 // CIMError: <error type> (if specified by caller)
2054 // PGErrorDetail: <error text> (if specified by caller)
|
2055 kumpf 1.40 //
2056 //------------------------------------------------------------------------------
2057
2058 void XmlWriter::appendHttpErrorResponseHeader(
|
2059 mike 1.125 Buffer& out,
|
2060 kumpf 1.40 const String& status,
2061 const String& cimError,
|
2062 kumpf 1.41 const String& errorDetail)
|
2063 kumpf 1.40 {
|
2064 mike 1.126 out << STRLIT("HTTP/1.1 ") << status << STRLIT("\r\n");
|
2065 kumpf 1.40 if (cimError != String::EMPTY)
2066 {
|
2067 mike 1.126 out << STRLIT("CIMError: ") << cimError << STRLIT("\r\n");
|
2068 kumpf 1.40 }
|
2069 kumpf 1.41 if (errorDetail != String::EMPTY)
|
2070 kumpf 1.40 {
|
2071 kumpf 1.41 // ATTN-RK-P3-20020404: It is critical that this text not contain '\n'
2072 // ATTN-RK-P3-20020404: Need to encode this value properly. (See
2073 // CIM/HTTP Specification section 3.3.2
|
2074 mike 1.126 out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")
2075 << encodeURICharacters(errorDetail) << STRLIT("\r\n");
|
2076 kumpf 1.40 }
|
2077 mike 1.126 out << STRLIT("\r\n");
|
2078 kumpf 1.40 }
2079
2080 //------------------------------------------------------------------------------
2081 //
|
2082 kumpf 1.27 // appendUnauthorizedResponseHeader()
2083 //
2084 // Build HTTP authentication response header for unauthorized requests.
2085 //
2086 // Returns unauthorized message in the following format:
2087 //
2088 // HTTP/1.1 401 Unauthorized
2089 // WWW-Authenticate: Basic "hostname:80"
2090 // <HTML><HEAD>
2091 // <TITLE>401 Unauthorized</TITLE>
2092 // </HEAD><BODY BGCOLOR="#99cc99">
2093 // <H2>TEST401 Unauthorized</H2>
2094 // <HR>
2095 // </BODY></HTML>
2096 //
2097 //------------------------------------------------------------------------------
2098
2099 void XmlWriter::appendUnauthorizedResponseHeader(
|
2100 mike 1.125 Buffer& out,
|
2101 kumpf 1.27 const String& content)
2102 {
|
2103 mike 1.126 out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n");
2104 out << content << STRLIT("\r\n");
2105 out << STRLIT("\r\n");
|
2106 kumpf 1.27
2107 //ATTN: We may need to include the following line, so that the browsers
2108 // can display the error message.
2109 // out << "<HTML><HEAD>\r\n";
2110 // out << "<TITLE>" << "401 Unauthorized" << "</TITLE>\r\n";
2111 // out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
2112 // out << "<H2>TEST" << "401 Unauthorized" << "</H2>\r\n";
2113 // out << "<HR>\r\n";
2114 // out << "</BODY></HTML>\r\n";
2115 }
2116
|
2117 gerarda 1.90 #ifdef PEGASUS_KERBEROS_AUTHENTICATION
2118 //------------------------------------------------------------------------------
2119 //
2120 // appendOKResponseHeader()
2121 //
2122 // Build HTTP authentication response header for unauthorized requests.
2123 //
2124 // Returns OK message in the following format:
2125 //
2126 // HTTP/1.1 200 OK
|
2127 gerarda 1.101 // Content-Length: 0
|
2128 gerarda 1.90 // WWW-Authenticate: Negotiate "token"
2129 // <HTML><HEAD>
2130 // <TITLE>200 OK</TITLE>
2131 // </HEAD><BODY BGCOLOR="#99cc99">
2132 // <H2>TEST200 OK</H2>
2133 // <HR>
2134 // </BODY></HTML>
2135 //
2136 //------------------------------------------------------------------------------
2137
2138 void XmlWriter::appendOKResponseHeader(
|
2139 mike 1.125 Buffer& out,
|
2140 gerarda 1.90 const String& content)
2141 {
|
2142 mike 1.126 out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");
|
2143 gerarda 1.101 // Content-Length header needs to be added because 200 OK record
2144 // is usually intended to have content. But, for Kerberos this
2145 // may not always be the case so we need to indicate that there
2146 // is no content
|
2147 brian.campbell 1.107 Uint32 contentLength = 0;
2148 OUTPUT_CONTENTLENGTH;
|
2149 mike 1.126 out << content << STRLIT("\r\n");
2150 out << STRLIT("\r\n");
|
2151 gerarda 1.90
2152 //ATTN: We may need to include the following line, so that the browsers
2153 // can display the error message.
2154 // out << "<HTML><HEAD>\r\n";
2155 // out << "<TITLE>" << "200 OK" << "</TITLE>\r\n";
2156 // out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
2157 // out << "<H2>TEST" << "200 OK" << "</H2>\r\n";
2158 // out << "<HR>\r\n";
2159 // out << "</BODY></HTML>\r\n";
2160 }
2161 #endif
2162
|
2163 kumpf 1.27 //------------------------------------------------------------------------------
2164 //
|
2165 kumpf 1.29 // _appendMessageElementBegin()
2166 // _appendMessageElementEnd()
|
2167 mike 1.23 //
2168 // <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
2169 // <!ATTLIST MESSAGE
2170 // ID CDATA #REQUIRED
2171 // PROTOCOLVERSION CDATA #REQUIRED>
2172 //
2173 //------------------------------------------------------------------------------
2174
|
2175 kumpf 1.29 void XmlWriter::_appendMessageElementBegin(
|
2176 mike 1.125 Buffer& out,
|
2177 kumpf 1.27 const String& messageId)
|
2178 mike 1.23 {
|
2179 mike 1.126 out << STRLIT("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
2180 out << STRLIT("<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n");
2181 out << STRLIT("<MESSAGE ID=\"") << messageId;
2182 out << STRLIT("\" PROTOCOLVERSION=\"1.0\">\n");
|
2183 kumpf 1.27 }
2184
|
2185 kumpf 1.29 void XmlWriter::_appendMessageElementEnd(
|
2186 mike 1.125 Buffer& out)
|
2187 kumpf 1.27 {
|
2188 mike 1.126 out << STRLIT("</MESSAGE>\n");
2189 out << STRLIT("</CIM>\n");
|
2190 mike 1.23 }
2191
2192 //------------------------------------------------------------------------------
2193 //
|
2194 kumpf 1.29 // _appendSimpleReqElementBegin()
2195 // _appendSimpleReqElementEnd()
|
2196 mike 1.23 //
2197 // <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
2198 //
2199 //------------------------------------------------------------------------------
2200
|
2201 kumpf 1.29 void XmlWriter::_appendSimpleReqElementBegin(
|
2202 mike 1.125 Buffer& out)
|
2203 kumpf 1.27 {
|
2204 mike 1.126 out << STRLIT("<SIMPLEREQ>\n");
|
2205 kumpf 1.27 }
2206
|
2207 kumpf 1.29 void XmlWriter::_appendSimpleReqElementEnd(
|
2208 mike 1.125 Buffer& out)
|
2209 mike 1.23 {
|
2210 mike 1.126 out << STRLIT("</SIMPLEREQ>\n");
|
2211 mike 1.23 }
2212
2213 //------------------------------------------------------------------------------
2214 //
|
2215 kumpf 1.29 // _appendMethodCallElementBegin()
2216 // _appendMethodCallElementEnd()
|
2217 mike 1.23 //
|
2218 kumpf 1.27 // <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
2219 // <!ATTLIST METHODCALL %CIMName;>
|
2220 mike 1.23 //
2221 //------------------------------------------------------------------------------
2222
|
2223 kumpf 1.29 void XmlWriter::_appendMethodCallElementBegin(
|
2224 mike 1.125 Buffer& out,
|
2225 kumpf 1.80 const CIMName& name)
|
2226 kumpf 1.27 {
|
2227 mike 1.126 out << STRLIT("<METHODCALL NAME=\"") << name << STRLIT("\">\n");
|
2228 kumpf 1.27 }
2229
|
2230 kumpf 1.29 void XmlWriter::_appendMethodCallElementEnd(
|
2231 mike 1.125 Buffer& out)
|
2232 mike 1.23 {
|
2233 mike 1.126 out << STRLIT("</METHODCALL>\n");
|
2234 mike 1.23 }
2235
2236 //------------------------------------------------------------------------------
2237 //
|
2238 kumpf 1.29 // _appendIMethodCallElementBegin()
2239 // _appendIMethodCallElementEnd()
|
2240 mike 1.23 //
2241 // <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
2242 // <!ATTLIST IMETHODCALL %CIMName;>
2243 //
2244 //------------------------------------------------------------------------------
2245
|
2246 kumpf 1.29 void XmlWriter::_appendIMethodCallElementBegin(
|
2247 mike 1.125 Buffer& out,
|
2248 kumpf 1.80 const CIMName& name)
|
2249 mike 1.23 {
|
2250 mike 1.126 out << STRLIT("<IMETHODCALL NAME=\"") << name << STRLIT("\">\n");
|
2251 kumpf 1.27 }
2252
|
2253 kumpf 1.29 void XmlWriter::_appendIMethodCallElementEnd(
|
2254 mike 1.125 Buffer& out)
|
2255 kumpf 1.27 {
|
2256 mike 1.126 out << STRLIT("</IMETHODCALL>\n");
|
2257 mike 1.23 }
2258
2259 //------------------------------------------------------------------------------
2260 //
|
2261 kumpf 1.29 // _appendIParamValueElementBegin()
2262 // _appendIParamValueElementEnd()
|
2263 mike 1.23 //
|
2264 kumpf 1.27 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
2265 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
2266 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
2267 // <!ATTLIST IPARAMVALUE %CIMName;>
|
2268 mike 1.23 //
2269 //------------------------------------------------------------------------------
2270
|
2271 kumpf 1.29 void XmlWriter::_appendIParamValueElementBegin(
|
2272 mike 1.125 Buffer& out,
|
2273 kumpf 1.27 const char* name)
2274 {
|
2275 mike 1.126 out << STRLIT("<IPARAMVALUE NAME=\"") << name << STRLIT("\">\n");
|
2276 kumpf 1.27 }
2277
|
2278 kumpf 1.29 void XmlWriter::_appendIParamValueElementEnd(
|
2279 mike 1.125 Buffer& out)
|
2280 mike 1.23 {
|
2281 mike 1.126 out << STRLIT("</IPARAMVALUE>\n");
|
2282 mike 1.23 }
2283
2284 //------------------------------------------------------------------------------
2285 //
|
2286 kumpf 1.29 // _appendSimpleRspElementBegin()
2287 // _appendSimpleRspElementEnd()
|
2288 mike 1.23 //
|
2289 kumpf 1.27 // <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
|
2290 mike 1.23 //
2291 //------------------------------------------------------------------------------
2292
|
2293 kumpf 1.29 void XmlWriter::_appendSimpleRspElementBegin(
|
2294 mike 1.125 Buffer& out)
|
2295 kumpf 1.27 {
|
2296 mike 1.126 out << STRLIT("<SIMPLERSP>\n");
|
2297 kumpf 1.27 }
2298
|
2299 kumpf 1.29 void XmlWriter::_appendSimpleRspElementEnd(
|
2300 mike 1.125 Buffer& out)
|
2301 mike 1.23 {
|
2302 mike 1.126 out << STRLIT("</SIMPLERSP>\n");
|
2303 mike 1.23 }
2304
2305 //------------------------------------------------------------------------------
2306 //
|
2307 kumpf 1.29 // _appendMethodResponseElementBegin()
2308 // _appendMethodResponseElementEnd()
|
2309 mike 1.23 //
|
2310 kumpf 1.27 // <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
2311 // <!ATTLIST METHODRESPONSE %CIMName;>
|
2312 mike 1.23 //
2313 //------------------------------------------------------------------------------
2314
|
2315 kumpf 1.29 void XmlWriter::_appendMethodResponseElementBegin(
|
2316 mike 1.125 Buffer& out,
|
2317 kumpf 1.80 const CIMName& name)
|
2318 kumpf 1.27 {
|
2319 mike 1.126 out << STRLIT("<METHODRESPONSE NAME=\"") << name << STRLIT("\">\n");
|
2320 kumpf 1.27 }
2321
|
2322 kumpf 1.29 void XmlWriter::_appendMethodResponseElementEnd(
|
2323 mike 1.125 Buffer& out)
|
2324 mike 1.23 {
|
2325 mike 1.126 out << STRLIT("</METHODRESPONSE>\n");
|
2326 kumpf 1.27 }
2327
2328 //------------------------------------------------------------------------------
2329 //
|
2330 kumpf 1.29 // _appendIMethodResponseElementBegin()
2331 // _appendIMethodResponseElementEnd()
|
2332 kumpf 1.27 //
2333 // <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
2334 // <!ATTLIST IMETHODRESPONSE %CIMName;>
2335 //
2336 //------------------------------------------------------------------------------
2337
|
2338 kumpf 1.29 void XmlWriter::_appendIMethodResponseElementBegin(
|
2339 mike 1.125 Buffer& out,
|
2340 kumpf 1.80 const CIMName& name)
|
2341 kumpf 1.27 {
|
2342 mike 1.126 out << STRLIT("<IMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");
|
2343 kumpf 1.27 }
2344
|
2345 kumpf 1.29 void XmlWriter::_appendIMethodResponseElementEnd(
|
2346 mike 1.125 Buffer& out)
|
2347 kumpf 1.27 {
|
2348 mike 1.126 out << STRLIT("</IMETHODRESPONSE>\n");
|
2349 mike 1.23 }
2350
2351 //------------------------------------------------------------------------------
2352 //
|
2353 kumpf 1.29 // _appendErrorElement()
|
2354 mike 1.23 //
2355 //------------------------------------------------------------------------------
2356
|
2357 kumpf 1.29 void XmlWriter::_appendErrorElement(
|
2358 mike 1.125 Buffer& out,
|
2359 kumpf 1.42 const CIMException& cimException)
|
2360 mike 1.23 {
|
2361 kumpf 1.71 Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);
|
2362 kumpf 1.44
|
2363 mike 1.126 out << STRLIT("<ERROR");
2364 out << STRLIT(" CODE=\"") << Uint32(cimException.getCode());
2365 out.append('"');
|
2366 kumpf 1.71 String description = TraceableCIMException(cimException).getDescription();
|
2367 kumpf 1.51 if (description != String::EMPTY)
|
2368 kumpf 1.42 {
|
2369 mike 1.126 out << STRLIT(" DESCRIPTION=\"");
|
2370 kumpf 1.51 appendSpecial(out, description);
|
2371 mike 1.126 out.append('"');
|
2372 kumpf 1.42 }
|
2373 mike 1.126 out << STRLIT("/>");
|
2374 mike 1.23 }
2375
2376 //------------------------------------------------------------------------------
2377 //
|
2378 kumpf 1.27 // appendReturnValueElement()
2379 //
2380 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
2381 // <!ATTLIST RETURNVALUE
|
2382 dave.sudlik 1.117 // %EmbeddedObject; #IMPLIED
|
2383 kumpf 1.27 // %ParamType;>
|
2384 mike 1.23 //
2385 //------------------------------------------------------------------------------
2386
|
2387 kumpf 1.27 void XmlWriter::appendReturnValueElement(
|
2388 mike 1.125 Buffer& out,
|
2389 kumpf 1.27 const CIMValue& value)
2390 {
|
2391 mike 1.126 out << STRLIT("<RETURNVALUE");
|
2392 kumpf 1.27
2393 CIMType type = value.getType();
|
2394 david.dillard 1.121 // If the property type is CIMObject, then
|
2395 dave.sudlik 1.117 // encode the property in CIM-XML as a string with the EMBEDDEDOBJECT attribute
2396 // (there is not currently a CIM-XML "object" datatype)
2397 // else
2398 // output the real type
2399 if (type == CIMTYPE_OBJECT)
2400 {
|
2401 mike 1.126 out << STRLIT(" PARAMTYPE=\"string\"");
2402 out << STRLIT(" EMBEDDEDOBJECT=\"object\"");
|
2403 dave.sudlik 1.117 }
|
2404 a.dunfey 1.132.2.1 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
2405 else if (type == CIMTYPE_INSTANCE)
2406 {
2407 out << STRLIT(" PARAMTYPE=\"string\"");
2408 out << STRLIT(" EMBEDDEDOBJECT=\"instance\"");
2409 }
2410 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
2411 dave.sudlik 1.117 else
2412 {
|
2413 mike 1.126 out << STRLIT(" PARAMTYPE=\"") << cimTypeToString (type);
2414 out.append('"');
|
2415 dave.sudlik 1.117 }
|
2416 kumpf 1.27
|
2417 mike 1.126 out << STRLIT(">\n");
|
2418 karl 1.37
|
2419 kumpf 1.54 // Add value.
2420 appendValueElement(out, value);
|
2421 mike 1.126 out << STRLIT("</RETURNVALUE>\n");
|
2422 kumpf 1.27 }
2423
2424 //------------------------------------------------------------------------------
2425 //
|
2426 kumpf 1.29 // _appendIReturnValueElementBegin()
2427 // _appendIReturnValueElementEnd()
|
2428 kumpf 1.27 //
2429 // <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
2430 // VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
2431 // OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
2432 // CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
2433 //
2434 //------------------------------------------------------------------------------
2435
|
2436 kumpf 1.29 void XmlWriter::_appendIReturnValueElementBegin(
|
2437 mike 1.125 Buffer& out)
|
2438 kumpf 1.27 {
|
2439 mike 1.126 out << STRLIT("<IRETURNVALUE>\n");
|
2440 kumpf 1.27 }
2441
|
2442 kumpf 1.29 void XmlWriter::_appendIReturnValueElementEnd(
|
2443 mike 1.125 Buffer& out)
|
2444 mike 1.23 {
|
2445 mike 1.126 out << STRLIT("</IRETURNVALUE>\n");
|
2446 mike 1.23 }
2447
2448 //------------------------------------------------------------------------------
2449 //
|
2450 kumpf 1.27 // appendBooleanIParameter()
|
2451 mike 1.23 //
2452 //------------------------------------------------------------------------------
2453
|
2454 kumpf 1.27 void XmlWriter::appendBooleanIParameter(
|
2455 mike 1.125 Buffer& out,
|
2456 mike 1.23 const char* name,
|
2457 kumpf 1.27 Boolean flag)
|
2458 mike 1.23 {
|
2459 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2460 mike 1.126 out << STRLIT("<VALUE>");
|
2461 kumpf 1.54 append(out, flag);
|
2462 mike 1.126 out << STRLIT("</VALUE>\n");
|
2463 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2464 mike 1.23 }
2465
2466 //------------------------------------------------------------------------------
2467 //
|
2468 kumpf 1.27 // appendStringIParameter()
|
2469 mike 1.23 //
2470 //------------------------------------------------------------------------------
2471
|
2472 kumpf 1.27 void XmlWriter::appendStringIParameter(
|
2473 mike 1.125 Buffer& out,
|
2474 mike 1.23 const char* name,
|
2475 kumpf 1.27 const String& str)
|
2476 mike 1.23 {
|
2477 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2478 mike 1.126 out << STRLIT("<VALUE>");
|
2479 kumpf 1.27 appendSpecial(out, str);
|
2480 mike 1.126 out << STRLIT("</VALUE>\n");
|
2481 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2482 mike 1.23 }
2483
2484 //------------------------------------------------------------------------------
2485 //
|
2486 kumpf 1.27 // appendQualifierNameIParameter()
|
2487 mike 1.23 //
2488 //------------------------------------------------------------------------------
2489
|
2490 kumpf 1.27 void XmlWriter::appendQualifierNameIParameter(
|
2491 mike 1.125 Buffer& out,
|
2492 mike 1.23 const char* name,
2493 const String& qualifierName)
2494 {
2495 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
2496 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
2497 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
2498 //
2499 // ATTN: notice that there is really no way to pass a qualifier name
2500 // as an IPARAMVALUE element according to the spec (look above). So we
2501 // just pass it as a class name. An answer must be obtained later.
|
2502 david.dillard 1.121
|
2503 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2504 kumpf 1.27 appendClassNameElement(out, qualifierName);
|
2505 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2506 mike 1.23 }
2507
2508 //------------------------------------------------------------------------------
2509 //
|
2510 kumpf 1.27 // appendClassNameIParameter()
|
2511 mike 1.23 //
2512 //------------------------------------------------------------------------------
2513
|
2514 kumpf 1.27 void XmlWriter::appendClassNameIParameter(
|
2515 mike 1.125 Buffer& out,
|
2516 kumpf 1.27 const char* name,
|
2517 kumpf 1.80 const CIMName& className)
|
2518 mike 1.23 {
|
2519 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2520 kumpf 1.83
2521 //
|
2522 david.dillard 1.121 // A NULL (unassigned) value for a parameter is specified by an
|
2523 kumpf 1.83 // <IPARAMVALUE> element with no subelement
2524 //
2525 if (!className.isNull ())
2526 {
2527 appendClassNameElement(out, className);
2528 }
2529
|
2530 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2531 mike 1.23 }
2532
2533 //------------------------------------------------------------------------------
2534 //
|
2535 kumpf 1.27 // appendInstanceNameIParameter()
|
2536 mike 1.23 //
2537 //------------------------------------------------------------------------------
2538
|
2539 kumpf 1.27 void XmlWriter::appendInstanceNameIParameter(
|
2540 mike 1.125 Buffer& out,
|
2541 kumpf 1.27 const char* name,
|
2542 kumpf 1.59 const CIMObjectPath& instanceName)
|
2543 mike 1.23 {
|
2544 kumpf 1.29 _appendIParamValueElementBegin(out, name);
2545 appendInstanceNameElement(out, instanceName);
2546 _appendIParamValueElementEnd(out);
|
2547 kumpf 1.27 }
2548
2549 void XmlWriter::appendObjectNameIParameter(
|
2550 mike 1.125 Buffer& out,
|
2551 kumpf 1.27 const char* name,
|
2552 kumpf 1.59 const CIMObjectPath& objectName)
|
2553 kumpf 1.27 {
|
2554 kumpf 1.68 //
2555 // ATTN-CAKG-P2-20020726: The following condition does not correctly
2556 // distinguish instanceNames from classNames in every case
|
2557 david.dillard 1.121 // The instanceName of a singleton instance of a keyless class also
|
2558 kumpf 1.68 // has no key bindings
2559 //
2560 if (objectName.getKeyBindings ().size () == 0)
|
2561 kumpf 1.27 {
2562 XmlWriter::appendClassNameIParameter(
2563 out, name, objectName.getClassName());
2564 }
2565 else
2566 {
2567 XmlWriter::appendInstanceNameIParameter(
2568 out, name, objectName);
2569 }
2570 }
2571
2572 //------------------------------------------------------------------------------
2573 //
2574 // appendClassIParameter()
2575 //
2576 //------------------------------------------------------------------------------
2577
2578 void XmlWriter::appendClassIParameter(
|
2579 mike 1.125 Buffer& out,
|
2580 kumpf 1.27 const char* name,
2581 const CIMConstClass& cimClass)
2582 {
|
2583 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2584 kumpf 1.55 appendClassElement(out, cimClass);
|
2585 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2586 mike 1.23 }
2587
2588 //------------------------------------------------------------------------------
2589 //
|
2590 kumpf 1.27 // appendInstanceIParameter()
|
2591 mike 1.23 //
2592 //------------------------------------------------------------------------------
2593
|
2594 kumpf 1.27 void XmlWriter::appendInstanceIParameter(
|
2595 mike 1.125 Buffer& out,
|
2596 kumpf 1.27 const char* name,
|
2597 mike 1.23 const CIMConstInstance& instance)
2598 {
|
2599 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2600 kumpf 1.55 appendInstanceElement(out, instance);
|
2601 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2602 mike 1.23 }
2603
|
2604 mike 1.24 //------------------------------------------------------------------------------
2605 //
|
2606 kumpf 1.27 // appendNamedInstanceIParameter()
|
2607 mike 1.24 //
2608 //------------------------------------------------------------------------------
2609
|
2610 kumpf 1.27 void XmlWriter::appendNamedInstanceIParameter(
|
2611 mike 1.125 Buffer& out,
|
2612 kumpf 1.27 const char* name,
|
2613 kumpf 1.61 const CIMInstance& namedInstance)
|
2614 mike 1.24 {
|
2615 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2616 kumpf 1.56 appendValueNamedInstanceElement(out, namedInstance);
|
2617 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2618 mike 1.24 }
2619
|
2620 mike 1.23 //----------------------------------------------------------
2621 //
|
2622 kumpf 1.27 // appendPropertyNameIParameter()
|
2623 david.dillard 1.121 //
|
2624 mike 1.23 // </IPARAMVALUE>
2625 // <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
2626 //
2627 // USE: Create parameter for getProperty operation
|
2628 brian.campbell 1.113 //==========================================================
|
2629 kumpf 1.27 void XmlWriter::appendPropertyNameIParameter(
|
2630 mike 1.125 Buffer& out,
|
2631 kumpf 1.80 const CIMName& propertyName)
|
2632 mike 1.23 {
|
2633 kumpf 1.29 _appendIParamValueElementBegin(out, "PropertyName");
|
2634 mike 1.126 out << STRLIT("<VALUE>") << propertyName << STRLIT("</VALUE>\n");
|
2635 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2636 kumpf 1.27 }
|
2637 mike 1.23
2638 //------------------------------------------------------------------------------
2639 //
|
2640 kumpf 1.27 // appendPropertyValueIParameter()
|
2641 mike 1.24 //
2642 //------------------------------------------------------------------------------
2643
|
2644 kumpf 1.27 void XmlWriter::appendPropertyValueIParameter(
|
2645 mike 1.125 Buffer& out,
|
2646 kumpf 1.27 const char* name,
|
2647 mike 1.24 const CIMValue& value)
2648 {
|
2649 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2650 kumpf 1.54 appendValueElement(out, value);
|
2651 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2652 mike 1.24 }
2653
2654 //------------------------------------------------------------------------------
2655 //
|
2656 kumpf 1.27 // appendPropertyListIParameter()
|
2657 mike 1.24 //
2658 //------------------------------------------------------------------------------
2659
|
2660 kumpf 1.27 void XmlWriter::appendPropertyListIParameter(
|
2661 mike 1.125 Buffer& out,
|
2662 mike 1.24 const CIMPropertyList& propertyList)
2663 {
|
2664 kumpf 1.29 _appendIParamValueElementBegin(out, "PropertyList");
|
2665 mike 1.24
|
2666 kumpf 1.83 //
|
2667 david.dillard 1.121 // A NULL (unassigned) value for a parameter is specified by an
|
2668 kumpf 1.83 // <IPARAMVALUE> element with no subelement
2669 //
2670 if (!propertyList.isNull ())
|
2671 mike 1.24 {
|
2672 mike 1.126 out << STRLIT("<VALUE.ARRAY>\n");
|
2673 kumpf 1.83 for (Uint32 i = 0; i < propertyList.size(); i++)
2674 {
|
2675 mike 1.126 out << STRLIT("<VALUE>") << propertyList[i] << STRLIT("</VALUE>\n");
|
2676 kumpf 1.83 }
|
2677 mike 1.126 out << STRLIT("</VALUE.ARRAY>\n");
|
2678 mike 1.24 }
|
2679 kumpf 1.27
|
2680 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2681 mike 1.24 }
2682
2683 //------------------------------------------------------------------------------
2684 //
|
2685 kumpf 1.27 // appendQualifierDeclarationIParameter()
|
2686 mike 1.23 //
2687 //------------------------------------------------------------------------------
2688
|
2689 kumpf 1.27 void XmlWriter::appendQualifierDeclarationIParameter(
|
2690 mike 1.125 Buffer& out,
|
2691 kumpf 1.27 const char* name,
|
2692 mike 1.23 const CIMConstQualifierDecl& qualifierDecl)
2693 {
|
2694 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
2695 kumpf 1.56 appendQualifierDeclElement(out, qualifierDecl);
|
2696 kumpf 1.29 _appendIParamValueElementEnd(out);
|
2697 kumpf 1.40 }
2698
2699 //------------------------------------------------------------------------------
2700 //
2701 // XmlWriter::formatHttpErrorRspMessage()
2702 //
2703 //------------------------------------------------------------------------------
2704
|
2705 mike 1.125 Buffer XmlWriter::formatHttpErrorRspMessage(
|
2706 kumpf 1.40 const String& status,
2707 const String& cimError,
|
2708 kumpf 1.41 const String& errorDetail)
|
2709 kumpf 1.40 {
|
2710 mike 1.125 Buffer out;
|
2711 kumpf 1.40
|
2712 kumpf 1.41 appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
|
2713 kumpf 1.40
|
2714 kumpf 1.41 return out;
|
2715 mike 1.23 }
2716
|
2717 chuck 1.89 // l10n - add content language support to the format methods below
2718
|
2719 mike 1.23 //------------------------------------------------------------------------------
2720 //
|
2721 kumpf 1.27 // XmlWriter::formatSimpleMethodReqMessage()
|
2722 mike 1.23 //
2723 //------------------------------------------------------------------------------
2724
|
2725 kumpf 1.27 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
|
2726 mike 1.125 Buffer XmlWriter::formatSimpleMethodReqMessage(
|
2727 kumpf 1.27 const char* host,
|
2728 kumpf 1.80 const CIMNamespaceName& nameSpace,
|
2729 kumpf 1.59 const CIMObjectPath& path,
|
2730 kumpf 1.80 const CIMName& methodName,
|
2731 kumpf 1.30 const Array<CIMParamValue>& parameters,
|
2732 kumpf 1.27 const String& messageId,
|
2733 kumpf 1.82 HttpMethod httpMethod,
|
2734 chuck 1.89 const String& authenticationHeader,
2735 const AcceptLanguages& httpAcceptLanguages,
2736 const ContentLanguages& httpContentLanguages)
|
2737 kumpf 1.27 {
|
2738 mike 1.125 Buffer out;
2739 Buffer tmp;
|
2740 kumpf 1.59 CIMObjectPath localObjectPath = path;
|
2741 kumpf 1.80 localObjectPath.setNameSpace(nameSpace.getString());
|
2742 kumpf 1.77 localObjectPath.setHost(String::EMPTY);
|
2743 kumpf 1.27
|
2744 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2745 _appendSimpleReqElementBegin(out);
2746 _appendMethodCallElementBegin(out, methodName);
|
2747 kumpf 1.38 appendLocalObjectPathElement(out, localObjectPath);
|
2748 kumpf 1.30 for (Uint32 i=0; i < parameters.size(); i++)
|
2749 kumpf 1.29 {
|
2750 kumpf 1.56 appendParamValueElement(out, parameters[i]);
|
2751 kumpf 1.29 }
2752 _appendMethodCallElementEnd(out);
2753 _appendSimpleReqElementEnd(out);
2754 _appendMessageElementEnd(out);
|
2755 kumpf 1.27
2756 appendMethodCallHeader(
2757 tmp,
2758 host,
2759 methodName,
|
2760 kumpf 1.77 localObjectPath.toString(),
|
2761 kumpf 1.27 authenticationHeader,
|
2762 kumpf 1.82 httpMethod,
|
2763 chuck 1.89 httpAcceptLanguages,
2764 httpContentLanguages,
|
2765 kumpf 1.27 out.size());
2766 tmp << out;
2767
2768 return tmp;
2769 }
2770
|
2771 w.white 1.108 //PEP 128 adding serverRsponseTime to header
|
2772 mike 1.125 Buffer XmlWriter::formatSimpleMethodRspMessage(
|
2773 w.white 1.108 const CIMName& methodName,
2774 const String& messageId,
2775 HttpMethod httpMethod,
2776 const ContentLanguages & httpContentLanguages,
|
2777 mike 1.125 const Buffer& body,
|
2778 david.dillard 1.130 Uint64 serverResponseTime,
|
2779 w.white 1.108 Boolean isFirst,
2780 Boolean isLast)
2781 {
|
2782 mike 1.125 Buffer out;
|
2783 w.white 1.108
2784 if (isFirst == true)
2785 {
2786 // NOTE: temporarily put zero for content length. the http code
2787 // will later decide to fill in the length or remove it altogether
|
2788 david.dillard 1.121 appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
|
2789 brian.campbell 1.113 serverResponseTime);
|
2790 w.white 1.108 _appendMessageElementBegin(out, messageId);
2791 _appendSimpleRspElementBegin(out);
2792 _appendMethodResponseElementBegin(out, methodName);
2793 }
|
2794 david.dillard 1.121
|
2795 w.white 1.108 if (body.size() != 0)
2796 {
2797 out << body;
2798 }
|
2799 david.dillard 1.121
|
2800 w.white 1.108 if (isLast == true)
2801 {
2802 _appendMethodResponseElementEnd(out);
2803 _appendSimpleRspElementEnd(out);
2804 _appendMessageElementEnd(out);
2805 }
|
2806 david.dillard 1.121
|
2807 w.white 1.108 return out;
2808 }
2809
2810
2811
|
2812 mike 1.23 //------------------------------------------------------------------------------
2813 //
|
2814 kumpf 1.28 // XmlWriter::formatSimpleMethodErrorRspMessage()
2815 //
2816 //------------------------------------------------------------------------------
2817
|
2818 mike 1.125 Buffer XmlWriter::formatSimpleMethodErrorRspMessage(
|
2819 kumpf 1.80 const CIMName& methodName,
|
2820 kumpf 1.28 const String& messageId,
|
2821 kumpf 1.82 HttpMethod httpMethod,
|
2822 kumpf 1.42 const CIMException& cimException)
|
2823 kumpf 1.28 {
|
2824 mike 1.125 Buffer out;
2825 Buffer tmp;
|
2826 kumpf 1.28
|
2827 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2828 _appendSimpleRspElementBegin(out);
|
2829 kumpf 1.80 _appendMethodResponseElementBegin(out, methodName);
|
2830 kumpf 1.42 _appendErrorElement(out, cimException);
|
2831 kumpf 1.29 _appendMethodResponseElementEnd(out);
2832 _appendSimpleRspElementEnd(out);
2833 _appendMessageElementEnd(out);
|
2834 kumpf 1.28
|
2835 david.dillard 1.121 // l10n
2836 appendMethodResponseHeader(tmp,
2837 httpMethod,
2838 cimException.getContentLanguages(),
|
2839 chuck 1.89 out.size());
|
2840 kumpf 1.28 tmp << out;
2841
2842 return tmp;
2843 }
2844
2845 //------------------------------------------------------------------------------
2846 //
|
2847 kumpf 1.27 // XmlWriter::formatSimpleIMethodReqMessage()
|
2848 mike 1.23 //
2849 //------------------------------------------------------------------------------
2850
|
2851 mike 1.125 Buffer XmlWriter::formatSimpleIMethodReqMessage(
|
2852 kumpf 1.27 const char* host,
|
2853 kumpf 1.80 const CIMNamespaceName& nameSpace,
2854 const CIMName& iMethodName,
|
2855 kumpf 1.27 const String& messageId,
|
2856 kumpf 1.82 HttpMethod httpMethod,
|
2857 kumpf 1.27 const String& authenticationHeader,
|
2858 chuck 1.89 const AcceptLanguages& httpAcceptLanguages,
|
2859 david.dillard 1.121 const ContentLanguages& httpContentLanguages,
|
2860 mike 1.125 const Buffer& body)
|
2861 mike 1.23 {
|
2862 mike 1.125 Buffer out;
2863 Buffer tmp;
|
2864 kumpf 1.27
|
2865 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2866 _appendSimpleReqElementBegin(out);
2867 _appendIMethodCallElementBegin(out, iMethodName);
|
2868 kumpf 1.80 appendLocalNameSpacePathElement(out, nameSpace.getString());
|
2869 kumpf 1.27 out << body;
|
2870 kumpf 1.29 _appendIMethodCallElementEnd(out);
2871 _appendSimpleReqElementEnd(out);
2872 _appendMessageElementEnd(out);
|
2873 kumpf 1.27
2874 appendMethodCallHeader(
2875 tmp,
2876 host,
2877 iMethodName,
|
2878 kumpf 1.80 nameSpace.getString(),
|
2879 kumpf 1.27 authenticationHeader,
|
2880 kumpf 1.82 httpMethod,
|
2881 chuck 1.89 httpAcceptLanguages,
2882 httpContentLanguages,
|
2883 kumpf 1.27 out.size());
2884 tmp << out;
|
2885 mike 1.23
|
2886 kumpf 1.27 return tmp;
|
2887 mike 1.23 }
2888
2889 //------------------------------------------------------------------------------
2890 //
|
2891 kumpf 1.27 // XmlWriter::formatSimpleIMethodRspMessage()
|
2892 mike 1.23 //
2893 //------------------------------------------------------------------------------
2894
|
2895 mike 1.125 Buffer XmlWriter::formatSimpleIMethodRspMessage(
|
2896 kumpf 1.80 const CIMName& iMethodName,
|
2897 kumpf 1.27 const String& messageId,
|
2898 kumpf 1.82 HttpMethod httpMethod,
|
2899 david.dillard 1.121 const ContentLanguages & httpContentLanguages,
|
2900 mike 1.125 const Buffer& body,
|
2901 david.dillard 1.130 Uint64 serverResponseTime,
|
2902 david.dillard 1.121 Boolean isFirst,
2903 Boolean isLast)
|
2904 mike 1.23 {
|
2905 mike 1.125 Buffer out;
|
2906 mike 1.23
|
2907 brian.campbell 1.107 if (isFirst == true)
2908 {
2909 // NOTE: temporarily put zero for content length. the http code
2910 // will later decide to fill in the length or remove it altogether
|
2911 david.dillard 1.121 appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
|
2912 brian.campbell 1.113 serverResponseTime);
|
2913 brian.campbell 1.107 _appendMessageElementBegin(out, messageId);
2914 _appendSimpleRspElementBegin(out);
2915 _appendIMethodResponseElementBegin(out, iMethodName);
2916
|
2917 brian.campbell 1.113 // output the start of the return tag. Test if there is response data by:
2918 // 1. there is data on the first chunk OR
2919 // 2. there is no data on the first chunk but isLast is false implying
2920 // there is more non-empty data to come. If all subsequent chunks
2921 // are empty, then this generates and empty response.
2922 if (body.size() != 0 || isLast == false)
|
2923 w.white 1.108 _appendIReturnValueElementBegin(out);
2924 }
2925
2926 if (body.size() != 0)
2927 {
2928 out << body;
2929 }
2930
2931 if (isLast == true)
2932 {
|
2933 brian.campbell 1.113 if (body.size() != 0 || isFirst == false)
|
2934 w.white 1.108 _appendIReturnValueElementEnd(out);
2935 _appendIMethodResponseElementEnd(out);
2936 _appendSimpleRspElementEnd(out);
2937 _appendMessageElementEnd(out);
2938 }
2939
2940 return out;
2941 }
2942
2943
|
2944 kumpf 1.28 //------------------------------------------------------------------------------
2945 //
2946 // XmlWriter::formatSimpleIMethodErrorRspMessage()
2947 //
2948 //------------------------------------------------------------------------------
2949
|
2950 mike 1.125 Buffer XmlWriter::formatSimpleIMethodErrorRspMessage(
|
2951 kumpf 1.80 const CIMName& iMethodName,
|
2952 kumpf 1.28 const String& messageId,
|
2953 kumpf 1.82 HttpMethod httpMethod,
|
2954 kumpf 1.42 const CIMException& cimException)
|
2955 kumpf 1.28 {
|
2956 mike 1.125 Buffer out;
2957 Buffer tmp;
|
2958 kumpf 1.28
|
2959 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2960 _appendSimpleRspElementBegin(out);
|
2961 kumpf 1.80 _appendIMethodResponseElementBegin(out, iMethodName);
|
2962 kumpf 1.42 _appendErrorElement(out, cimException);
|
2963 kumpf 1.29 _appendIMethodResponseElementEnd(out);
2964 _appendSimpleRspElementEnd(out);
2965 _appendMessageElementEnd(out);
|
2966 kumpf 1.28
|
2967 david.dillard 1.121 // l10n
|
2968 chuck 1.89 appendMethodResponseHeader(tmp,
|
2969 david.dillard 1.121 httpMethod,
2970 cimException.getContentLanguages(),
|
2971 chuck 1.89 out.size());
|
2972 kumpf 1.28 tmp << out;
2973
2974 return tmp;
2975 }
2976
|
2977 kumpf 1.27 //******************************************************************************
2978 //
2979 // Export Messages (used for indications)
2980 //
2981 //******************************************************************************
|
2982 mike 1.23
|
2983 kumpf 1.27 //------------------------------------------------------------------------------
2984 //
2985 // appendEMethodRequestHeader()
2986 //
2987 // Build HTTP request header for export operation.
2988 //
2989 //------------------------------------------------------------------------------
|
2990 mike 1.23
|
2991 kumpf 1.27 void XmlWriter::appendEMethodRequestHeader(
|
2992 mike 1.125 Buffer& out,
|
2993 kumpf 1.50 const char* requestUri,
|
2994 kumpf 1.27 const char* host,
|
2995 kumpf 1.80 const CIMName& cimMethod,
|
2996 kumpf 1.82 HttpMethod httpMethod,
|
2997 kumpf 1.27 const String& authenticationHeader,
|
2998 david.dillard 1.121 const AcceptLanguages& acceptLanguages,
2999 const ContentLanguages& contentLanguages,
|
3000 kumpf 1.27 Uint32 contentLength)
3001 {
3002 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
|
3003 mike 1.23
|
3004 kumpf 1.82 if (httpMethod == HTTP_METHOD_M_POST)
3005 {
|
3006 mike 1.126 out << STRLIT("M-POST ") << requestUri << STRLIT(" HTTP/1.1\r\n");
|
3007 kumpf 1.82 }
3008 else
3009 {
|
3010 mike 1.126 out << STRLIT("POST ") << requestUri << STRLIT(" HTTP/1.1\r\n");
|
3011 kumpf 1.82 }
|
3012 mike 1.126 out << STRLIT("HOST: ") << host << STRLIT("\r\n");
3013 out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
3014 OUTPUT_CONTENTLENGTH;
|
3015 brian.campbell 1.107
|
3016 chuck 1.89 if (acceptLanguages.size() > 0)
3017 {
|
3018 mike 1.126 out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");
|
3019 chuck 1.89 }
3020 if (contentLanguages.size() > 0)
3021 {
|
3022 mike 1.126 out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
|
3023 david.dillard 1.121 }
|
3024 brian.campbell 1.107
|
3025 brian.campbell 1.113 #ifdef PEGASUS_DEBUG
|
3026 david.dillard 1.121 // backdoor environment variable to turn OFF client requesting transfer
|
3027 brian.campbell 1.107 // encoding. The default is on. to turn off, set this variable to zero.
3028 // This should be removed when stable. This should only be turned off in
3029 // a debugging/testing environment.
|
3030 brian.campbell 1.113
|
3031 david.dillard 1.121 static const char *clientTransferEncodingOff =
|
3032 brian.campbell 1.107 getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
3033 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
|
3034 a.dunfey 1.110 #endif
|
3035 mike 1.126 out << STRLIT("TE: chunked, trailers\r\n");
|
3036 brian.campbell 1.107
|
3037 kumpf 1.82 if (httpMethod == HTTP_METHOD_M_POST)
3038 {
|
3039 mike 1.126 out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
3040 out << nn << STRLIT("\r\n");
3041 out << nn << STRLIT("-CIMExport: MethodRequest\r\n");
3042 out << nn << STRLIT("-CIMExportMethod: ") << cimMethod << STRLIT("\r\n");
|
3043 kumpf 1.82 }
3044 else
3045 {
|
3046 mike 1.126 out << STRLIT("CIMExport: MethodRequest\r\n");
3047 out << STRLIT("CIMExportMethod: ") << cimMethod << STRLIT("\r\n");
|
3048 kumpf 1.82 }
3049
|
3050 kumpf 1.27 if (authenticationHeader.size())
3051 {
|
3052 mike 1.126 out << authenticationHeader << STRLIT("\r\n");
|
3053 kumpf 1.27 }
|
3054 brian.campbell 1.107
|
3055 mike 1.126 out << STRLIT("\r\n");
|
3056 kumpf 1.27 }
|
3057 mike 1.23
|
3058 kumpf 1.27 //------------------------------------------------------------------------------
3059 //
3060 // appendEMethodResponseHeader()
3061 //
3062 // Build HTTP response header for export operation.
3063 //
3064 //------------------------------------------------------------------------------
|
3065 mike 1.23
|
3066 kumpf 1.27 void XmlWriter::appendEMethodResponseHeader(
|
3067 mike 1.125 Buffer& out,
|
3068 kumpf 1.82 HttpMethod httpMethod,
|
3069 david.dillard 1.121 const ContentLanguages& contentLanguages,
|
3070 kumpf 1.27 Uint32 contentLength)
3071 {
3072 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
|
3073 mike 1.23
|
3074 mike 1.126 out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");
3075 out << STRLIT("Content-Type: application/xml; charset=\"utf-8\"\r\n");
3076 OUTPUT_CONTENTLENGTH;
|
3077 brian.campbell 1.107
|
3078 chuck 1.89 if (contentLanguages.size() > 0)
3079 {
|
3080 mike 1.126 out << STRLIT("Content-Language: ") << contentLanguages << STRLIT("\r\n");
|
3081 david.dillard 1.121 }
|
3082 kumpf 1.82 if (httpMethod == HTTP_METHOD_M_POST)
3083 {
|
3084 mike 1.126 out << STRLIT("Ext:\r\n");
3085 out << STRLIT("Cache-Control: no-cache\r\n");
3086 out << STRLIT("Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=");
3087 out << nn << STRLIT("\r\n");
3088 out << nn << STRLIT("-CIMExport: MethodResponse\r\n\r\n");
|
3089 kumpf 1.82 }
3090 else
3091 {
|
3092 mike 1.126 out << STRLIT("CIMExport: MethodResponse\r\n\r\n");
|
3093 kumpf 1.82 }
|
3094 mike 1.23 }
3095
3096 //------------------------------------------------------------------------------
3097 //
|
3098 kumpf 1.29 // _appendSimpleExportReqElementBegin()
3099 // _appendSimpleExportReqElementEnd()
|
3100 kumpf 1.27 //
3101 // <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
|
3102 mike 1.23 //
3103 //------------------------------------------------------------------------------
3104
|
3105 kumpf 1.29 void XmlWriter::_appendSimpleExportReqElementBegin(
|
3106 mike 1.125 Buffer& out)
|
3107 mike 1.23 {
|
3108 mike 1.126 out << STRLIT("<SIMPLEEXPREQ>\n");
|
3109 kumpf 1.27 }
|
3110 mike 1.23
|
3111 kumpf 1.29 void XmlWriter::_appendSimpleExportReqElementEnd(
|
3112 mike 1.125 Buffer& out)
|
3113 kumpf 1.27 {
|
3114 mike 1.126 out << STRLIT("</SIMPLEEXPREQ>\n");
|
3115 mike 1.23 }
3116
3117 //------------------------------------------------------------------------------
3118 //
|
3119 kumpf 1.29 // _appendEMethodCallElementBegin()
3120 // _appendEMethodCallElementEnd()
|
3121 kumpf 1.27 //
3122 // <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>
3123 // <!ATTLIST EXPMETHODCALL %CIMName;>
|
3124 mike 1.23 //
3125 //------------------------------------------------------------------------------
3126
|
3127 kumpf 1.29 void XmlWriter::_appendEMethodCallElementBegin(
|
3128 mike 1.125 Buffer& out,
|
3129 kumpf 1.80 const CIMName& name)
|
3130 mike 1.23 {
|
3131 mike 1.126 out << STRLIT("<EXPMETHODCALL NAME=\"") << name << STRLIT("\">\n");
|
3132 mike 1.24 }
3133
|
3134 kumpf 1.29 void XmlWriter::_appendEMethodCallElementEnd(
|
3135 mike 1.125 Buffer& out)
|
3136 mike 1.24 {
|
3137 mike 1.126 out << STRLIT("</EXPMETHODCALL>\n");
|
3138 mike 1.24 }
3139
3140 //------------------------------------------------------------------------------
3141 //
|
3142 kumpf 1.85 // _appendEParamValueElementBegin()
3143 // _appendEParamValueElementEnd()
3144 //
|
3145 david.dillard 1.121 // <!ELEMENT EXPPARAMVALUE (INSTANCE)>
3146 // <!ATTLIST EXPPARAMVALUE
|
3147 kumpf 1.85 // %CIMName;>
3148 //
3149 //------------------------------------------------------------------------------
3150
3151 void XmlWriter::_appendEParamValueElementBegin(
|
3152 mike 1.125 Buffer& out,
|
3153 kumpf 1.85 const char* name)
3154 {
|
3155 mike 1.126 out << STRLIT("<EXPPARAMVALUE NAME=\"") << name << STRLIT("\">\n");
|
3156 kumpf 1.85 }
3157
3158 void XmlWriter::_appendEParamValueElementEnd(
|
3159 mike 1.125 Buffer& out)
|
3160 kumpf 1.85 {
|
3161 mike 1.126 out << STRLIT("</EXPPARAMVALUE>\n");
|
3162 kumpf 1.85 }
3163
3164 //------------------------------------------------------------------------------
3165 //
3166 // appendInstanceEParameter()
3167 //
3168 //------------------------------------------------------------------------------
3169
3170 void XmlWriter::appendInstanceEParameter(
|
3171 mike 1.125 Buffer& out,
|
3172 kumpf 1.85 const char* name,
3173 const CIMInstance& instance)
3174 {
3175 _appendEParamValueElementBegin(out, name);
3176 appendInstanceElement(out, instance);
3177 _appendEParamValueElementEnd(out);
3178 }
3179
3180 //------------------------------------------------------------------------------
3181 //
|
3182 kumpf 1.29 // _appendSimpleExportRspElementBegin()
3183 // _appendSimpleExportRspElementEnd()
|
3184 mike 1.24 //
|
3185 kumpf 1.27 // <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
|
3186 mike 1.24 //
3187 //------------------------------------------------------------------------------
3188
|
3189 kumpf 1.29 void XmlWriter::_appendSimpleExportRspElementBegin(
|
3190 mike 1.125 Buffer& out)
|
3191 kumpf 1.27 {
|
3192 mike 1.126 out << STRLIT("<SIMPLEEXPRSP>\n");
|
3193 kumpf 1.27 }
3194
|
3195 kumpf 1.29 void XmlWriter::_appendSimpleExportRspElementEnd(
|
3196 mike 1.125 Buffer& out)
|
3197 mike 1.24 {
|
3198 mike 1.126 out << STRLIT("</SIMPLEEXPRSP>\n");
|
3199 mike 1.24 }
3200
3201 //------------------------------------------------------------------------------
3202 //
|
3203 kumpf 1.29 // _appendEMethodResponseElementBegin()
3204 // _appendEMethodResponseElementEnd()
|
3205 mike 1.24 //
3206 // <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
3207 // <!ATTLIST EXPMETHODRESPONSE %CIMName;>
3208 //
3209 //------------------------------------------------------------------------------
3210
|
3211 kumpf 1.29 void XmlWriter::_appendEMethodResponseElementBegin(
|
3212 mike 1.125 Buffer& out,
|
3213 kumpf 1.80 const CIMName& name)
|
3214 mike 1.24 {
|
3215 mike 1.126 out << STRLIT("<EXPMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");
|
3216 kumpf 1.27 }
3217
|
3218 kumpf 1.29 void XmlWriter::_appendEMethodResponseElementEnd(
|
3219 mike 1.125 Buffer& out)
|
3220 kumpf 1.27 {
|
3221 mike 1.126 out << STRLIT("</EXPMETHODRESPONSE>\n");
|
3222 mike 1.24 }
3223
3224 //------------------------------------------------------------------------------
3225 //
|
3226 kumpf 1.27 // XmlWriter::formatSimpleEMethodReqMessage()
|
3227 mike 1.24 //
3228 //------------------------------------------------------------------------------
3229
|
3230 mike 1.125 Buffer XmlWriter::formatSimpleEMethodReqMessage(
|
3231 kumpf 1.50 const char* requestUri,
|
3232 kumpf 1.27 const char* host,
|
3233 kumpf 1.80 const CIMName& eMethodName,
|
3234 kumpf 1.27 const String& messageId,
|
3235 kumpf 1.82 HttpMethod httpMethod,
|
3236 kumpf 1.27 const String& authenticationHeader,
|
3237 chuck 1.89 const AcceptLanguages& httpAcceptLanguages,
|
3238 david.dillard 1.121 const ContentLanguages& httpContentLanguages,
|
3239 mike 1.125 const Buffer& body)
|
3240 mike 1.24 {
|
3241 mike 1.125 Buffer out;
3242 Buffer tmp;
|
3243 kumpf 1.27
|
3244 kumpf 1.29 _appendMessageElementBegin(out, messageId);
3245 _appendSimpleExportReqElementBegin(out);
3246 _appendEMethodCallElementBegin(out, eMethodName);
|
3247 kumpf 1.27 out << body;
|
3248 kumpf 1.29 _appendEMethodCallElementEnd(out);
3249 _appendSimpleExportReqElementEnd(out);
3250 _appendMessageElementEnd(out);
|
3251 kumpf 1.27
3252 appendEMethodRequestHeader(
3253 tmp,
|
3254 kumpf 1.50 requestUri,
|
3255 kumpf 1.27 host,
3256 eMethodName,
|
3257 kumpf 1.82 httpMethod,
|
3258 kumpf 1.27 authenticationHeader,
|
3259 chuck 1.89 httpAcceptLanguages,
3260 httpContentLanguages,
|
3261 kumpf 1.27 out.size());
3262 tmp << out;
|
3263 mike 1.24
|
3264 kumpf 1.50 return tmp;
|
3265 mike 1.24 }
3266
3267 //------------------------------------------------------------------------------
3268 //
|
3269 kumpf 1.27 // XmlWriter::formatSimpleEMethodRspMessage()
|
3270 mike 1.24 //
3271 //------------------------------------------------------------------------------
3272
|
3273 mike 1.125 Buffer XmlWriter::formatSimpleEMethodRspMessage(
|
3274 kumpf 1.80 const CIMName& eMethodName,
|
3275 mike 1.24 const String& messageId,
|
3276 kumpf 1.82 HttpMethod httpMethod,
|
3277 chuck 1.89 const ContentLanguages& httpContentLanguages,
|
3278 mike 1.125 const Buffer& body)
|
3279 mike 1.24 {
|
3280 mike 1.125 Buffer out;
3281 Buffer tmp;
|
3282 kumpf 1.27
|
3283 kumpf 1.29 _appendMessageElementBegin(out, messageId);
3284 _appendSimpleExportRspElementBegin(out);
3285 _appendEMethodResponseElementBegin(out, eMethodName);
|
3286 kumpf 1.27 out << body;
|
3287 kumpf 1.29 _appendEMethodResponseElementEnd(out);
3288 _appendSimpleExportRspElementEnd(out);
3289 _appendMessageElementEnd(out);
|
3290 kumpf 1.28
|
3291 david.dillard 1.121 appendEMethodResponseHeader(tmp,
3292 httpMethod,
|
3293 chuck 1.89 httpContentLanguages,
3294 out.size());
|
3295 kumpf 1.28 tmp << out;
3296
3297 return tmp;
3298 }
3299
3300 //------------------------------------------------------------------------------
3301 //
3302 // XmlWriter::formatSimpleEMethodErrorRspMessage()
3303 //
3304 //------------------------------------------------------------------------------
3305
|
3306 mike 1.125 Buffer XmlWriter::formatSimpleEMethodErrorRspMessage(
|
3307 kumpf 1.80 const CIMName& eMethodName,
|
3308 kumpf 1.28 const String& messageId,
|
3309 kumpf 1.82 HttpMethod httpMethod,
|
3310 kumpf 1.42 const CIMException& cimException)
|
3311 kumpf 1.28 {
|
3312 mike 1.125 Buffer out;
3313 Buffer tmp;
|
3314 kumpf 1.28
|
3315 kumpf 1.29 _appendMessageElementBegin(out, messageId);
3316 _appendSimpleExportRspElementBegin(out);
|
3317 kumpf 1.80 _appendEMethodResponseElementBegin(out, eMethodName);
|
3318 kumpf 1.42 _appendErrorElement(out, cimException);
|
3319 kumpf 1.29 _appendEMethodResponseElementEnd(out);
3320 _appendSimpleExportRspElementEnd(out);
3321 _appendMessageElementEnd(out);
|
3322 kumpf 1.27
|
3323 david.dillard 1.121 // l10n
|
3324 chuck 1.89 appendEMethodResponseHeader(tmp,
3325 httpMethod,
|
3326 david.dillard 1.121 cimException.getContentLanguages(),
|
3327 chuck 1.89 out.size());
|
3328 kumpf 1.27 tmp << out;
3329
3330 return tmp;
|
3331 mike 1.24 }
3332
3333 //------------------------------------------------------------------------------
3334 //
|
3335 s.hills 1.99 // _xmlWritter_printAttributes()
|
3336 mike 1.24 //
3337 //------------------------------------------------------------------------------
3338
|
3339 s.hills 1.99 void _xmlWritter_printAttributes(
|
3340 kumpf 1.27 PEGASUS_STD(ostream)& os,
3341 const XmlAttribute* attributes,
3342 Uint32 attributeCount)
|
3343 mike 1.24 {
|
3344 kumpf 1.27 for (Uint32 i = 0; i < attributeCount; i++)
3345 {
3346 os << attributes[i].name << "=";
3347
3348 os << '"';
|
3349 s.hills 1.99 _xmlWritter_appendSpecial(os, attributes[i].value);
|
3350 kumpf 1.27 os << '"';
|
3351 mike 1.24
|
3352 kumpf 1.27 if (i + 1 != attributeCount)
3353 os << ' ';
3354 }
|
3355 mike 1.24 }
3356
3357 //------------------------------------------------------------------------------
3358 //
|
3359 s.hills 1.99 // _xmlWritter_indent()
|
3360 mike 1.24 //
3361 //------------------------------------------------------------------------------
3362
|
3363 s.hills 1.99 void _xmlWritter_indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
|
3364 mike 1.24 {
|
3365 kumpf 1.27 Uint32 n = level * indentChars;
3366
3367 for (Uint32 i = 0; i < n; i++)
3368 os << ' ';
|
3369 mike 1.24 }
3370
3371 //------------------------------------------------------------------------------
3372 //
|
3373 kumpf 1.27 // indentedPrint()
|
3374 mike 1.24 //
3375 //------------------------------------------------------------------------------
3376
|
3377 kumpf 1.27 void XmlWriter::indentedPrint(
|
3378 david.dillard 1.121 PEGASUS_STD(ostream)& os,
3379 const char* text,
|
3380 kumpf 1.27 Uint32 indentChars)
|
3381 mike 1.24 {
|
3382 a.arora 1.106 AutoArrayPtr<char> tmp(strcpy(new char[strlen(text) + 1], text));
|
3383 kumpf 1.27
|
3384 a.arora 1.106 XmlParser parser(tmp.get());
|
3385 kumpf 1.27 XmlEntry entry;
3386 Stack<const char*> stack;
|
3387 kumpf 1.26
|
3388 kumpf 1.27 while (parser.next(entry))
|
3389 kumpf 1.26 {
|
3390 kumpf 1.27 switch (entry.type)
3391 {
3392 case XmlEntry::XML_DECLARATION:
3393 {
|
3394 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
|
3395 kumpf 1.27
3396 os << "<?" << entry.text << " ";
|
3397 s.hills 1.99 _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
|
3398 kumpf 1.27 os << "?>";
3399 break;
3400 }
3401
3402 case XmlEntry::START_TAG:
3403 {
|
3404 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
|
3405 kumpf 1.27
3406 os << "<" << entry.text;
3407
3408 if (entry.attributeCount)
3409 os << ' ';
3410
|
3411 s.hills 1.99 _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
|
3412 kumpf 1.27 os << ">";
3413 stack.push(entry.text);
3414 break;
3415 }
3416
3417 case XmlEntry::EMPTY_TAG:
3418 {
|
3419 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
|
3420 kumpf 1.27
3421 os << "<" << entry.text << " ";
|
3422 s.hills 1.99 _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
|
3423 kumpf 1.27 os << "/>";
3424 break;
3425 }
3426
3427 case XmlEntry::END_TAG:
3428 {
3429 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
3430 stack.pop();
3431
|
3432 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
|
3433 kumpf 1.27
3434 os << "</" << entry.text << ">";
3435 break;
3436 }
3437
3438 case XmlEntry::COMMENT:
3439 {
3440
|
3441 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
|
3442 kumpf 1.27 os << "<!--";
|
3443 s.hills 1.99 _xmlWritter_appendSpecial(os, entry.text);
|
3444 kumpf 1.27 os << "-->";
3445 break;
3446 }
3447
3448 case XmlEntry::CONTENT:
3449 {
|
3450 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
3451 _xmlWritter_appendSpecial(os, entry.text);
|
3452 kumpf 1.27 break;
3453 }
3454
3455 case XmlEntry::CDATA:
3456 {
|
3457 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
|
3458 kumpf 1.27 os << "<![CDATA[...]]>";
3459 break;
3460 }
3461
3462 case XmlEntry::DOCTYPE:
3463 {
|
3464 s.hills 1.99 _xmlWritter_indent(os, stack.size(), indentChars);
|
3465 kumpf 1.27 os << "<!DOCTYPE...>";
3466 break;
3467 }
3468 }
3469
3470 os << PEGASUS_STD(endl);
|
3471 kumpf 1.26 }
3472
|
3473 mike 1.24 }
3474
3475 //------------------------------------------------------------------------------
3476 //
|
3477 kumpf 1.27 // XmlWriter::getNextMessageId()
|
3478 mike 1.24 //
3479 //------------------------------------------------------------------------------
3480
|
3481 kumpf 1.27 String XmlWriter::getNextMessageId()
|
3482 mike 1.24 {
|
3483 kumpf 1.27 // ATTN: make thread-safe:
3484 static Uint32 messageId = 1000;
|
3485 mike 1.24
|
3486 kumpf 1.27 messageId++;
|
3487 mike 1.24
|
3488 kumpf 1.27 if (messageId < 1000)
3489 messageId = 1001;
|
3490 mike 1.23
|
3491 kumpf 1.27 char buffer[16];
3492 sprintf(buffer, "%d", messageId);
3493 return buffer;
|
3494 kumpf 1.68 }
3495
3496 //------------------------------------------------------------------------------
3497 //
3498 // XmlWriter::keyBindingTypeToString
3499 //
3500 //------------------------------------------------------------------------------
|
3501 kumpf 1.79 const char* XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type)
|
3502 kumpf 1.68 {
3503 switch (type)
3504 {
|
3505 kumpf 1.79 case CIMKeyBinding::BOOLEAN:
|
3506 kumpf 1.68 return "boolean";
3507
|
3508 kumpf 1.79 case CIMKeyBinding::STRING:
|
3509 kumpf 1.68 return "string";
3510
|
3511 kumpf 1.79 case CIMKeyBinding::NUMERIC:
|
3512 kumpf 1.68 return "numeric";
3513
|
3514 kumpf 1.79 case CIMKeyBinding::REFERENCE:
|
3515 kumpf 1.68 default:
3516 PEGASUS_ASSERT(false);
3517 }
3518
|
3519 gs.keenan 1.124 return "unknown";
|
3520 mike 1.23 }
3521
3522 PEGASUS_NAMESPACE_END
|
Return to
XmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common