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