1 mike 1.23 //%/////////////////////////////////////////////////////////////////////////////
2 //
|
3 mike 1.24 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,
4 // The Open Group, Tivoli Systems
|
5 mike 1.23 //
6 // Permission is hereby granted, free of charge, to any person obtaining a copy
7 // of this software and associated documentation files (the "Software"), to
8 // deal in the Software without restriction, including without limitation the
9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 // sell copies of the Software, and to permit persons to whom the Software is
11 // furnished to do so, subject to the following conditions:
12 //
13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 //
22 //==============================================================================
23 //
24 // Author: Mike Brasher (mbrasher@bmc.com)
25 //
|
26 mike 1.24 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
27 // Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
28 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
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 kumpf 1.28 #include "Destroyer.h"
|
37 mike 1.23 #include "CIMClass.h"
|
38 kumpf 1.55 #include "CIMClassRep.h"
|
39 mike 1.23 #include "CIMInstance.h"
|
40 kumpf 1.55 #include "CIMInstanceRep.h"
|
41 kumpf 1.56 #include "CIMProperty.h"
42 #include "CIMPropertyRep.h"
43 #include "CIMMethod.h"
44 #include "CIMMethodRep.h"
45 #include "CIMParameter.h"
46 #include "CIMParameterRep.h"
47 #include "CIMParamValue.h"
48 #include "CIMParamValueRep.h"
49 #include "CIMQualifier.h"
50 #include "CIMQualifierRep.h"
51 #include "CIMQualifierDecl.h"
52 #include "CIMQualifierDeclRep.h"
|
53 kumpf 1.54 #include "CIMValue.h"
|
54 mike 1.23 #include "XmlWriter.h"
55 #include "XmlParser.h"
|
56 kumpf 1.44 #include "Tracer.h"
|
57 sage 1.49 #include <Pegasus/Common/StatisticalData.h>
|
58 mike 1.23
59 PEGASUS_NAMESPACE_BEGIN
60
|
61 kumpf 1.27 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)
62 {
63 XmlWriter::append(out, x);
64 return out;
65 }
66
67 Array<Sint8>& operator<<(Array<Sint8>& out, char x)
68 {
69 XmlWriter::append(out, x);
70 return out;
71 }
72
73 Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x)
74 {
75 XmlWriter::append(out, x);
76 return out;
77 }
78
79 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)
80 {
81 XmlWriter::append(out, x);
82 kumpf 1.27 return out;
83 }
84
85 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)
86 {
87 XmlWriter::append(out, x);
88 return out;
89 }
90
91 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)
92 {
93 out.appendArray(x);
94 return out;
95 }
96
97 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)
98 {
99 XmlWriter::append(out, x);
100 return out;
101 }
102
103 kumpf 1.27 inline void _appendChar(Array<Sint8>& out, Char16 c)
|
104 mike 1.23 {
105 out.append(Sint8(c));
106 }
107
|
108 kumpf 1.27 inline void _appendSpecialChar(Array<Sint8>& out, Char16 c)
|
109 mike 1.23 {
110 // ATTN-B: Only UTF-8 handled for now.
111
112 switch (c)
113 {
114 case '&':
115 out.append("&", 5);
116 break;
117
118 case '<':
119 out.append("<", 4);
120 break;
121
122 case '>':
123 out.append(">", 4);
124 break;
125
126 case '"':
127 out.append(""", 6);
128 break;
129
130 mike 1.23 case '\'':
131 out.append("'", 6);
132 break;
133
134 default:
135 out.append(Sint8(c));
136 }
137 }
138
|
139 kumpf 1.27 static inline void _appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
140 {
141 switch (c)
142 {
143 case '&':
144 os << "&";
145 break;
146
147 case '<':
148 os << "<";
149 break;
150
151 case '>':
152 os << ">";
153 break;
154
155 case '"':
156 os << """;
157 break;
158
159 case '\'':
160 kumpf 1.27 os << "'";
161 break;
162
163 default:
164 os << c;
165 }
166 }
167
168 static inline void _appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
169 {
170 while (*str)
171 _appendSpecialChar(os, *str++);
172 }
173
|
174 mike 1.23 void XmlWriter::append(Array<Sint8>& out, Char16 x)
175 {
|
176 kumpf 1.27 _appendChar(out, x);
|
177 mike 1.23 }
178
|
179 kumpf 1.54 void XmlWriter::append(Array<Sint8>& out, Boolean x)
180 {
181 append(out, (x ? "TRUE" : "FALSE"));
182 }
183
|
184 mike 1.23 void XmlWriter::append(Array<Sint8>& out, Uint32 x)
185 {
186 char buffer[32];
|
187 kumpf 1.54 sprintf(buffer, "%u", x);
188 append(out, buffer);
189 }
190
191 void XmlWriter::append(Array<Sint8>& out, Sint32 x)
192 {
193 char buffer[32];
|
194 mike 1.23 sprintf(buffer, "%d", x);
195 append(out, buffer);
196 }
197
|
198 kumpf 1.54 void XmlWriter::append(Array<Sint8>& out, Uint64 x)
199 {
200 char buffer[32]; // Should need 21 chars max
201 // I know I shouldn't put platform flags here, but the other way is too hard
202 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
203 sprintf(buffer, "%I64u", x);
204 #else
205 sprintf(buffer, "%llu", x);
206 #endif
207 append(out, buffer);
208 }
209
210 void XmlWriter::append(Array<Sint8>& out, Sint64 x)
211 {
212 char buffer[32]; // Should need 21 chars max
213 // I know I shouldn't put platform flags here, but the other way is too hard
214 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
215 sprintf(buffer, "%I64d", x);
216 #else
217 sprintf(buffer, "%lld", x);
218 #endif
219 kumpf 1.54 append(out, buffer);
220 }
221
222 void XmlWriter::append(Array<Sint8>& out, Real64 x)
223 {
224 char buffer[128];
225 // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec
226 sprintf(buffer, "%e", x);
227 append(out, buffer);
228 }
229
|
230 mike 1.23 void XmlWriter::append(Array<Sint8>& out, const char* str)
231 {
232 while (*str)
|
233 kumpf 1.27 _appendChar(out, *str++);
234 }
235
236 void XmlWriter::append(Array<Sint8>& out, const String& str)
237 {
238 const Char16* tmp = str.getData();
239
240 while (*tmp)
241 _appendChar(out, *tmp++);
242 }
243
244 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)
245 {
246 for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
247 out.append(' ');
|
248 mike 1.23 }
249
250 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)
251 {
|
252 kumpf 1.27 _appendSpecialChar(out, x);
|
253 mike 1.23 }
254
255 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)
256 {
|
257 kumpf 1.27 _appendSpecialChar(out, Char16(x));
|
258 mike 1.23 }
259
260 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)
261 {
262 while (*str)
|
263 kumpf 1.27 _appendSpecialChar(out, *str++);
|
264 mike 1.23 }
265
266 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)
267 {
268 const Char16* tmp = str.getData();
269
270 while (*tmp)
|
271 kumpf 1.27 _appendSpecialChar(out, *tmp++);
|
272 mike 1.23 }
273
|
274 kumpf 1.29 //------------------------------------------------------------------------------
275 //
276 // appendLocalNameSpacePathElement()
277 //
278 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
279 //
280 //------------------------------------------------------------------------------
281
282 void XmlWriter::appendLocalNameSpacePathElement(
283 Array<Sint8>& out,
|
284 mike 1.23 const String& nameSpace)
285 {
286 out << "<LOCALNAMESPACEPATH>\n";
287
288 char* tmp = nameSpace.allocateCString();
289
290 for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/"))
291 {
292 out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
293 }
294
295 delete [] tmp;
296
297 out << "</LOCALNAMESPACEPATH>\n";
298 }
299
300 //------------------------------------------------------------------------------
301 //
|
302 kumpf 1.29 // appendNameSpacePathElement()
303 //
304 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
305 //
306 //------------------------------------------------------------------------------
307
308 void XmlWriter::appendNameSpacePathElement(
309 Array<Sint8>& out,
310 const String& host,
311 const String& nameSpace)
312 {
313 out << "<NAMESPACEPATH>\n";
314 out << "<HOST>" << host << "</HOST>\n";
315 appendLocalNameSpacePathElement(out, nameSpace);
316 out << "</NAMESPACEPATH>\n";
317 }
318
319 //------------------------------------------------------------------------------
320 //
321 // appendClassNameElement()
322 //
323 kumpf 1.29 // <!ELEMENT CLASSNAME EMPTY>
324 // <!ATTLIST CLASSNAME
325 // %CIMName;>
326 //
327 //------------------------------------------------------------------------------
328
329 void XmlWriter::appendClassNameElement(
330 Array<Sint8>& out,
331 const String& className)
332 {
333 out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
334 }
335
336 //------------------------------------------------------------------------------
337 //
338 // appendInstanceNameElement()
339 //
340 // <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
341 // <!ATTLIST INSTANCENAME
342 // %ClassName;>
343 //
344 kumpf 1.29 //------------------------------------------------------------------------------
345
346 void XmlWriter::appendInstanceNameElement(
347 Array<Sint8>& out,
|
348 kumpf 1.59 const CIMObjectPath& instanceName)
|
349 kumpf 1.29 {
350 out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
351
352 Array<KeyBinding> keyBindings = instanceName.getKeyBindings();
353 for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)
354 {
355 out << "<KEYBINDING NAME=\"" << keyBindings[i].getName() << "\">\n";
356
357 if (keyBindings[i].getType() == KeyBinding::REFERENCE)
358 {
|
359 kumpf 1.59 CIMObjectPath ref = keyBindings[i].getValue();
|
360 kumpf 1.56 appendValueReferenceElement(out, ref, true);
|
361 kumpf 1.29 }
362 else {
363 out << "<KEYVALUE VALUETYPE=\"";
364 out << KeyBinding::typeToString(keyBindings[i].getType());
365 out << "\">";
366
367 // fixed the special character problem - Markus
368
369 appendSpecial(out, keyBindings[i].getValue());
370 out << "</KEYVALUE>\n";
371 }
372 out << "</KEYBINDING>\n";
373 }
374 out << "</INSTANCENAME>\n";
375 }
376
377 //------------------------------------------------------------------------------
378 //
379 // appendClassPathElement()
380 //
381 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
382 kumpf 1.29 //
383 //------------------------------------------------------------------------------
384
385 void XmlWriter::appendClassPathElement(
386 Array<Sint8>& out,
|
387 kumpf 1.59 const CIMObjectPath& classPath)
|
388 kumpf 1.29 {
389 out << "<CLASSPATH>\n";
390 appendNameSpacePathElement(out,
391 classPath.getHost(),
392 classPath.getNameSpace());
393 appendClassNameElement(out, classPath.getClassName());
394 out << "</CLASSPATH>\n";
395 }
396
397 //------------------------------------------------------------------------------
398 //
399 // appendInstancePathElement()
400 //
401 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
402 //
403 //------------------------------------------------------------------------------
404
405 void XmlWriter::appendInstancePathElement(
406 Array<Sint8>& out,
|
407 kumpf 1.59 const CIMObjectPath& instancePath)
|
408 kumpf 1.29 {
409 out << "<INSTANCEPATH>\n";
410 appendNameSpacePathElement(out,
411 instancePath.getHost(),
412 instancePath.getNameSpace());
413 appendInstanceNameElement(out, instancePath);
414 out << "</INSTANCEPATH>\n";
415 }
416
417 //------------------------------------------------------------------------------
418 //
419 // appendLocalClassPathElement()
420 //
421 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
422 //
423 //------------------------------------------------------------------------------
424
425 void XmlWriter::appendLocalClassPathElement(
426 Array<Sint8>& out,
|
427 kumpf 1.59 const CIMObjectPath& classPath)
|
428 kumpf 1.29 {
429 out << "<LOCALCLASSPATH>\n";
430 appendLocalNameSpacePathElement(out, classPath.getNameSpace());
431 appendClassNameElement(out, classPath.getClassName());
432 out << "</LOCALCLASSPATH>\n";
433 }
434
435 //------------------------------------------------------------------------------
436 //
437 // appendLocalInstancePathElement()
438 //
439 // <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>
440 //
441 //------------------------------------------------------------------------------
442
443 void XmlWriter::appendLocalInstancePathElement(
444 Array<Sint8>& out,
|
445 kumpf 1.59 const CIMObjectPath& instancePath)
|
446 kumpf 1.29 {
447 out << "<LOCALINSTANCEPATH>\n";
448 appendLocalNameSpacePathElement(out, instancePath.getNameSpace());
449 appendInstanceNameElement(out, instancePath);
450 out << "</LOCALINSTANCEPATH>\n";
451 }
452
453 //------------------------------------------------------------------------------
454 //
|
455 kumpf 1.30 // appendLocalObjectPathElement()
456 //
|
457 kumpf 1.31 // If the reference refers to an instance, write a LOCALINSTANCEPATH;
458 // otherwise write a LOCALCLASSPATH.
|
459 kumpf 1.30 //
460 //------------------------------------------------------------------------------
461
462 void XmlWriter::appendLocalObjectPathElement(
463 Array<Sint8>& out,
|
464 kumpf 1.59 const CIMObjectPath& objectPath)
|
465 kumpf 1.30 {
|
466 kumpf 1.31 if (objectPath.isInstanceName())
|
467 kumpf 1.30 {
468 appendLocalInstancePathElement(out, objectPath);
469 }
470 else
471 {
472 appendLocalClassPathElement(out, objectPath);
473 }
474 }
475
476 //------------------------------------------------------------------------------
477 //
|
478 kumpf 1.54 // Helper functions for appendValueElement()
479 //
480 //------------------------------------------------------------------------------
481
482 inline void _appendValue(Array<Sint8>& out, Boolean x)
483 {
484 XmlWriter::append(out, x);
485 }
486
487 inline void _appendValue(Array<Sint8>& out, Uint8 x)
488 {
489 XmlWriter::append(out, Uint32(x));
490 }
491
492 inline void _appendValue(Array<Sint8>& out, Sint8 x)
493 {
494 XmlWriter::append(out, Sint32(x));
495 }
496
497 inline void _appendValue(Array<Sint8>& out, Uint16 x)
498 {
499 kumpf 1.54 XmlWriter::append(out, Uint32(x));
500 }
501
502 inline void _appendValue(Array<Sint8>& out, Sint16 x)
503 {
504 XmlWriter::append(out, Sint32(x));
505 }
506
507 inline void _appendValue(Array<Sint8>& out, Uint32 x)
508 {
509 XmlWriter::append(out, x);
510 }
511
512 inline void _appendValue(Array<Sint8>& out, Sint32 x)
513 {
514 XmlWriter::append(out, x);
515 }
516
517 inline void _appendValue(Array<Sint8>& out, Uint64 x)
518 {
519 XmlWriter::append(out, x);
520 kumpf 1.54 }
521
522 inline void _appendValue(Array<Sint8>& out, Sint64 x)
523 {
524 XmlWriter::append(out, x);
525 }
526
527 inline void _appendValue(Array<Sint8>& out, Real32 x)
528 {
529 XmlWriter::append(out, Real64(x));
530 }
531
532 inline void _appendValue(Array<Sint8>& out, Real64 x)
533 {
534 XmlWriter::append(out, x);
535 }
536
537 inline void _appendValue(Array<Sint8>& out, Char16 x)
538 {
539 XmlWriter::appendSpecial(out, x);
540 }
541 kumpf 1.54
542 inline void _appendValue(Array<Sint8>& out, const String& x)
543 {
544 XmlWriter::appendSpecial(out, x);
545 }
546
547 inline void _appendValue(Array<Sint8>& out, const CIMDateTime& x)
548 {
549 out << x.getString(); //ATTN: append() method?
550 }
551
|
552 kumpf 1.59 inline void _appendValue(Array<Sint8>& out, const CIMObjectPath& x)
|
553 kumpf 1.54 {
|
554 kumpf 1.56 XmlWriter::appendValueReferenceElement(out, x, true);
|
555 kumpf 1.54 }
556
|
557 kumpf 1.59 void _appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)
|
558 kumpf 1.54 {
559 out << "<VALUE.REFARRAY>\n";
560 while (size--)
561 {
562 _appendValue(out, *p++);
563 }
564 out << "</VALUE.REFARRAY>\n";
565 }
566
567 template<class T>
568 void _appendValueArray(Array<Sint8>& out, const T* p, Uint32 size)
569 {
570 out << "<VALUE.ARRAY>\n";
571
572 while (size--)
573 {
574 out << "<VALUE>";
575 _appendValue(out, *p++);
576 out << "</VALUE>\n";
577 }
578
579 kumpf 1.54 out << "</VALUE.ARRAY>\n";
580 }
581
582 //------------------------------------------------------------------------------
583 //
584 // appendValueElement()
585 //
|
586 kumpf 1.55 // <!ELEMENT VALUE (#PCDATA)>
587 // <!ELEMENT VALUE.ARRAY (VALUE*)>
588 // <!ELEMENT VALUE.REFERENCE
589 // (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
590 // INSTANCENAME)>
591 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
592 //
|
593 kumpf 1.54 //------------------------------------------------------------------------------
594
595 void XmlWriter::appendValueElement(
|
596 kumpf 1.56 Array<Sint8>& out,
|
597 kumpf 1.54 const CIMValue& value)
598 {
599 if (value.isNull())
600 {
601 return;
602 }
603 if (value.isArray())
604 {
605 switch (value.getType())
606 {
607 case CIMType::BOOLEAN:
608 {
609 Array<Boolean> a;
610 value.get(a);
611 _appendValueArray(out, a.getData(), a.size());
612 break;
613 }
614
615 case CIMType::UINT8:
616 {
617 Array<Uint8> a;
618 kumpf 1.54 value.get(a);
619 _appendValueArray(out, a.getData(), a.size());
620 break;
621 }
622
623 case CIMType::SINT8:
624 {
625 Array<Sint8> a;
626 value.get(a);
627 _appendValueArray(out, a.getData(), a.size());
628 break;
629 }
630
631 case CIMType::UINT16:
632 {
633 Array<Uint16> a;
634 value.get(a);
635 _appendValueArray(out, a.getData(), a.size());
636 break;
637 }
638
639 kumpf 1.54 case CIMType::SINT16:
640 {
641 Array<Sint16> a;
642 value.get(a);
643 _appendValueArray(out, a.getData(), a.size());
644 break;
645 }
646
647 case CIMType::UINT32:
648 {
649 Array<Uint32> a;
650 value.get(a);
651 _appendValueArray(out, a.getData(), a.size());
652 break;
653 }
654
655 case CIMType::SINT32:
656 {
657 Array<Sint32> a;
658 value.get(a);
659 _appendValueArray(out, a.getData(), a.size());
660 kumpf 1.54 break;
661 }
662
663 case CIMType::UINT64:
664 {
665 Array<Uint64> a;
666 value.get(a);
667 _appendValueArray(out, a.getData(), a.size());
668 break;
669 }
670
671 case CIMType::SINT64:
672 {
673 Array<Sint64> a;
674 value.get(a);
675 _appendValueArray(out, a.getData(), a.size());
676 break;
677 }
678
679 case CIMType::REAL32:
680 {
681 kumpf 1.54 Array<Real32> a;
682 value.get(a);
683 _appendValueArray(out, a.getData(), a.size());
684 break;
685 }
686
687 case CIMType::REAL64:
688 {
689 Array<Real64> a;
690 value.get(a);
691 _appendValueArray(out, a.getData(), a.size());
692 break;
693 }
694
695 case CIMType::CHAR16:
696 {
697 Array<Char16> a;
698 value.get(a);
699 _appendValueArray(out, a.getData(), a.size());
700 break;
701 }
702 kumpf 1.54
703 case CIMType::STRING:
704 {
705 Array<String> a;
706 value.get(a);
707 _appendValueArray(out, a.getData(), a.size());
708 break;
709 }
710
711 case CIMType::DATETIME:
712 {
713 Array<CIMDateTime> a;
714 value.get(a);
715 _appendValueArray(out, a.getData(), a.size());
716 break;
717 }
718
719 case CIMType::REFERENCE:
720 {
|
721 kumpf 1.59 Array<CIMObjectPath> a;
|
722 kumpf 1.54 value.get(a);
723 _appendValueArray(out, a.getData(), a.size());
724 break;
725 }
726
727 default:
728 throw CIMValueInvalidType();
729 }
730 }
731 else if (value.getType() == CIMType::REFERENCE)
732 {
733 // Has to be separate because it uses VALUE.REFERENCE tag
|
734 kumpf 1.59 CIMObjectPath v;
|
735 kumpf 1.54 value.get(v);
736 _appendValue(out, v);
737 }
738 else
739 {
740 out << "<VALUE>";
741
742 switch (value.getType())
743 {
744 case CIMType::BOOLEAN:
745 {
746 Boolean v;
747 value.get(v);
748 _appendValue(out, v);
749 break;
750 }
751
752 case CIMType::UINT8:
753 {
754 Uint8 v;
755 value.get(v);
756 kumpf 1.54 _appendValue(out, v);
757 break;
758 }
759
760 case CIMType::SINT8:
761 {
762 Sint8 v;
763 value.get(v);
764 _appendValue(out, v);
765 break;
766 }
767
768 case CIMType::UINT16:
769 {
770 Uint16 v;
771 value.get(v);
772 _appendValue(out, v);
773 break;
774 }
775
776 case CIMType::SINT16:
777 kumpf 1.54 {
778 Sint16 v;
779 value.get(v);
780 _appendValue(out, v);
781 break;
782 }
783
784 case CIMType::UINT32:
785 {
786 Uint32 v;
787 value.get(v);
788 _appendValue(out, v);
789 break;
790 }
791
792 case CIMType::SINT32:
793 {
794 Sint32 v;
795 value.get(v);
796 _appendValue(out, v);
797 break;
798 kumpf 1.54 }
799
800 case CIMType::UINT64:
801 {
802 Uint64 v;
803 value.get(v);
804 _appendValue(out, v);
805 break;
806 }
807
808 case CIMType::SINT64:
809 {
810 Sint64 v;
811 value.get(v);
812 _appendValue(out, v);
813 break;
814 }
815
816 case CIMType::REAL32:
817 {
818 Real32 v;
819 kumpf 1.54 value.get(v);
820 _appendValue(out, v);
821 break;
822 }
823
824 case CIMType::REAL64:
825 {
826 Real64 v;
827 value.get(v);
828 _appendValue(out, v);
829 break;
830 }
831
832 case CIMType::CHAR16:
833 {
834 Char16 v;
835 value.get(v);
836 _appendValue(out, v);
837 break;
838 }
839
840 kumpf 1.54 case CIMType::STRING:
841 {
842 String v;
843 value.get(v);
844 _appendValue(out, v);
845 break;
846 }
847
848 case CIMType::DATETIME:
849 {
850 CIMDateTime v;
851 value.get(v);
852 _appendValue(out, v);
853 break;
854 }
855
856 default:
857 throw CIMValueInvalidType();
858 }
859
860 out << "</VALUE>\n";
861 kumpf 1.54 }
862 }
863
864 void XmlWriter::printValueElement(
865 const CIMValue& value,
866 PEGASUS_STD(ostream)& os)
867 {
868 Array<Sint8> tmp;
869 appendValueElement(tmp, value);
870 tmp.append('\0');
871 os << tmp.getData() << PEGASUS_STD(endl);
872 }
873
874 //------------------------------------------------------------------------------
875 //
|
876 kumpf 1.56 // appendValueObjectWithPathElement()
877 //
878 // <!ELEMENT VALUE.OBJECTWITHPATH
879 // ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
880 //
881 //------------------------------------------------------------------------------
882
883 void XmlWriter::appendValueObjectWithPathElement(
884 Array<Sint8>& out,
885 const CIMObjectWithPath& objectWithPath)
886 {
887 out << "<VALUE.OBJECTWITHPATH>\n";
888
889 appendValueReferenceElement(out, objectWithPath.getReference(), false);
890 appendObjectElement(out, objectWithPath.getObject());
891
892 out << "</VALUE.OBJECTWITHPATH>\n";
893 }
894
895 //------------------------------------------------------------------------------
896 //
897 kumpf 1.56 // appendValueReferenceElement()
898 //
899 // <!ELEMENT VALUE.REFERENCE
900 // (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
901 // INSTANCENAME)>
902 //
903 //------------------------------------------------------------------------------
904
905 void XmlWriter::appendValueReferenceElement(
906 Array<Sint8>& out,
|
907 kumpf 1.59 const CIMObjectPath& reference,
|
908 kumpf 1.56 Boolean putValueWrapper)
909 {
910 if (putValueWrapper)
911 out << "<VALUE.REFERENCE>\n";
912
913 // See if it is a class or instance reference (instance references have
914 // key-bindings; class references do not).
915
|
916 sage 1.60 //KeyBindingArray kbs = reference.getKeyBindingArray();
917 KeyBindingArray kbs = reference.getKeyBindings();
918
|
919 kumpf 1.56 if (kbs.size())
920 {
921 if (reference.getHost().size())
922 {
923 appendInstancePathElement(out, reference);
924 }
925 else if (reference.getNameSpace().size())
926 {
927 appendLocalInstancePathElement(out, reference);
928 }
929 else
930 {
931 appendInstanceNameElement(out, reference);
932 }
933 }
934 else
935 {
936 if (reference.getHost().size())
937 {
938 appendClassPathElement(out, reference);
939 }
940 kumpf 1.56 else if (reference.getNameSpace().size())
941 {
942 appendLocalClassPathElement(out, reference);
943 }
944 else
945 {
946 appendClassNameElement(out, reference.getClassName());
947 }
948 }
949
950 if (putValueWrapper)
951 out << "</VALUE.REFERENCE>\n";
952 }
953
954 void XmlWriter::printValueReferenceElement(
|
955 kumpf 1.59 const CIMObjectPath& reference,
|
956 kumpf 1.56 PEGASUS_STD(ostream)& os)
957 {
958 Array<Sint8> tmp;
959 appendValueReferenceElement(tmp, reference, true);
960 tmp.append('\0');
961 indentedPrint(os, tmp.getData());
962 }
963
964 //------------------------------------------------------------------------------
965 //
966 // appendValueNamedInstanceElement()
967 //
968 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
969 //
970 //------------------------------------------------------------------------------
971
972 void XmlWriter::appendValueNamedInstanceElement(
973 Array<Sint8>& out,
974 const CIMNamedInstance& namedInstance)
975 {
976 out << "<VALUE.NAMEDINSTANCE>\n";
977 kumpf 1.56
978 appendInstanceNameElement(out, namedInstance.getInstanceName());
979 appendInstanceElement(out, namedInstance.getInstance());
980
981 out << "</VALUE.NAMEDINSTANCE>\n";
982 }
983
984 //------------------------------------------------------------------------------
985 //
|
986 kumpf 1.55 // appendClassElement()
987 //
988 // <!ELEMENT CLASS
989 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
|
990 kumpf 1.56 // <!ATTLIST CLASS
|
991 kumpf 1.55 // %CIMName;
992 // %SuperClass;>
993 //
994 //------------------------------------------------------------------------------
995
996 void XmlWriter::appendClassElement(
|
997 kumpf 1.56 Array<Sint8>& out,
|
998 kumpf 1.55 const CIMConstClass& cimclass)
999 {
1000 cimclass._checkRep();
1001 cimclass._rep->toXml(out);
1002 }
1003
1004 void XmlWriter::printClassElement(
1005 const CIMConstClass& cimclass,
1006 PEGASUS_STD(ostream)& os)
1007 {
1008 Array<Sint8> tmp;
1009 appendClassElement(tmp, cimclass);
1010 tmp.append('\0');
1011 indentedPrint(os, tmp.getData(), 4);
1012 }
1013
1014 //------------------------------------------------------------------------------
1015 //
1016 // appendInstanceElement()
1017 //
1018 // <!ELEMENT INSTANCE
1019 kumpf 1.55 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
1020 // <!ATTLIST INSTANCE
1021 // %ClassName;>
1022 //
1023 //------------------------------------------------------------------------------
1024
1025 void XmlWriter::appendInstanceElement(
|
1026 kumpf 1.56 Array<Sint8>& out,
|
1027 kumpf 1.55 const CIMConstInstance& instance)
1028 {
1029 instance._checkRep();
1030 instance._rep->toXml(out);
1031 }
1032
1033 void XmlWriter::printInstanceElement(
1034 const CIMConstInstance& instance,
1035 PEGASUS_STD(ostream)& os)
1036 {
1037 Array<Sint8> tmp;
1038 appendInstanceElement(tmp, instance);
1039 tmp.append('\0');
1040 os << tmp.getData() << PEGASUS_STD(endl);
1041 }
1042
1043 //------------------------------------------------------------------------------
1044 //
|
1045 kumpf 1.56 // appendObjectElement()
1046 //
1047 // May refer to a CLASS or an INSTANCE
1048 //
1049 //------------------------------------------------------------------------------
1050
1051 void XmlWriter::appendObjectElement(
1052 Array<Sint8>& out,
1053 const CIMConstObject& object)
1054 {
1055 // ATTN-RK-P3-20020515: This could use some work
1056 try
1057 {
1058 CIMConstClass c(object);
1059 appendClassElement(out, c);
1060 }
1061 catch (DynamicCastFailed)
1062 {
1063 try
1064 {
1065 CIMConstInstance i(object);
1066 kumpf 1.56 appendInstanceElement(out, i);
1067 }
1068 catch (DynamicCastFailed)
1069 {
1070 PEGASUS_ASSERT(0);
1071 }
1072 }
1073 }
1074
1075 //------------------------------------------------------------------------------
1076 //
1077 // appendPropertyElement()
1078 //
1079 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
1080 // <!ATTLIST PROPERTY
1081 // %CIMName;
1082 // %CIMType; #REQUIRED
1083 // %ClassOrigin;
1084 // %Propagated;>
1085 //
1086 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
1087 kumpf 1.56 // <!ATTLIST PROPERTY.ARRAY
1088 // %CIMName;
1089 // %CIMType; #REQUIRED
1090 // %ArraySize;
1091 // %ClassOrigin;
1092 // %Propagated;>
1093 //
1094 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
1095 // <!ATTLIST PROPERTY.REFERENCE
1096 // %CIMName;
1097 // %ReferenceClass;
1098 // %ClassOrigin;
1099 // %Propagated;>
1100 //
1101 //------------------------------------------------------------------------------
1102
1103 void XmlWriter::appendPropertyElement(
1104 Array<Sint8>& out,
1105 const CIMConstProperty& property)
1106 {
1107 property._checkRep();
1108 kumpf 1.56 property._rep->toXml(out);
1109 }
1110
1111 void XmlWriter::printPropertyElement(
1112 const CIMConstProperty& property,
1113 PEGASUS_STD(ostream)& os)
1114 {
1115 Array<Sint8> tmp;
1116 appendPropertyElement(tmp, property);
1117 tmp.append('\0');
1118 os << tmp.getData() << PEGASUS_STD(endl);
1119 }
1120
1121 //------------------------------------------------------------------------------
1122 //
1123 // appendMethodElement()
1124 //
1125 // <!ELEMENT METHOD (QUALIFIER*,
1126 // (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
1127 // <!ATTLIST METHOD
1128 // %CIMName;
1129 kumpf 1.56 // %CIMType; #IMPLIED
1130 // %ClassOrigin;
1131 // %Propagated;>
1132 //
1133 //------------------------------------------------------------------------------
1134
1135 void XmlWriter::appendMethodElement(
1136 Array<Sint8>& out,
1137 const CIMConstMethod& method)
1138 {
1139 method._checkRep();
1140 method._rep->toXml(out);
1141 }
1142
1143 void XmlWriter::printMethodElement(
1144 const CIMConstMethod& method,
1145 PEGASUS_STD(ostream)& os)
1146 {
1147 Array<Sint8> tmp;
1148 appendMethodElement(tmp, method);
1149 tmp.append('\0');
1150 kumpf 1.56 os << tmp.getData() << PEGASUS_STD(endl);
1151 }
1152
1153 //------------------------------------------------------------------------------
1154 //
1155 // appendParameterElement()
1156 //
1157 // <!ELEMENT PARAMETER (QUALIFIER*)>
1158 // <!ATTLIST PARAMETER
1159 // %CIMName;
1160 // %CIMType; #REQUIRED>
1161 //
1162 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
1163 // <!ATTLIST PARAMETER.REFERENCE
1164 // %CIMName;
1165 // %ReferenceClass;>
1166 //
1167 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
1168 // <!ATTLIST PARAMETER.ARRAY
1169 // %CIMName;
1170 // %CIMType; #REQUIRED
1171 kumpf 1.56 // %ArraySize;>
1172 //
1173 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
1174 // <!ATTLIST PARAMETER.REFARRAY
1175 // %CIMName;
1176 // %ReferenceClass;
1177 // %ArraySize;>
1178 //
1179 //------------------------------------------------------------------------------
1180
1181 void XmlWriter::appendParameterElement(
1182 Array<Sint8>& out,
1183 const CIMConstParameter& parameter)
1184 {
1185 parameter._checkRep();
1186 parameter._rep->toXml(out);
1187 }
1188
1189 void XmlWriter::printParameterElement(
1190 const CIMConstParameter& parameter,
1191 PEGASUS_STD(ostream)& os)
1192 kumpf 1.56 {
1193 Array<Sint8> tmp;
1194 appendParameterElement(tmp, parameter);
1195 tmp.append('\0');
1196 os << tmp.getData() << PEGASUS_STD(endl);
1197 }
1198
1199 //------------------------------------------------------------------------------
1200 //
1201 // appendParamValueElement()
1202 //
1203 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
1204 // <!ATTLIST PARAMVALUE
1205 // %CIMName;>
1206 //
1207 //------------------------------------------------------------------------------
1208
1209 void XmlWriter::appendParamValueElement(
1210 Array<Sint8>& out,
1211 const CIMParamValue& paramValue)
1212 {
1213 kumpf 1.56 paramValue._checkRep();
1214 paramValue._rep->toXml(out);
1215 }
1216
1217 void XmlWriter::printParamValueElement(
1218 const CIMParamValue& paramValue,
1219 PEGASUS_STD(ostream)& os)
1220 {
1221 Array<Sint8> tmp;
1222 appendParamValueElement(tmp, paramValue);
1223 tmp.append('\0');
1224 os << tmp.getData() << PEGASUS_STD(endl);
1225 }
1226
1227 //------------------------------------------------------------------------------
1228 //
1229 // appendQualifierElement()
1230 //
1231 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
1232 // <!ATTLIST QUALIFIER
1233 // %CIMName;
1234 kumpf 1.56 // %CIMType; #REQUIRED
1235 // %Propagated;
1236 // %QualifierFlavor;>
1237 //
1238 //------------------------------------------------------------------------------
1239
1240 void XmlWriter::appendQualifierElement(
1241 Array<Sint8>& out,
1242 const CIMConstQualifier& qualifier)
1243 {
1244 qualifier._checkRep();
1245 qualifier._rep->toXml(out);
1246 }
1247
1248 void XmlWriter::printQualifierElement(
1249 const CIMConstQualifier& qualifier,
1250 PEGASUS_STD(ostream)& os)
1251 {
1252 Array<Sint8> tmp;
1253 appendQualifierElement(tmp, qualifier);
1254 tmp.append('\0');
1255 kumpf 1.56 os << tmp.getData() << PEGASUS_STD(endl);
1256 }
1257
1258 //------------------------------------------------------------------------------
1259 //
1260 // appendQualifierDeclElement()
1261 //
1262 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
1263 // <!ATTLIST QUALIFIER.DECLARATION
1264 // %CIMName;
1265 // %CIMType; #REQUIRED
1266 // ISARRAY (true|false) #IMPLIED
1267 // %ArraySize;
1268 // %QualifierFlavor;>
1269 //
1270 //------------------------------------------------------------------------------
1271
1272 void XmlWriter::appendQualifierDeclElement(
1273 Array<Sint8>& out,
1274 const CIMConstQualifierDecl& qualifierDecl)
1275 {
1276 kumpf 1.56 qualifierDecl._checkRep();
1277 qualifierDecl._rep->toXml(out);
1278 }
1279
1280 void XmlWriter::printQualifierDeclElement(
1281 const CIMConstQualifierDecl& qualifierDecl,
1282 PEGASUS_STD(ostream)& os)
1283 {
1284 Array<Sint8> tmp;
1285 appendQualifierDeclElement(tmp, qualifierDecl);
1286 tmp.append('\0');
1287 os << tmp.getData() << PEGASUS_STD(endl);
1288 }
1289
1290 //------------------------------------------------------------------------------
1291 //
|
1292 kumpf 1.57 // appendQualifierFlavorEntity()
1293 //
1294 // <!ENTITY % QualifierFlavor "OVERRIDABLE (true|false) 'true'
1295 // TOSUBCLASS (true|false) 'true'
1296 // TOINSTANCE (true|false) 'false'
1297 // TRANSLATABLE (true|false) 'false'">
1298 //
1299 //------------------------------------------------------------------------------
1300
1301 void XmlWriter::appendQualifierFlavorEntity(
1302 Array<Sint8>& out,
1303 Uint32 flavor)
1304 {
1305 if (!(flavor & CIMFlavor::OVERRIDABLE))
1306 out << " OVERRIDABLE=\"false\"";
1307
1308 if (!(flavor & CIMFlavor::TOSUBCLASS))
1309 out << " TOSUBCLASS=\"false\"";
1310
1311 if (flavor & CIMFlavor::TOINSTANCE)
1312 out << " TOINSTANCE=\"true\"";
1313 kumpf 1.57
1314 if (flavor & CIMFlavor::TRANSLATABLE)
1315 out << " TRANSLATABLE=\"true\"";
1316 }
1317
1318 //------------------------------------------------------------------------------
1319 //
|
1320 kumpf 1.58 // appendScopeElement()
1321 //
1322 // <!ELEMENT SCOPE EMPTY>
1323 // <!ATTLIST SCOPE
1324 // CLASS (true|false) 'false'
1325 // ASSOCIATION (true|false) 'false'
1326 // REFERENCE (true|false) 'false'
1327 // PROPERTY (true|false) 'false'
1328 // METHOD (true|false) 'false'
1329 // PARAMETER (true|false) 'false'
1330 // INDICATION (true|false) 'false'>
1331 //
1332 //------------------------------------------------------------------------------
1333
1334 void XmlWriter::appendScopeElement(
1335 Array<Sint8>& out,
1336 Uint32 scope)
1337 {
1338 if (scope)
1339 {
1340 out << "<SCOPE";
1341 kumpf 1.58
1342 if (scope & CIMScope::CLASS)
1343 out << " CLASS=\"true\"";
1344
1345 if (scope & CIMScope::ASSOCIATION)
1346 out << " ASSOCIATION=\"true\"";
1347
1348 if (scope & CIMScope::REFERENCE)
1349 out << " REFERENCE=\"true\"";
1350
1351 if (scope & CIMScope::PROPERTY)
1352 out << " PROPERTY=\"true\"";
1353
1354 if (scope & CIMScope::METHOD)
1355 out << " METHOD=\"true\"";
1356
1357 if (scope & CIMScope::PARAMETER)
1358 out << " PARAMETER=\"true\"";
1359
1360 if (scope & CIMScope::INDICATION)
1361 out << " INDICATION=\"true\"";
1362 kumpf 1.58
1363 out << "/>";
1364 }
1365 }
1366
1367 //------------------------------------------------------------------------------
1368 //
|
1369 kumpf 1.27 // appendMethodCallHeader()
|
1370 mike 1.23 //
|
1371 kumpf 1.31 // Build HTTP method call request header.
|
1372 mike 1.23 //
1373 //------------------------------------------------------------------------------
1374
|
1375 kumpf 1.27 void XmlWriter::appendMethodCallHeader(
1376 Array<Sint8>& out,
|
1377 mike 1.23 const char* host,
1378 const char* cimMethod,
1379 const String& cimObject,
|
1380 mike 1.24 const String& authenticationHeader,
|
1381 kumpf 1.27 Uint32 contentLength)
|
1382 mike 1.23 {
1383 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
1384
1385 out << "M-POST /cimom HTTP/1.1\r\n";
1386 out << "HOST: " << host << "\r\n";
|
1387 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
1388 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
|
1389 mike 1.23 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
1390 out << nn <<"\r\n";
|
1391 kumpf 1.27 out << nn << "-CIMOperation: MethodCall\r\n";
|
1392 mike 1.23 out << nn << "-CIMMethod: " << cimMethod << "\r\n";
|
1393 mike 1.24 out << nn << "-CIMObject: " << cimObject << "\r\n";
1394 if (authenticationHeader.size())
1395 {
1396 out << authenticationHeader << "\r\n";
1397 }
1398 out << "\r\n";
|
1399 mike 1.23 }
1400
1401 //------------------------------------------------------------------------------
1402 //
|
1403 kumpf 1.27 // appendMethodResponseHeader()
|
1404 mike 1.23 //
1405 // Build HTTP response header.
1406 //
1407 //------------------------------------------------------------------------------
1408
|
1409 kumpf 1.27 void XmlWriter::appendMethodResponseHeader(
1410 Array<Sint8>& out,
1411 Uint32 contentLength)
|
1412 mike 1.23 {
1413 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
1414
|
1415 kumpf 1.48 out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
|
1416 sage 1.49 STAT_SERVERTIME
|
1417 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
1418 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
|
1419 mike 1.23 out << "Ext:\r\n";
1420 out << "Cache-Control: no-cache\r\n";
1421 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
1422 out << nn <<"\r\n";
1423 out << nn << "-CIMOperation: MethodResponse\r\n\r\n";
1424 }
1425
1426 //------------------------------------------------------------------------------
1427 //
|
1428 kumpf 1.40 // appendHttpErrorResponseHeader()
1429 //
1430 // Build HTTP error response header.
1431 //
1432 // Returns error response message in the following format:
1433 //
|
1434 kumpf 1.41 // HTTP/1.1 400 Bad Request (using specified status code)
1435 // CIMError: <error type> (if specified by caller)
1436 // PGErrorDetail: <error text> (if specified by caller)
|
1437 kumpf 1.40 //
1438 //------------------------------------------------------------------------------
1439
1440 void XmlWriter::appendHttpErrorResponseHeader(
1441 Array<Sint8>& out,
1442 const String& status,
1443 const String& cimError,
|
1444 kumpf 1.41 const String& errorDetail)
|
1445 kumpf 1.40 {
1446 out << "HTTP/1.1 " << status << "\r\n";
1447 if (cimError != String::EMPTY)
1448 {
1449 out << "CIMError: " << cimError << "\r\n";
1450 }
|
1451 kumpf 1.41 if (errorDetail != String::EMPTY)
|
1452 kumpf 1.40 {
|
1453 kumpf 1.41 // ATTN-RK-P3-20020404: It is critical that this text not contain '\n'
1454 // ATTN-RK-P3-20020404: Need to encode this value properly. (See
1455 // CIM/HTTP Specification section 3.3.2
|
1456 kumpf 1.46 out << PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": " << errorDetail << "\r\n";
|
1457 kumpf 1.40 }
1458 out << "\r\n";
1459 }
1460
1461 //------------------------------------------------------------------------------
1462 //
|
1463 kumpf 1.27 // appendUnauthorizedResponseHeader()
1464 //
1465 // Build HTTP authentication response header for unauthorized requests.
1466 //
1467 // Returns unauthorized message in the following format:
1468 //
1469 // HTTP/1.1 401 Unauthorized
1470 // WWW-Authenticate: Basic "hostname:80"
1471 // <HTML><HEAD>
1472 // <TITLE>401 Unauthorized</TITLE>
1473 // </HEAD><BODY BGCOLOR="#99cc99">
1474 // <H2>TEST401 Unauthorized</H2>
1475 // <HR>
1476 // </BODY></HTML>
1477 //
1478 //------------------------------------------------------------------------------
1479
1480 void XmlWriter::appendUnauthorizedResponseHeader(
1481 Array<Sint8>& out,
1482 const String& content)
1483 {
|
1484 kumpf 1.40 out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";
|
1485 kumpf 1.27 out << content << "\r\n";
1486 out << "\r\n";
1487
1488 //ATTN: We may need to include the following line, so that the browsers
1489 // can display the error message.
1490 // out << "<HTML><HEAD>\r\n";
1491 // out << "<TITLE>" << "401 Unauthorized" << "</TITLE>\r\n";
1492 // out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
1493 // out << "<H2>TEST" << "401 Unauthorized" << "</H2>\r\n";
1494 // out << "<HR>\r\n";
1495 // out << "</BODY></HTML>\r\n";
1496 }
1497
1498 //------------------------------------------------------------------------------
1499 //
|
1500 kumpf 1.29 // _appendMessageElementBegin()
1501 // _appendMessageElementEnd()
|
1502 mike 1.23 //
1503 // <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
1504 // <!ATTLIST MESSAGE
1505 // ID CDATA #REQUIRED
1506 // PROTOCOLVERSION CDATA #REQUIRED>
1507 //
1508 //------------------------------------------------------------------------------
1509
|
1510 kumpf 1.29 void XmlWriter::_appendMessageElementBegin(
|
1511 kumpf 1.27 Array<Sint8>& out,
1512 const String& messageId)
|
1513 mike 1.23 {
1514 out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
1515 out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";
1516 out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
|
1517 kumpf 1.27 }
1518
|
1519 kumpf 1.29 void XmlWriter::_appendMessageElementEnd(
|
1520 kumpf 1.27 Array<Sint8>& out)
1521 {
|
1522 mike 1.23 out << "</MESSAGE>\n";
1523 out << "</CIM>\n";
1524 }
1525
1526 //------------------------------------------------------------------------------
1527 //
|
1528 kumpf 1.29 // _appendSimpleReqElementBegin()
1529 // _appendSimpleReqElementEnd()
|
1530 mike 1.23 //
1531 // <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
1532 //
1533 //------------------------------------------------------------------------------
1534
|
1535 kumpf 1.29 void XmlWriter::_appendSimpleReqElementBegin(
|
1536 kumpf 1.27 Array<Sint8>& out)
1537 {
1538 out << "<SIMPLEREQ>\n";
1539 }
1540
|
1541 kumpf 1.29 void XmlWriter::_appendSimpleReqElementEnd(
|
1542 kumpf 1.27 Array<Sint8>& out)
|
1543 mike 1.23 {
|
1544 kumpf 1.27 out << "</SIMPLEREQ>\n";
|
1545 mike 1.23 }
1546
1547 //------------------------------------------------------------------------------
1548 //
|
1549 kumpf 1.29 // _appendMethodCallElementBegin()
1550 // _appendMethodCallElementEnd()
|
1551 mike 1.23 //
|
1552 kumpf 1.27 // <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
1553 // <!ATTLIST METHODCALL %CIMName;>
|
1554 mike 1.23 //
1555 //------------------------------------------------------------------------------
1556
|
1557 kumpf 1.29 void XmlWriter::_appendMethodCallElementBegin(
|
1558 kumpf 1.27 Array<Sint8>& out,
1559 const char* name)
1560 {
1561 out << "<METHODCALL NAME=\"" << name << "\">\n";
1562 }
1563
|
1564 kumpf 1.29 void XmlWriter::_appendMethodCallElementEnd(
|
1565 kumpf 1.27 Array<Sint8>& out)
|
1566 mike 1.23 {
|
1567 kumpf 1.27 out << "</METHODCALL>\n";
|
1568 mike 1.23 }
1569
1570 //------------------------------------------------------------------------------
1571 //
|
1572 kumpf 1.29 // _appendIMethodCallElementBegin()
1573 // _appendIMethodCallElementEnd()
|
1574 mike 1.23 //
1575 // <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
1576 // <!ATTLIST IMETHODCALL %CIMName;>
1577 //
1578 //------------------------------------------------------------------------------
1579
|
1580 kumpf 1.29 void XmlWriter::_appendIMethodCallElementBegin(
|
1581 kumpf 1.27 Array<Sint8>& out,
1582 const char* name)
|
1583 mike 1.23 {
1584 out << "<IMETHODCALL NAME=\"" << name << "\">\n";
|
1585 kumpf 1.27 }
1586
|
1587 kumpf 1.29 void XmlWriter::_appendIMethodCallElementEnd(
|
1588 kumpf 1.27 Array<Sint8>& out)
1589 {
|
1590 mike 1.23 out << "</IMETHODCALL>\n";
1591 }
1592
1593 //------------------------------------------------------------------------------
1594 //
|
1595 kumpf 1.29 // _appendIParamValueElementBegin()
1596 // _appendIParamValueElementEnd()
|
1597 mike 1.23 //
|
1598 kumpf 1.27 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
1599 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
1600 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
1601 // <!ATTLIST IPARAMVALUE %CIMName;>
|
1602 mike 1.23 //
1603 //------------------------------------------------------------------------------
1604
|
1605 kumpf 1.29 void XmlWriter::_appendIParamValueElementBegin(
|
1606 kumpf 1.27 Array<Sint8>& out,
1607 const char* name)
1608 {
1609 out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
1610 }
1611
|
1612 kumpf 1.29 void XmlWriter::_appendIParamValueElementEnd(
|
1613 kumpf 1.27 Array<Sint8>& out)
|
1614 mike 1.23 {
|
1615 kumpf 1.27 out << "</IPARAMVALUE>\n";
|
1616 mike 1.23 }
1617
1618 //------------------------------------------------------------------------------
1619 //
|
1620 kumpf 1.29 // _appendSimpleRspElementBegin()
1621 // _appendSimpleRspElementEnd()
|
1622 mike 1.23 //
|
1623 kumpf 1.27 // <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
|
1624 mike 1.23 //
1625 //------------------------------------------------------------------------------
1626
|
1627 kumpf 1.29 void XmlWriter::_appendSimpleRspElementBegin(
|
1628 kumpf 1.27 Array<Sint8>& out)
1629 {
1630 out << "<SIMPLERSP>\n";
1631 }
1632
|
1633 kumpf 1.29 void XmlWriter::_appendSimpleRspElementEnd(
|
1634 kumpf 1.27 Array<Sint8>& out)
|
1635 mike 1.23 {
|
1636 kumpf 1.27 out << "</SIMPLERSP>\n";
|
1637 mike 1.23 }
1638
1639 //------------------------------------------------------------------------------
1640 //
|
1641 kumpf 1.29 // _appendMethodResponseElementBegin()
1642 // _appendMethodResponseElementEnd()
|
1643 mike 1.23 //
|
1644 kumpf 1.27 // <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
1645 // <!ATTLIST METHODRESPONSE %CIMName;>
|
1646 mike 1.23 //
1647 //------------------------------------------------------------------------------
1648
|
1649 kumpf 1.29 void XmlWriter::_appendMethodResponseElementBegin(
|
1650 mike 1.23 Array<Sint8>& out,
|
1651 kumpf 1.27 const char* name)
1652 {
1653 out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
1654 }
1655
|
1656 kumpf 1.29 void XmlWriter::_appendMethodResponseElementEnd(
|
1657 kumpf 1.27 Array<Sint8>& out)
|
1658 mike 1.23 {
|
1659 kumpf 1.27 out << "</METHODRESPONSE>\n";
1660 }
1661
1662 //------------------------------------------------------------------------------
1663 //
|
1664 kumpf 1.29 // _appendIMethodResponseElementBegin()
1665 // _appendIMethodResponseElementEnd()
|
1666 kumpf 1.27 //
1667 // <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
1668 // <!ATTLIST IMETHODRESPONSE %CIMName;>
1669 //
1670 //------------------------------------------------------------------------------
1671
|
1672 kumpf 1.29 void XmlWriter::_appendIMethodResponseElementBegin(
|
1673 kumpf 1.27 Array<Sint8>& out,
1674 const char* name)
1675 {
1676 out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
1677 }
1678
|
1679 kumpf 1.29 void XmlWriter::_appendIMethodResponseElementEnd(
|
1680 kumpf 1.27 Array<Sint8>& out)
1681 {
1682 out << "</IMETHODRESPONSE>\n";
|
1683 mike 1.23 }
1684
1685 //------------------------------------------------------------------------------
1686 //
|
1687 kumpf 1.29 // _appendErrorElement()
|
1688 mike 1.23 //
1689 //------------------------------------------------------------------------------
1690
|
1691 kumpf 1.29 void XmlWriter::_appendErrorElement(
|
1692 kumpf 1.27 Array<Sint8>& out,
|
1693 kumpf 1.42 const CIMException& cimException)
|
1694 mike 1.23 {
|
1695 kumpf 1.44 PEG_TRACE_STRING(TRC_XML_WRITER, Tracer::LEVEL2,
|
1696 kumpf 1.51 cimException.getTraceDescription());
|
1697 kumpf 1.44
|
1698 mike 1.23 out << "<ERROR";
|
1699 kumpf 1.42 out << " CODE=\"" << Uint32(cimException.getCode()) << "\"";
|
1700 kumpf 1.51 String description = cimException.getDescription();
1701 if (description != String::EMPTY)
|
1702 kumpf 1.42 {
1703 out << " DESCRIPTION=\"";
|
1704 kumpf 1.51 appendSpecial(out, description);
|
1705 kumpf 1.42 out << "\"";
1706 }
1707 out << "/>";
|
1708 mike 1.23 }
1709
1710 //------------------------------------------------------------------------------
1711 //
|
1712 kumpf 1.27 // appendReturnValueElement()
1713 //
1714 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
1715 // <!ATTLIST RETURNVALUE
1716 // %ParamType;>
|
1717 mike 1.23 //
1718 //------------------------------------------------------------------------------
1719
|
1720 kumpf 1.27 void XmlWriter::appendReturnValueElement(
|
1721 mike 1.23 Array<Sint8>& out,
|
1722 kumpf 1.27 const CIMValue& value)
1723 {
1724 out << "<RETURNVALUE";
1725
1726 CIMType type = value.getType();
1727 if (type != CIMType::NONE)
1728 {
|
1729 kumpf 1.53 out << " PARAMTYPE=\"" << type.toString() << "\"";
|
1730 kumpf 1.27 }
1731
1732 out << ">\n";
|
1733 karl 1.37
|
1734 kumpf 1.54 // Add value.
1735 appendValueElement(out, value);
|
1736 kumpf 1.27 out << "</RETURNVALUE>\n";
1737 }
1738
1739 //------------------------------------------------------------------------------
1740 //
|
1741 kumpf 1.29 // _appendIReturnValueElementBegin()
1742 // _appendIReturnValueElementEnd()
|
1743 kumpf 1.27 //
1744 // <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
1745 // VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
1746 // OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
1747 // CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
1748 //
1749 //------------------------------------------------------------------------------
1750
|
1751 kumpf 1.29 void XmlWriter::_appendIReturnValueElementBegin(
|
1752 kumpf 1.27 Array<Sint8>& out)
1753 {
1754 out << "<IRETURNVALUE>\n";
1755 }
1756
|
1757 kumpf 1.29 void XmlWriter::_appendIReturnValueElementEnd(
|
1758 kumpf 1.27 Array<Sint8>& out)
|
1759 mike 1.23 {
|
1760 kumpf 1.27 out << "</IRETURNVALUE>\n";
|
1761 mike 1.23 }
1762
1763 //------------------------------------------------------------------------------
1764 //
|
1765 kumpf 1.27 // appendBooleanIParameter()
|
1766 mike 1.23 //
1767 //------------------------------------------------------------------------------
1768
|
1769 kumpf 1.27 void XmlWriter::appendBooleanIParameter(
|
1770 mike 1.23 Array<Sint8>& out,
1771 const char* name,
|
1772 kumpf 1.27 Boolean flag)
|
1773 mike 1.23 {
|
1774 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1775 kumpf 1.54 out << "<VALUE>";
1776 append(out, flag);
1777 out << "</VALUE>\n";
|
1778 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1779 mike 1.23 }
1780
1781 //------------------------------------------------------------------------------
1782 //
|
1783 kumpf 1.27 // appendStringIParameter()
|
1784 mike 1.23 //
1785 //------------------------------------------------------------------------------
1786
|
1787 kumpf 1.27 void XmlWriter::appendStringIParameter(
|
1788 mike 1.23 Array<Sint8>& out,
1789 const char* name,
|
1790 kumpf 1.27 const String& str)
|
1791 mike 1.23 {
|
1792 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1793 kumpf 1.27 out << "<VALUE>";
1794 appendSpecial(out, str);
1795 out << "</VALUE>\n";
|
1796 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1797 mike 1.23 }
1798
1799 //------------------------------------------------------------------------------
1800 //
|
1801 kumpf 1.27 // appendQualifierNameIParameter()
|
1802 mike 1.23 //
1803 //------------------------------------------------------------------------------
1804
|
1805 kumpf 1.27 void XmlWriter::appendQualifierNameIParameter(
|
1806 mike 1.23 Array<Sint8>& out,
1807 const char* name,
1808 const String& qualifierName)
1809 {
1810 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
1811 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
1812 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
1813 //
1814 // ATTN: notice that there is really no way to pass a qualifier name
1815 // as an IPARAMVALUE element according to the spec (look above). So we
1816 // just pass it as a class name. An answer must be obtained later.
1817
|
1818 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1819 kumpf 1.27 appendClassNameElement(out, qualifierName);
|
1820 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1821 mike 1.23 }
1822
1823 //------------------------------------------------------------------------------
1824 //
|
1825 kumpf 1.27 // appendClassNameIParameter()
|
1826 mike 1.23 //
1827 //------------------------------------------------------------------------------
1828
|
1829 kumpf 1.27 void XmlWriter::appendClassNameIParameter(
|
1830 mike 1.23 Array<Sint8>& out,
|
1831 kumpf 1.27 const char* name,
1832 const String& className)
|
1833 mike 1.23 {
|
1834 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1835 kumpf 1.27 appendClassNameElement(out, className);
|
1836 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1837 mike 1.23 }
1838
1839 //------------------------------------------------------------------------------
1840 //
|
1841 kumpf 1.27 // appendInstanceNameIParameter()
|
1842 mike 1.23 //
1843 //------------------------------------------------------------------------------
1844
|
1845 kumpf 1.27 void XmlWriter::appendInstanceNameIParameter(
|
1846 mike 1.23 Array<Sint8>& out,
|
1847 kumpf 1.27 const char* name,
|
1848 kumpf 1.59 const CIMObjectPath& instanceName)
|
1849 mike 1.23 {
|
1850 kumpf 1.29 _appendIParamValueElementBegin(out, name);
1851 appendInstanceNameElement(out, instanceName);
1852 _appendIParamValueElementEnd(out);
|
1853 kumpf 1.27 }
1854
1855 void XmlWriter::appendObjectNameIParameter(
1856 Array<Sint8>& out,
1857 const char* name,
|
1858 kumpf 1.59 const CIMObjectPath& objectName)
|
1859 kumpf 1.27 {
1860 if (objectName.isClassName())
1861 {
1862 XmlWriter::appendClassNameIParameter(
1863 out, name, objectName.getClassName());
1864 }
1865 else
1866 {
1867 XmlWriter::appendInstanceNameIParameter(
1868 out, name, objectName);
1869 }
1870 }
1871
1872 //------------------------------------------------------------------------------
1873 //
1874 // appendClassIParameter()
1875 //
1876 //------------------------------------------------------------------------------
1877
1878 void XmlWriter::appendClassIParameter(
1879 Array<Sint8>& out,
1880 kumpf 1.27 const char* name,
1881 const CIMConstClass& cimClass)
1882 {
|
1883 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1884 kumpf 1.55 appendClassElement(out, cimClass);
|
1885 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1886 mike 1.23 }
1887
1888 //------------------------------------------------------------------------------
1889 //
|
1890 kumpf 1.27 // appendInstanceIParameter()
|
1891 mike 1.23 //
1892 //------------------------------------------------------------------------------
1893
|
1894 kumpf 1.27 void XmlWriter::appendInstanceIParameter(
|
1895 mike 1.23 Array<Sint8>& out,
|
1896 kumpf 1.27 const char* name,
|
1897 mike 1.23 const CIMConstInstance& instance)
1898 {
|
1899 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1900 kumpf 1.55 appendInstanceElement(out, instance);
|
1901 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1902 mike 1.23 }
1903
|
1904 mike 1.24 //------------------------------------------------------------------------------
1905 //
|
1906 kumpf 1.27 // appendNamedInstanceIParameter()
|
1907 mike 1.24 //
1908 //------------------------------------------------------------------------------
1909
|
1910 kumpf 1.27 void XmlWriter::appendNamedInstanceIParameter(
|
1911 mike 1.24 Array<Sint8>& out,
|
1912 kumpf 1.27 const char* name,
|
1913 mike 1.24 const CIMNamedInstance& namedInstance)
1914 {
|
1915 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1916 kumpf 1.56 appendValueNamedInstanceElement(out, namedInstance);
|
1917 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1918 mike 1.24 }
1919
|
1920 mike 1.23 //----------------------------------------------------------
1921 //
|
1922 kumpf 1.27 // appendPropertyNameIParameter()
|
1923 mike 1.23 //
1924 // </IPARAMVALUE>
1925 // <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
1926 //
1927 // USE: Create parameter for getProperty operation
1928 //==========================================================
|
1929 kumpf 1.27 void XmlWriter::appendPropertyNameIParameter(
|
1930 mike 1.23 Array<Sint8>& out,
1931 const String& propertyName)
1932 {
|
1933 kumpf 1.29 _appendIParamValueElementBegin(out, "PropertyName");
|
1934 kumpf 1.27 out << "<VALUE>" << propertyName << "</VALUE>\n";
|
1935 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1936 kumpf 1.27 }
|
1937 mike 1.23
1938 //------------------------------------------------------------------------------
1939 //
|
1940 kumpf 1.27 // appendPropertyValueIParameter()
|
1941 mike 1.24 //
1942 //------------------------------------------------------------------------------
1943
|
1944 kumpf 1.27 void XmlWriter::appendPropertyValueIParameter(
|
1945 mike 1.24 Array<Sint8>& out,
|
1946 kumpf 1.27 const char* name,
|
1947 mike 1.24 const CIMValue& value)
1948 {
|
1949 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1950 kumpf 1.54 appendValueElement(out, value);
|
1951 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1952 mike 1.24 }
1953
1954 //------------------------------------------------------------------------------
1955 //
|
1956 kumpf 1.27 // appendPropertyListIParameter()
|
1957 mike 1.24 //
1958 //------------------------------------------------------------------------------
1959
|
1960 kumpf 1.27 void XmlWriter::appendPropertyListIParameter(
|
1961 mike 1.24 Array<Sint8>& out,
1962 const CIMPropertyList& propertyList)
1963 {
|
1964 karl 1.37 // ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list
|
1965 kumpf 1.29 _appendIParamValueElementBegin(out, "PropertyList");
|
1966 mike 1.24
|
1967 kumpf 1.27 out << "<VALUE.ARRAY>\n";
|
1968 mike 1.24 for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)
1969 {
|
1970 kumpf 1.27 out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";
|
1971 mike 1.24 }
|
1972 kumpf 1.27 out << "</VALUE.ARRAY>\n";
1973
|
1974 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1975 mike 1.24 }
1976
1977 //------------------------------------------------------------------------------
1978 //
|
1979 kumpf 1.27 // appendQualifierDeclarationIParameter()
|
1980 mike 1.23 //
1981 //------------------------------------------------------------------------------
1982
|
1983 kumpf 1.27 void XmlWriter::appendQualifierDeclarationIParameter(
|
1984 mike 1.23 Array<Sint8>& out,
|
1985 kumpf 1.27 const char* name,
|
1986 mike 1.23 const CIMConstQualifierDecl& qualifierDecl)
1987 {
|
1988 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1989 kumpf 1.56 appendQualifierDeclElement(out, qualifierDecl);
|
1990 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1991 kumpf 1.40 }
1992
1993 //------------------------------------------------------------------------------
1994 //
1995 // XmlWriter::formatHttpErrorRspMessage()
1996 //
1997 //------------------------------------------------------------------------------
1998
1999 Array<Sint8> XmlWriter::formatHttpErrorRspMessage(
2000 const String& status,
2001 const String& cimError,
|
2002 kumpf 1.41 const String& errorDetail)
|
2003 kumpf 1.40 {
2004 Array<Sint8> out;
2005
|
2006 kumpf 1.41 appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
|
2007 kumpf 1.40
|
2008 kumpf 1.41 return out;
|
2009 mike 1.23 }
2010
2011 //------------------------------------------------------------------------------
2012 //
|
2013 kumpf 1.27 // XmlWriter::formatSimpleMethodReqMessage()
|
2014 mike 1.23 //
2015 //------------------------------------------------------------------------------
2016
|
2017 kumpf 1.27 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
2018 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
2019 const char* host,
|
2020 kumpf 1.38 const String& nameSpace,
|
2021 kumpf 1.59 const CIMObjectPath& path,
|
2022 kumpf 1.27 const char* methodName,
|
2023 kumpf 1.30 const Array<CIMParamValue>& parameters,
|
2024 kumpf 1.27 const String& messageId,
|
2025 kumpf 1.30 const String& authenticationHeader)
|
2026 kumpf 1.27 {
2027 Array<Sint8> out;
2028 Array<Sint8> tmp;
|
2029 kumpf 1.59 CIMObjectPath localObjectPath = path;
|
2030 kumpf 1.38 localObjectPath.setNameSpace(nameSpace);
|
2031 kumpf 1.27
|
2032 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2033 _appendSimpleReqElementBegin(out);
2034 _appendMethodCallElementBegin(out, methodName);
|
2035 kumpf 1.38 appendLocalObjectPathElement(out, localObjectPath);
|
2036 kumpf 1.30 for (Uint32 i=0; i < parameters.size(); i++)
|
2037 kumpf 1.29 {
|
2038 kumpf 1.56 appendParamValueElement(out, parameters[i]);
|
2039 kumpf 1.29 }
2040 _appendMethodCallElementEnd(out);
2041 _appendSimpleReqElementEnd(out);
2042 _appendMessageElementEnd(out);
|
2043 kumpf 1.27
2044 appendMethodCallHeader(
2045 tmp,
2046 host,
2047 methodName,
|
2048 kumpf 1.39 localObjectPath.toString(false),
|
2049 kumpf 1.27 authenticationHeader,
2050 out.size());
2051 tmp << out;
2052
2053 return tmp;
2054 }
2055
2056 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
2057 const char* methodName,
2058 const String& messageId,
2059 const Array<Sint8>& body)
|
2060 mike 1.23 {
|
2061 kumpf 1.27 Array<Sint8> out;
2062 Array<Sint8> tmp;
2063
|
2064 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2065 _appendSimpleRspElementBegin(out);
2066 _appendMethodResponseElementBegin(out, methodName);
|
2067 kumpf 1.27 out << body;
|
2068 kumpf 1.29 _appendMethodResponseElementEnd(out);
2069 _appendSimpleRspElementEnd(out);
2070 _appendMessageElementEnd(out);
|
2071 mike 1.23
|
2072 kumpf 1.27 appendMethodResponseHeader(tmp, out.size());
2073 tmp << out;
|
2074 mike 1.23
|
2075 kumpf 1.27 return tmp;
|
2076 mike 1.23 }
2077
2078 //------------------------------------------------------------------------------
2079 //
|
2080 kumpf 1.28 // XmlWriter::formatSimpleMethodErrorRspMessage()
2081 //
2082 //------------------------------------------------------------------------------
2083
2084 Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(
2085 const String& methodName,
2086 const String& messageId,
|
2087 kumpf 1.42 const CIMException& cimException)
|
2088 kumpf 1.28 {
2089 ArrayDestroyer<char> tmp1(methodName.allocateCString());
2090 Array<Sint8> out;
2091 Array<Sint8> tmp;
2092
|
2093 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2094 _appendSimpleRspElementBegin(out);
2095 _appendMethodResponseElementBegin(out, tmp1.getPointer());
|
2096 kumpf 1.42 _appendErrorElement(out, cimException);
|
2097 kumpf 1.29 _appendMethodResponseElementEnd(out);
2098 _appendSimpleRspElementEnd(out);
2099 _appendMessageElementEnd(out);
|
2100 kumpf 1.28
2101 appendMethodResponseHeader(tmp, out.size());
2102 tmp << out;
2103
2104 return tmp;
2105 }
2106
2107 //------------------------------------------------------------------------------
2108 //
|
2109 kumpf 1.27 // XmlWriter::formatSimpleIMethodReqMessage()
|
2110 mike 1.23 //
2111 //------------------------------------------------------------------------------
2112
|
2113 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(
2114 const char* host,
2115 const String& nameSpace,
2116 const char* iMethodName,
2117 const String& messageId,
2118 const String& authenticationHeader,
2119 const Array<Sint8>& body)
|
2120 mike 1.23 {
|
2121 kumpf 1.27 Array<Sint8> out;
2122 Array<Sint8> tmp;
2123
|
2124 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2125 _appendSimpleReqElementBegin(out);
2126 _appendIMethodCallElementBegin(out, iMethodName);
2127 appendLocalNameSpacePathElement(out, nameSpace);
|
2128 kumpf 1.27 out << body;
|
2129 kumpf 1.29 _appendIMethodCallElementEnd(out);
2130 _appendSimpleReqElementEnd(out);
2131 _appendMessageElementEnd(out);
|
2132 kumpf 1.27
2133 appendMethodCallHeader(
2134 tmp,
2135 host,
2136 iMethodName,
2137 nameSpace,
2138 authenticationHeader,
2139 out.size());
2140 tmp << out;
|
2141 mike 1.23
|
2142 kumpf 1.27 return tmp;
|
2143 mike 1.23 }
2144
2145 //------------------------------------------------------------------------------
2146 //
|
2147 kumpf 1.27 // XmlWriter::formatSimpleIMethodRspMessage()
|
2148 mike 1.23 //
2149 //------------------------------------------------------------------------------
2150
|
2151 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(
2152 const char* iMethodName,
2153 const String& messageId,
2154 const Array<Sint8>& body)
|
2155 mike 1.23 {
|
2156 kumpf 1.27 Array<Sint8> out;
2157 Array<Sint8> tmp;
|
2158 mike 1.23
|
2159 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2160 _appendSimpleRspElementBegin(out);
2161 _appendIMethodResponseElementBegin(out, iMethodName);
|
2162 kumpf 1.45 if (body.size() != 0)
2163 {
2164 _appendIReturnValueElementBegin(out);
2165 out << body;
2166 _appendIReturnValueElementEnd(out);
2167 }
|
2168 kumpf 1.29 _appendIMethodResponseElementEnd(out);
2169 _appendSimpleRspElementEnd(out);
2170 _appendMessageElementEnd(out);
|
2171 mike 1.23
|
2172 kumpf 1.27 appendMethodResponseHeader(tmp, out.size());
2173 tmp << out;
|
2174 mike 1.23
|
2175 kumpf 1.27 return tmp;
2176 }
|
2177 mike 1.23
|
2178 kumpf 1.28 //------------------------------------------------------------------------------
2179 //
2180 // XmlWriter::formatSimpleIMethodErrorRspMessage()
2181 //
2182 //------------------------------------------------------------------------------
2183
2184 Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(
2185 const String& iMethodName,
2186 const String& messageId,
|
2187 kumpf 1.42 const CIMException& cimException)
|
2188 kumpf 1.28 {
2189 ArrayDestroyer<char> tmp1(iMethodName.allocateCString());
2190 Array<Sint8> out;
2191 Array<Sint8> tmp;
2192
|
2193 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2194 _appendSimpleRspElementBegin(out);
2195 _appendIMethodResponseElementBegin(out, tmp1.getPointer());
|
2196 kumpf 1.42 _appendErrorElement(out, cimException);
|
2197 kumpf 1.29 _appendIMethodResponseElementEnd(out);
2198 _appendSimpleRspElementEnd(out);
2199 _appendMessageElementEnd(out);
|
2200 kumpf 1.28
2201 appendMethodResponseHeader(tmp, out.size());
2202 tmp << out;
2203
2204 return tmp;
2205 }
2206
|
2207 kumpf 1.27 //******************************************************************************
2208 //
2209 // Export Messages (used for indications)
2210 //
2211 //******************************************************************************
|
2212 mike 1.23
|
2213 kumpf 1.27 //------------------------------------------------------------------------------
2214 //
2215 // appendEMethodRequestHeader()
2216 //
2217 // Build HTTP request header for export operation.
2218 //
2219 //------------------------------------------------------------------------------
|
2220 mike 1.23
|
2221 kumpf 1.27 void XmlWriter::appendEMethodRequestHeader(
2222 Array<Sint8>& out,
|
2223 kumpf 1.50 const char* requestUri,
|
2224 kumpf 1.27 const char* host,
2225 const char* cimMethod,
2226 const String& authenticationHeader,
2227 Uint32 contentLength)
2228 {
2229 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
|
2230 mike 1.23
|
2231 kumpf 1.50 out << "M-POST " << requestUri << " HTTP/1.1\r\n";
|
2232 kumpf 1.27 out << "HOST: " << host << "\r\n";
|
2233 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
2234 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
2235 out << "Man: http://www.hp.com; ns=";
2236 out << nn <<"\r\n";
|
2237 kumpf 1.32 out << nn << "-CIMExport: MethodRequest\r\n";
|
2238 kumpf 1.27 out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
2239 if (authenticationHeader.size())
2240 {
2241 out << authenticationHeader << "\r\n";
2242 }
2243 out << "\r\n";
2244 }
|
2245 mike 1.23
|
2246 kumpf 1.27 //------------------------------------------------------------------------------
2247 //
2248 // appendEMethodResponseHeader()
2249 //
2250 // Build HTTP response header for export operation.
2251 //
2252 //------------------------------------------------------------------------------
|
2253 mike 1.23
|
2254 kumpf 1.27 void XmlWriter::appendEMethodResponseHeader(
2255 Array<Sint8>& out,
2256 Uint32 contentLength)
2257 {
2258 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
|
2259 mike 1.23
|
2260 kumpf 1.48 out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
|
2261 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
2262 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
2263 out << "Ext:\r\n";
2264 out << "Cache-Control: no-cache\r\n";
|
2265 kumpf 1.47 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
|
2266 kumpf 1.27 out << nn <<"\r\n";
2267 out << nn << "-CIMExport: MethodResponse\r\n\r\n";
|
2268 mike 1.23 }
2269
2270 //------------------------------------------------------------------------------
2271 //
|
2272 kumpf 1.29 // _appendSimpleExportReqElementBegin()
2273 // _appendSimpleExportReqElementEnd()
|
2274 kumpf 1.27 //
2275 // <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
|
2276 mike 1.23 //
2277 //------------------------------------------------------------------------------
2278
|
2279 kumpf 1.29 void XmlWriter::_appendSimpleExportReqElementBegin(
|
2280 kumpf 1.27 Array<Sint8>& out)
|
2281 mike 1.23 {
|
2282 kumpf 1.27 out << "<SIMPLEEXPREQ>\n";
2283 }
|
2284 mike 1.23
|
2285 kumpf 1.29 void XmlWriter::_appendSimpleExportReqElementEnd(
|
2286 kumpf 1.27 Array<Sint8>& out)
2287 {
2288 out << "</SIMPLEEXPREQ>\n";
|
2289 mike 1.23 }
2290
2291 //------------------------------------------------------------------------------
2292 //
|
2293 kumpf 1.29 // _appendEMethodCallElementBegin()
2294 // _appendEMethodCallElementEnd()
|
2295 kumpf 1.27 //
2296 // <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>
2297 // <!ATTLIST EXPMETHODCALL %CIMName;>
|
2298 mike 1.23 //
2299 //------------------------------------------------------------------------------
2300
|
2301 kumpf 1.29 void XmlWriter::_appendEMethodCallElementBegin(
|
2302 mike 1.23 Array<Sint8>& out,
|
2303 kumpf 1.27 const char* name)
|
2304 mike 1.23 {
|
2305 kumpf 1.27 out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
|
2306 mike 1.24 }
2307
|
2308 kumpf 1.29 void XmlWriter::_appendEMethodCallElementEnd(
|
2309 kumpf 1.27 Array<Sint8>& out)
|
2310 mike 1.24 {
2311 out << "</EXPMETHODCALL>\n";
2312 }
2313
2314 //------------------------------------------------------------------------------
2315 //
|
2316 kumpf 1.29 // _appendSimpleExportRspElementBegin()
2317 // _appendSimpleExportRspElementEnd()
|
2318 mike 1.24 //
|
2319 kumpf 1.27 // <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
|
2320 mike 1.24 //
2321 //------------------------------------------------------------------------------
2322
|
2323 kumpf 1.29 void XmlWriter::_appendSimpleExportRspElementBegin(
|
2324 kumpf 1.27 Array<Sint8>& out)
2325 {
2326 out << "<SIMPLEEXPRSP>\n";
2327 }
2328
|
2329 kumpf 1.29 void XmlWriter::_appendSimpleExportRspElementEnd(
|
2330 kumpf 1.27 Array<Sint8>& out)
|
2331 mike 1.24 {
|
2332 kumpf 1.27 out << "</SIMPLEEXPRSP>\n";
|
2333 mike 1.24 }
2334
2335 //------------------------------------------------------------------------------
2336 //
|
2337 kumpf 1.29 // _appendEMethodResponseElementBegin()
2338 // _appendEMethodResponseElementEnd()
|
2339 mike 1.24 //
2340 // <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
2341 // <!ATTLIST EXPMETHODRESPONSE %CIMName;>
2342 //
2343 //------------------------------------------------------------------------------
2344
|
2345 kumpf 1.29 void XmlWriter::_appendEMethodResponseElementBegin(
|
2346 kumpf 1.27 Array<Sint8>& out,
2347 const char* name)
|
2348 mike 1.24 {
2349 out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
|
2350 kumpf 1.27 }
2351
|
2352 kumpf 1.29 void XmlWriter::_appendEMethodResponseElementEnd(
|
2353 kumpf 1.27 Array<Sint8>& out)
2354 {
|
2355 mike 1.24 out << "</EXPMETHODRESPONSE>\n";
2356 }
2357
2358 //------------------------------------------------------------------------------
2359 //
|
2360 kumpf 1.27 // XmlWriter::formatSimpleEMethodReqMessage()
|
2361 mike 1.24 //
2362 //------------------------------------------------------------------------------
2363
|
2364 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(
|
2365 kumpf 1.50 const char* requestUri,
|
2366 kumpf 1.27 const char* host,
2367 const char* eMethodName,
2368 const String& messageId,
2369 const String& authenticationHeader,
2370 const Array<Sint8>& body)
|
2371 mike 1.24 {
2372 Array<Sint8> out;
|
2373 kumpf 1.27 Array<Sint8> tmp;
2374
|
2375 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2376 _appendSimpleExportReqElementBegin(out);
2377 _appendEMethodCallElementBegin(out, eMethodName);
|
2378 kumpf 1.27 out << body;
|
2379 kumpf 1.29 _appendEMethodCallElementEnd(out);
2380 _appendSimpleExportReqElementEnd(out);
2381 _appendMessageElementEnd(out);
|
2382 kumpf 1.27
2383 appendEMethodRequestHeader(
2384 tmp,
|
2385 kumpf 1.50 requestUri,
|
2386 kumpf 1.27 host,
2387 eMethodName,
2388 authenticationHeader,
2389 out.size());
2390 tmp << out;
|
2391 mike 1.24
|
2392 kumpf 1.50 return tmp;
|
2393 mike 1.24 }
2394
2395 //------------------------------------------------------------------------------
2396 //
|
2397 kumpf 1.27 // XmlWriter::formatSimpleEMethodRspMessage()
|
2398 mike 1.24 //
2399 //------------------------------------------------------------------------------
2400
|
2401 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(
2402 const char* eMethodName,
|
2403 mike 1.24 const String& messageId,
2404 const Array<Sint8>& body)
2405 {
|
2406 kumpf 1.27 Array<Sint8> out;
2407 Array<Sint8> tmp;
2408
|
2409 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2410 _appendSimpleExportRspElementBegin(out);
2411 _appendEMethodResponseElementBegin(out, eMethodName);
|
2412 kumpf 1.27 out << body;
|
2413 kumpf 1.29 _appendEMethodResponseElementEnd(out);
2414 _appendSimpleExportRspElementEnd(out);
2415 _appendMessageElementEnd(out);
|
2416 kumpf 1.28
2417 appendEMethodResponseHeader(tmp, out.size());
2418 tmp << out;
2419
2420 return tmp;
2421 }
2422
2423 //------------------------------------------------------------------------------
2424 //
2425 // XmlWriter::formatSimpleEMethodErrorRspMessage()
2426 //
2427 //------------------------------------------------------------------------------
2428
2429 Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(
2430 const String& eMethodName,
2431 const String& messageId,
|
2432 kumpf 1.42 const CIMException& cimException)
|
2433 kumpf 1.28 {
2434 ArrayDestroyer<char> tmp1(eMethodName.allocateCString());
2435 Array<Sint8> out;
2436 Array<Sint8> tmp;
2437
|
2438 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2439 _appendSimpleExportRspElementBegin(out);
2440 _appendEMethodResponseElementBegin(out, tmp1.getPointer());
|
2441 kumpf 1.42 _appendErrorElement(out, cimException);
|
2442 kumpf 1.29 _appendEMethodResponseElementEnd(out);
2443 _appendSimpleExportRspElementEnd(out);
2444 _appendMessageElementEnd(out);
|
2445 kumpf 1.27
2446 appendEMethodResponseHeader(tmp, out.size());
2447 tmp << out;
2448
2449 return tmp;
|
2450 mike 1.24 }
2451
2452 //------------------------------------------------------------------------------
2453 //
|
2454 kumpf 1.27 // _printAttributes()
|
2455 mike 1.24 //
2456 //------------------------------------------------------------------------------
2457
|
2458 kumpf 1.27 static void _printAttributes(
2459 PEGASUS_STD(ostream)& os,
2460 const XmlAttribute* attributes,
2461 Uint32 attributeCount)
|
2462 mike 1.24 {
|
2463 kumpf 1.27 for (Uint32 i = 0; i < attributeCount; i++)
2464 {
2465 os << attributes[i].name << "=";
2466
2467 os << '"';
2468 _appendSpecial(os, attributes[i].value);
2469 os << '"';
|
2470 mike 1.24
|
2471 kumpf 1.27 if (i + 1 != attributeCount)
2472 os << ' ';
2473 }
|
2474 mike 1.24 }
2475
2476 //------------------------------------------------------------------------------
2477 //
|
2478 kumpf 1.27 // _indent()
|
2479 mike 1.24 //
2480 //------------------------------------------------------------------------------
2481
|
2482 kumpf 1.27 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
|
2483 mike 1.24 {
|
2484 kumpf 1.27 Uint32 n = level * indentChars;
2485
2486 for (Uint32 i = 0; i < n; i++)
2487 os << ' ';
|
2488 mike 1.24 }
2489
2490 //------------------------------------------------------------------------------
2491 //
|
2492 kumpf 1.27 // indentedPrint()
|
2493 mike 1.24 //
2494 //------------------------------------------------------------------------------
2495
|
2496 kumpf 1.27 void XmlWriter::indentedPrint(
2497 PEGASUS_STD(ostream)& os,
2498 const char* text,
2499 Uint32 indentChars)
|
2500 mike 1.24 {
|
2501 kumpf 1.27 char* tmp = strcpy(new char[strlen(text) + 1], text);
2502
2503 XmlParser parser(tmp);
2504 XmlEntry entry;
2505 Stack<const char*> stack;
|
2506 kumpf 1.26
|
2507 kumpf 1.27 while (parser.next(entry))
|
2508 kumpf 1.26 {
|
2509 kumpf 1.27 switch (entry.type)
2510 {
2511 case XmlEntry::XML_DECLARATION:
2512 {
2513 _indent(os, stack.size(), indentChars);
2514
2515 os << "<?" << entry.text << " ";
2516 _printAttributes(os, entry.attributes, entry.attributeCount);
2517 os << "?>";
2518 break;
2519 }
2520
2521 case XmlEntry::START_TAG:
2522 {
2523 _indent(os, stack.size(), indentChars);
2524
2525 os << "<" << entry.text;
2526
2527 if (entry.attributeCount)
2528 os << ' ';
2529
2530 kumpf 1.27 _printAttributes(os, entry.attributes, entry.attributeCount);
2531 os << ">";
2532 stack.push(entry.text);
2533 break;
2534 }
2535
2536 case XmlEntry::EMPTY_TAG:
2537 {
2538 _indent(os, stack.size(), indentChars);
2539
2540 os << "<" << entry.text << " ";
2541 _printAttributes(os, entry.attributes, entry.attributeCount);
2542 os << "/>";
2543 break;
2544 }
2545
2546 case XmlEntry::END_TAG:
2547 {
2548 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
2549 stack.pop();
2550
2551 kumpf 1.27 _indent(os, stack.size(), indentChars);
2552
2553 os << "</" << entry.text << ">";
2554 break;
2555 }
2556
2557 case XmlEntry::COMMENT:
2558 {
2559
2560 _indent(os, stack.size(), indentChars);
2561 os << "<!--";
2562 _appendSpecial(os, entry.text);
2563 os << "-->";
2564 break;
2565 }
2566
2567 case XmlEntry::CONTENT:
2568 {
2569 _indent(os, stack.size(), indentChars);
2570 _appendSpecial(os, entry.text);
2571 break;
2572 kumpf 1.27 }
2573
2574 case XmlEntry::CDATA:
2575 {
2576 _indent(os, stack.size(), indentChars);
2577 os << "<![CDATA[...]]>";
2578 break;
2579 }
2580
2581 case XmlEntry::DOCTYPE:
2582 {
2583 _indent(os, stack.size(), indentChars);
2584 os << "<!DOCTYPE...>";
2585 break;
2586 }
2587 }
2588
2589 os << PEGASUS_STD(endl);
|
2590 kumpf 1.26 }
2591
|
2592 kumpf 1.27 delete [] tmp;
|
2593 mike 1.24 }
2594
2595 //------------------------------------------------------------------------------
2596 //
|
2597 kumpf 1.27 // XmlWriter::getNextMessageId()
|
2598 mike 1.24 //
2599 //------------------------------------------------------------------------------
2600
|
2601 kumpf 1.27 String XmlWriter::getNextMessageId()
|
2602 mike 1.24 {
|
2603 kumpf 1.27 // ATTN: make thread-safe:
2604 static Uint32 messageId = 1000;
|
2605 mike 1.24
|
2606 kumpf 1.27 messageId++;
|
2607 mike 1.24
|
2608 kumpf 1.27 if (messageId < 1000)
2609 messageId = 1001;
|
2610 mike 1.23
|
2611 kumpf 1.27 char buffer[16];
2612 sprintf(buffer, "%d", messageId);
2613 return buffer;
|
2614 mike 1.23 }
2615
2616 PEGASUS_NAMESPACE_END
|
Return to
XmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common