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