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