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 KeyBindingArray kbs = reference.getKeyBindingArray();
917 if (kbs.size())
918 {
919 if (reference.getHost().size())
920 {
921 appendInstancePathElement(out, reference);
922 }
923 else if (reference.getNameSpace().size())
924 {
925 appendLocalInstancePathElement(out, reference);
926 }
927 else
928 {
929 kumpf 1.56 appendInstanceNameElement(out, reference);
930 }
931 }
932 else
933 {
934 if (reference.getHost().size())
935 {
936 appendClassPathElement(out, reference);
937 }
938 else if (reference.getNameSpace().size())
939 {
940 appendLocalClassPathElement(out, reference);
941 }
942 else
943 {
944 appendClassNameElement(out, reference.getClassName());
945 }
946 }
947
948 if (putValueWrapper)
949 out << "</VALUE.REFERENCE>\n";
950 kumpf 1.56 }
951
952 void XmlWriter::printValueReferenceElement(
|
953 kumpf 1.59 const CIMObjectPath& reference,
|
954 kumpf 1.56 PEGASUS_STD(ostream)& os)
955 {
956 Array<Sint8> tmp;
957 appendValueReferenceElement(tmp, reference, true);
958 tmp.append('\0');
959 indentedPrint(os, tmp.getData());
960 }
961
962 //------------------------------------------------------------------------------
963 //
964 // appendValueNamedInstanceElement()
965 //
966 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
967 //
968 //------------------------------------------------------------------------------
969
970 void XmlWriter::appendValueNamedInstanceElement(
971 Array<Sint8>& out,
972 const CIMNamedInstance& namedInstance)
973 {
974 out << "<VALUE.NAMEDINSTANCE>\n";
975 kumpf 1.56
976 appendInstanceNameElement(out, namedInstance.getInstanceName());
977 appendInstanceElement(out, namedInstance.getInstance());
978
979 out << "</VALUE.NAMEDINSTANCE>\n";
980 }
981
982 //------------------------------------------------------------------------------
983 //
|
984 kumpf 1.55 // appendClassElement()
985 //
986 // <!ELEMENT CLASS
987 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
|
988 kumpf 1.56 // <!ATTLIST CLASS
|
989 kumpf 1.55 // %CIMName;
990 // %SuperClass;>
991 //
992 //------------------------------------------------------------------------------
993
994 void XmlWriter::appendClassElement(
|
995 kumpf 1.56 Array<Sint8>& out,
|
996 kumpf 1.55 const CIMConstClass& cimclass)
997 {
998 cimclass._checkRep();
999 cimclass._rep->toXml(out);
1000 }
1001
1002 void XmlWriter::printClassElement(
1003 const CIMConstClass& cimclass,
1004 PEGASUS_STD(ostream)& os)
1005 {
1006 Array<Sint8> tmp;
1007 appendClassElement(tmp, cimclass);
1008 tmp.append('\0');
1009 indentedPrint(os, tmp.getData(), 4);
1010 }
1011
1012 //------------------------------------------------------------------------------
1013 //
1014 // appendInstanceElement()
1015 //
1016 // <!ELEMENT INSTANCE
1017 kumpf 1.55 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
1018 // <!ATTLIST INSTANCE
1019 // %ClassName;>
1020 //
1021 //------------------------------------------------------------------------------
1022
1023 void XmlWriter::appendInstanceElement(
|
1024 kumpf 1.56 Array<Sint8>& out,
|
1025 kumpf 1.55 const CIMConstInstance& instance)
1026 {
1027 instance._checkRep();
1028 instance._rep->toXml(out);
1029 }
1030
1031 void XmlWriter::printInstanceElement(
1032 const CIMConstInstance& instance,
1033 PEGASUS_STD(ostream)& os)
1034 {
1035 Array<Sint8> tmp;
1036 appendInstanceElement(tmp, instance);
1037 tmp.append('\0');
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 Array<Sint8>& out,
1051 const CIMConstObject& object)
1052 {
1053 // ATTN-RK-P3-20020515: This could use some work
1054 try
1055 {
1056 CIMConstClass c(object);
1057 appendClassElement(out, c);
1058 }
1059 catch (DynamicCastFailed)
1060 {
1061 try
1062 {
1063 CIMConstInstance i(object);
1064 kumpf 1.56 appendInstanceElement(out, i);
1065 }
1066 catch (DynamicCastFailed)
1067 {
1068 PEGASUS_ASSERT(0);
1069 }
1070 }
1071 }
1072
1073 //------------------------------------------------------------------------------
1074 //
1075 // appendPropertyElement()
1076 //
1077 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
1078 // <!ATTLIST PROPERTY
1079 // %CIMName;
1080 // %CIMType; #REQUIRED
1081 // %ClassOrigin;
1082 // %Propagated;>
1083 //
1084 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
1085 kumpf 1.56 // <!ATTLIST PROPERTY.ARRAY
1086 // %CIMName;
1087 // %CIMType; #REQUIRED
1088 // %ArraySize;
1089 // %ClassOrigin;
1090 // %Propagated;>
1091 //
1092 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
1093 // <!ATTLIST PROPERTY.REFERENCE
1094 // %CIMName;
1095 // %ReferenceClass;
1096 // %ClassOrigin;
1097 // %Propagated;>
1098 //
1099 //------------------------------------------------------------------------------
1100
1101 void XmlWriter::appendPropertyElement(
1102 Array<Sint8>& out,
1103 const CIMConstProperty& property)
1104 {
1105 property._checkRep();
1106 kumpf 1.56 property._rep->toXml(out);
1107 }
1108
1109 void XmlWriter::printPropertyElement(
1110 const CIMConstProperty& property,
1111 PEGASUS_STD(ostream)& os)
1112 {
1113 Array<Sint8> tmp;
1114 appendPropertyElement(tmp, property);
1115 tmp.append('\0');
1116 os << tmp.getData() << PEGASUS_STD(endl);
1117 }
1118
1119 //------------------------------------------------------------------------------
1120 //
1121 // appendMethodElement()
1122 //
1123 // <!ELEMENT METHOD (QUALIFIER*,
1124 // (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
1125 // <!ATTLIST METHOD
1126 // %CIMName;
1127 kumpf 1.56 // %CIMType; #IMPLIED
1128 // %ClassOrigin;
1129 // %Propagated;>
1130 //
1131 //------------------------------------------------------------------------------
1132
1133 void XmlWriter::appendMethodElement(
1134 Array<Sint8>& out,
1135 const CIMConstMethod& method)
1136 {
1137 method._checkRep();
1138 method._rep->toXml(out);
1139 }
1140
1141 void XmlWriter::printMethodElement(
1142 const CIMConstMethod& method,
1143 PEGASUS_STD(ostream)& os)
1144 {
1145 Array<Sint8> tmp;
1146 appendMethodElement(tmp, method);
1147 tmp.append('\0');
1148 kumpf 1.56 os << tmp.getData() << PEGASUS_STD(endl);
1149 }
1150
1151 //------------------------------------------------------------------------------
1152 //
1153 // appendParameterElement()
1154 //
1155 // <!ELEMENT PARAMETER (QUALIFIER*)>
1156 // <!ATTLIST PARAMETER
1157 // %CIMName;
1158 // %CIMType; #REQUIRED>
1159 //
1160 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
1161 // <!ATTLIST PARAMETER.REFERENCE
1162 // %CIMName;
1163 // %ReferenceClass;>
1164 //
1165 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
1166 // <!ATTLIST PARAMETER.ARRAY
1167 // %CIMName;
1168 // %CIMType; #REQUIRED
1169 kumpf 1.56 // %ArraySize;>
1170 //
1171 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
1172 // <!ATTLIST PARAMETER.REFARRAY
1173 // %CIMName;
1174 // %ReferenceClass;
1175 // %ArraySize;>
1176 //
1177 //------------------------------------------------------------------------------
1178
1179 void XmlWriter::appendParameterElement(
1180 Array<Sint8>& out,
1181 const CIMConstParameter& parameter)
1182 {
1183 parameter._checkRep();
1184 parameter._rep->toXml(out);
1185 }
1186
1187 void XmlWriter::printParameterElement(
1188 const CIMConstParameter& parameter,
1189 PEGASUS_STD(ostream)& os)
1190 kumpf 1.56 {
1191 Array<Sint8> tmp;
1192 appendParameterElement(tmp, parameter);
1193 tmp.append('\0');
1194 os << tmp.getData() << PEGASUS_STD(endl);
1195 }
1196
1197 //------------------------------------------------------------------------------
1198 //
1199 // appendParamValueElement()
1200 //
1201 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
1202 // <!ATTLIST PARAMVALUE
1203 // %CIMName;>
1204 //
1205 //------------------------------------------------------------------------------
1206
1207 void XmlWriter::appendParamValueElement(
1208 Array<Sint8>& out,
1209 const CIMParamValue& paramValue)
1210 {
1211 kumpf 1.56 paramValue._checkRep();
1212 paramValue._rep->toXml(out);
1213 }
1214
1215 void XmlWriter::printParamValueElement(
1216 const CIMParamValue& paramValue,
1217 PEGASUS_STD(ostream)& os)
1218 {
1219 Array<Sint8> tmp;
1220 appendParamValueElement(tmp, paramValue);
1221 tmp.append('\0');
1222 os << tmp.getData() << PEGASUS_STD(endl);
1223 }
1224
1225 //------------------------------------------------------------------------------
1226 //
1227 // appendQualifierElement()
1228 //
1229 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
1230 // <!ATTLIST QUALIFIER
1231 // %CIMName;
1232 kumpf 1.56 // %CIMType; #REQUIRED
1233 // %Propagated;
1234 // %QualifierFlavor;>
1235 //
1236 //------------------------------------------------------------------------------
1237
1238 void XmlWriter::appendQualifierElement(
1239 Array<Sint8>& out,
1240 const CIMConstQualifier& qualifier)
1241 {
1242 qualifier._checkRep();
1243 qualifier._rep->toXml(out);
1244 }
1245
1246 void XmlWriter::printQualifierElement(
1247 const CIMConstQualifier& qualifier,
1248 PEGASUS_STD(ostream)& os)
1249 {
1250 Array<Sint8> tmp;
1251 appendQualifierElement(tmp, qualifier);
1252 tmp.append('\0');
1253 kumpf 1.56 os << tmp.getData() << PEGASUS_STD(endl);
1254 }
1255
1256 //------------------------------------------------------------------------------
1257 //
1258 // appendQualifierDeclElement()
1259 //
1260 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
1261 // <!ATTLIST QUALIFIER.DECLARATION
1262 // %CIMName;
1263 // %CIMType; #REQUIRED
1264 // ISARRAY (true|false) #IMPLIED
1265 // %ArraySize;
1266 // %QualifierFlavor;>
1267 //
1268 //------------------------------------------------------------------------------
1269
1270 void XmlWriter::appendQualifierDeclElement(
1271 Array<Sint8>& out,
1272 const CIMConstQualifierDecl& qualifierDecl)
1273 {
1274 kumpf 1.56 qualifierDecl._checkRep();
1275 qualifierDecl._rep->toXml(out);
1276 }
1277
1278 void XmlWriter::printQualifierDeclElement(
1279 const CIMConstQualifierDecl& qualifierDecl,
1280 PEGASUS_STD(ostream)& os)
1281 {
1282 Array<Sint8> tmp;
1283 appendQualifierDeclElement(tmp, qualifierDecl);
1284 tmp.append('\0');
1285 os << tmp.getData() << PEGASUS_STD(endl);
1286 }
1287
1288 //------------------------------------------------------------------------------
1289 //
|
1290 kumpf 1.57 // appendQualifierFlavorEntity()
1291 //
1292 // <!ENTITY % QualifierFlavor "OVERRIDABLE (true|false) 'true'
1293 // TOSUBCLASS (true|false) 'true'
1294 // TOINSTANCE (true|false) 'false'
1295 // TRANSLATABLE (true|false) 'false'">
1296 //
1297 //------------------------------------------------------------------------------
1298
1299 void XmlWriter::appendQualifierFlavorEntity(
1300 Array<Sint8>& out,
1301 Uint32 flavor)
1302 {
1303 if (!(flavor & CIMFlavor::OVERRIDABLE))
1304 out << " OVERRIDABLE=\"false\"";
1305
1306 if (!(flavor & CIMFlavor::TOSUBCLASS))
1307 out << " TOSUBCLASS=\"false\"";
1308
1309 if (flavor & CIMFlavor::TOINSTANCE)
1310 out << " TOINSTANCE=\"true\"";
1311 kumpf 1.57
1312 if (flavor & CIMFlavor::TRANSLATABLE)
1313 out << " TRANSLATABLE=\"true\"";
1314 }
1315
1316 //------------------------------------------------------------------------------
1317 //
|
1318 kumpf 1.58 // appendScopeElement()
1319 //
1320 // <!ELEMENT SCOPE EMPTY>
1321 // <!ATTLIST SCOPE
1322 // CLASS (true|false) 'false'
1323 // ASSOCIATION (true|false) 'false'
1324 // REFERENCE (true|false) 'false'
1325 // PROPERTY (true|false) 'false'
1326 // METHOD (true|false) 'false'
1327 // PARAMETER (true|false) 'false'
1328 // INDICATION (true|false) 'false'>
1329 //
1330 //------------------------------------------------------------------------------
1331
1332 void XmlWriter::appendScopeElement(
1333 Array<Sint8>& out,
1334 Uint32 scope)
1335 {
1336 if (scope)
1337 {
1338 out << "<SCOPE";
1339 kumpf 1.58
1340 if (scope & CIMScope::CLASS)
1341 out << " CLASS=\"true\"";
1342
1343 if (scope & CIMScope::ASSOCIATION)
1344 out << " ASSOCIATION=\"true\"";
1345
1346 if (scope & CIMScope::REFERENCE)
1347 out << " REFERENCE=\"true\"";
1348
1349 if (scope & CIMScope::PROPERTY)
1350 out << " PROPERTY=\"true\"";
1351
1352 if (scope & CIMScope::METHOD)
1353 out << " METHOD=\"true\"";
1354
1355 if (scope & CIMScope::PARAMETER)
1356 out << " PARAMETER=\"true\"";
1357
1358 if (scope & CIMScope::INDICATION)
1359 out << " INDICATION=\"true\"";
1360 kumpf 1.58
1361 out << "/>";
1362 }
1363 }
1364
1365 //------------------------------------------------------------------------------
1366 //
|
1367 kumpf 1.27 // appendMethodCallHeader()
|
1368 mike 1.23 //
|
1369 kumpf 1.31 // Build HTTP method call request header.
|
1370 mike 1.23 //
1371 //------------------------------------------------------------------------------
1372
|
1373 kumpf 1.27 void XmlWriter::appendMethodCallHeader(
1374 Array<Sint8>& out,
|
1375 mike 1.23 const char* host,
1376 const char* cimMethod,
1377 const String& cimObject,
|
1378 mike 1.24 const String& authenticationHeader,
|
1379 kumpf 1.27 Uint32 contentLength)
|
1380 mike 1.23 {
1381 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
1382
1383 out << "M-POST /cimom HTTP/1.1\r\n";
1384 out << "HOST: " << host << "\r\n";
|
1385 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
1386 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
|
1387 mike 1.23 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
1388 out << nn <<"\r\n";
|
1389 kumpf 1.27 out << nn << "-CIMOperation: MethodCall\r\n";
|
1390 mike 1.23 out << nn << "-CIMMethod: " << cimMethod << "\r\n";
|
1391 mike 1.24 out << nn << "-CIMObject: " << cimObject << "\r\n";
1392 if (authenticationHeader.size())
1393 {
1394 out << authenticationHeader << "\r\n";
1395 }
1396 out << "\r\n";
|
1397 mike 1.23 }
1398
1399 //------------------------------------------------------------------------------
1400 //
|
1401 kumpf 1.27 // appendMethodResponseHeader()
|
1402 mike 1.23 //
1403 // Build HTTP response header.
1404 //
1405 //------------------------------------------------------------------------------
1406
|
1407 kumpf 1.27 void XmlWriter::appendMethodResponseHeader(
1408 Array<Sint8>& out,
1409 Uint32 contentLength)
|
1410 mike 1.23 {
1411 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
1412
|
1413 kumpf 1.48 out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
|
1414 sage 1.49 STAT_SERVERTIME
|
1415 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
1416 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
|
1417 mike 1.23 out << "Ext:\r\n";
1418 out << "Cache-Control: no-cache\r\n";
1419 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
1420 out << nn <<"\r\n";
1421 out << nn << "-CIMOperation: MethodResponse\r\n\r\n";
1422 }
1423
1424 //------------------------------------------------------------------------------
1425 //
|
1426 kumpf 1.40 // appendHttpErrorResponseHeader()
1427 //
1428 // Build HTTP error response header.
1429 //
1430 // Returns error response message in the following format:
1431 //
|
1432 kumpf 1.41 // HTTP/1.1 400 Bad Request (using specified status code)
1433 // CIMError: <error type> (if specified by caller)
1434 // PGErrorDetail: <error text> (if specified by caller)
|
1435 kumpf 1.40 //
1436 //------------------------------------------------------------------------------
1437
1438 void XmlWriter::appendHttpErrorResponseHeader(
1439 Array<Sint8>& out,
1440 const String& status,
1441 const String& cimError,
|
1442 kumpf 1.41 const String& errorDetail)
|
1443 kumpf 1.40 {
1444 out << "HTTP/1.1 " << status << "\r\n";
1445 if (cimError != String::EMPTY)
1446 {
1447 out << "CIMError: " << cimError << "\r\n";
1448 }
|
1449 kumpf 1.41 if (errorDetail != String::EMPTY)
|
1450 kumpf 1.40 {
|
1451 kumpf 1.41 // ATTN-RK-P3-20020404: It is critical that this text not contain '\n'
1452 // ATTN-RK-P3-20020404: Need to encode this value properly. (See
1453 // CIM/HTTP Specification section 3.3.2
|
1454 kumpf 1.46 out << PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": " << errorDetail << "\r\n";
|
1455 kumpf 1.40 }
1456 out << "\r\n";
1457 }
1458
1459 //------------------------------------------------------------------------------
1460 //
|
1461 kumpf 1.27 // appendUnauthorizedResponseHeader()
1462 //
1463 // Build HTTP authentication response header for unauthorized requests.
1464 //
1465 // Returns unauthorized message in the following format:
1466 //
1467 // HTTP/1.1 401 Unauthorized
1468 // WWW-Authenticate: Basic "hostname:80"
1469 // <HTML><HEAD>
1470 // <TITLE>401 Unauthorized</TITLE>
1471 // </HEAD><BODY BGCOLOR="#99cc99">
1472 // <H2>TEST401 Unauthorized</H2>
1473 // <HR>
1474 // </BODY></HTML>
1475 //
1476 //------------------------------------------------------------------------------
1477
1478 void XmlWriter::appendUnauthorizedResponseHeader(
1479 Array<Sint8>& out,
1480 const String& content)
1481 {
|
1482 kumpf 1.40 out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";
|
1483 kumpf 1.27 out << content << "\r\n";
1484 out << "\r\n";
1485
1486 //ATTN: We may need to include the following line, so that the browsers
1487 // can display the error message.
1488 // out << "<HTML><HEAD>\r\n";
1489 // out << "<TITLE>" << "401 Unauthorized" << "</TITLE>\r\n";
1490 // out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
1491 // out << "<H2>TEST" << "401 Unauthorized" << "</H2>\r\n";
1492 // out << "<HR>\r\n";
1493 // out << "</BODY></HTML>\r\n";
1494 }
1495
1496 //------------------------------------------------------------------------------
1497 //
|
1498 kumpf 1.29 // _appendMessageElementBegin()
1499 // _appendMessageElementEnd()
|
1500 mike 1.23 //
1501 // <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
1502 // <!ATTLIST MESSAGE
1503 // ID CDATA #REQUIRED
1504 // PROTOCOLVERSION CDATA #REQUIRED>
1505 //
1506 //------------------------------------------------------------------------------
1507
|
1508 kumpf 1.29 void XmlWriter::_appendMessageElementBegin(
|
1509 kumpf 1.27 Array<Sint8>& out,
1510 const String& messageId)
|
1511 mike 1.23 {
1512 out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
1513 out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";
1514 out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
|
1515 kumpf 1.27 }
1516
|
1517 kumpf 1.29 void XmlWriter::_appendMessageElementEnd(
|
1518 kumpf 1.27 Array<Sint8>& out)
1519 {
|
1520 mike 1.23 out << "</MESSAGE>\n";
1521 out << "</CIM>\n";
1522 }
1523
1524 //------------------------------------------------------------------------------
1525 //
|
1526 kumpf 1.29 // _appendSimpleReqElementBegin()
1527 // _appendSimpleReqElementEnd()
|
1528 mike 1.23 //
1529 // <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
1530 //
1531 //------------------------------------------------------------------------------
1532
|
1533 kumpf 1.29 void XmlWriter::_appendSimpleReqElementBegin(
|
1534 kumpf 1.27 Array<Sint8>& out)
1535 {
1536 out << "<SIMPLEREQ>\n";
1537 }
1538
|
1539 kumpf 1.29 void XmlWriter::_appendSimpleReqElementEnd(
|
1540 kumpf 1.27 Array<Sint8>& out)
|
1541 mike 1.23 {
|
1542 kumpf 1.27 out << "</SIMPLEREQ>\n";
|
1543 mike 1.23 }
1544
1545 //------------------------------------------------------------------------------
1546 //
|
1547 kumpf 1.29 // _appendMethodCallElementBegin()
1548 // _appendMethodCallElementEnd()
|
1549 mike 1.23 //
|
1550 kumpf 1.27 // <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
1551 // <!ATTLIST METHODCALL %CIMName;>
|
1552 mike 1.23 //
1553 //------------------------------------------------------------------------------
1554
|
1555 kumpf 1.29 void XmlWriter::_appendMethodCallElementBegin(
|
1556 kumpf 1.27 Array<Sint8>& out,
1557 const char* name)
1558 {
1559 out << "<METHODCALL NAME=\"" << name << "\">\n";
1560 }
1561
|
1562 kumpf 1.29 void XmlWriter::_appendMethodCallElementEnd(
|
1563 kumpf 1.27 Array<Sint8>& out)
|
1564 mike 1.23 {
|
1565 kumpf 1.27 out << "</METHODCALL>\n";
|
1566 mike 1.23 }
1567
1568 //------------------------------------------------------------------------------
1569 //
|
1570 kumpf 1.29 // _appendIMethodCallElementBegin()
1571 // _appendIMethodCallElementEnd()
|
1572 mike 1.23 //
1573 // <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
1574 // <!ATTLIST IMETHODCALL %CIMName;>
1575 //
1576 //------------------------------------------------------------------------------
1577
|
1578 kumpf 1.29 void XmlWriter::_appendIMethodCallElementBegin(
|
1579 kumpf 1.27 Array<Sint8>& out,
1580 const char* name)
|
1581 mike 1.23 {
1582 out << "<IMETHODCALL NAME=\"" << name << "\">\n";
|
1583 kumpf 1.27 }
1584
|
1585 kumpf 1.29 void XmlWriter::_appendIMethodCallElementEnd(
|
1586 kumpf 1.27 Array<Sint8>& out)
1587 {
|
1588 mike 1.23 out << "</IMETHODCALL>\n";
1589 }
1590
1591 //------------------------------------------------------------------------------
1592 //
|
1593 kumpf 1.29 // _appendIParamValueElementBegin()
1594 // _appendIParamValueElementEnd()
|
1595 mike 1.23 //
|
1596 kumpf 1.27 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
1597 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
1598 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
1599 // <!ATTLIST IPARAMVALUE %CIMName;>
|
1600 mike 1.23 //
1601 //------------------------------------------------------------------------------
1602
|
1603 kumpf 1.29 void XmlWriter::_appendIParamValueElementBegin(
|
1604 kumpf 1.27 Array<Sint8>& out,
1605 const char* name)
1606 {
1607 out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
1608 }
1609
|
1610 kumpf 1.29 void XmlWriter::_appendIParamValueElementEnd(
|
1611 kumpf 1.27 Array<Sint8>& out)
|
1612 mike 1.23 {
|
1613 kumpf 1.27 out << "</IPARAMVALUE>\n";
|
1614 mike 1.23 }
1615
1616 //------------------------------------------------------------------------------
1617 //
|
1618 kumpf 1.29 // _appendSimpleRspElementBegin()
1619 // _appendSimpleRspElementEnd()
|
1620 mike 1.23 //
|
1621 kumpf 1.27 // <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
|
1622 mike 1.23 //
1623 //------------------------------------------------------------------------------
1624
|
1625 kumpf 1.29 void XmlWriter::_appendSimpleRspElementBegin(
|
1626 kumpf 1.27 Array<Sint8>& out)
1627 {
1628 out << "<SIMPLERSP>\n";
1629 }
1630
|
1631 kumpf 1.29 void XmlWriter::_appendSimpleRspElementEnd(
|
1632 kumpf 1.27 Array<Sint8>& out)
|
1633 mike 1.23 {
|
1634 kumpf 1.27 out << "</SIMPLERSP>\n";
|
1635 mike 1.23 }
1636
1637 //------------------------------------------------------------------------------
1638 //
|
1639 kumpf 1.29 // _appendMethodResponseElementBegin()
1640 // _appendMethodResponseElementEnd()
|
1641 mike 1.23 //
|
1642 kumpf 1.27 // <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
1643 // <!ATTLIST METHODRESPONSE %CIMName;>
|
1644 mike 1.23 //
1645 //------------------------------------------------------------------------------
1646
|
1647 kumpf 1.29 void XmlWriter::_appendMethodResponseElementBegin(
|
1648 mike 1.23 Array<Sint8>& out,
|
1649 kumpf 1.27 const char* name)
1650 {
1651 out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
1652 }
1653
|
1654 kumpf 1.29 void XmlWriter::_appendMethodResponseElementEnd(
|
1655 kumpf 1.27 Array<Sint8>& out)
|
1656 mike 1.23 {
|
1657 kumpf 1.27 out << "</METHODRESPONSE>\n";
1658 }
1659
1660 //------------------------------------------------------------------------------
1661 //
|
1662 kumpf 1.29 // _appendIMethodResponseElementBegin()
1663 // _appendIMethodResponseElementEnd()
|
1664 kumpf 1.27 //
1665 // <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
1666 // <!ATTLIST IMETHODRESPONSE %CIMName;>
1667 //
1668 //------------------------------------------------------------------------------
1669
|
1670 kumpf 1.29 void XmlWriter::_appendIMethodResponseElementBegin(
|
1671 kumpf 1.27 Array<Sint8>& out,
1672 const char* name)
1673 {
1674 out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
1675 }
1676
|
1677 kumpf 1.29 void XmlWriter::_appendIMethodResponseElementEnd(
|
1678 kumpf 1.27 Array<Sint8>& out)
1679 {
1680 out << "</IMETHODRESPONSE>\n";
|
1681 mike 1.23 }
1682
1683 //------------------------------------------------------------------------------
1684 //
|
1685 kumpf 1.29 // _appendErrorElement()
|
1686 mike 1.23 //
1687 //------------------------------------------------------------------------------
1688
|
1689 kumpf 1.29 void XmlWriter::_appendErrorElement(
|
1690 kumpf 1.27 Array<Sint8>& out,
|
1691 kumpf 1.42 const CIMException& cimException)
|
1692 mike 1.23 {
|
1693 kumpf 1.44 PEG_TRACE_STRING(TRC_XML_WRITER, Tracer::LEVEL2,
|
1694 kumpf 1.51 cimException.getTraceDescription());
|
1695 kumpf 1.44
|
1696 mike 1.23 out << "<ERROR";
|
1697 kumpf 1.42 out << " CODE=\"" << Uint32(cimException.getCode()) << "\"";
|
1698 kumpf 1.51 String description = cimException.getDescription();
1699 if (description != String::EMPTY)
|
1700 kumpf 1.42 {
1701 out << " DESCRIPTION=\"";
|
1702 kumpf 1.51 appendSpecial(out, description);
|
1703 kumpf 1.42 out << "\"";
1704 }
1705 out << "/>";
|
1706 mike 1.23 }
1707
1708 //------------------------------------------------------------------------------
1709 //
|
1710 kumpf 1.27 // appendReturnValueElement()
1711 //
1712 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
1713 // <!ATTLIST RETURNVALUE
1714 // %ParamType;>
|
1715 mike 1.23 //
1716 //------------------------------------------------------------------------------
1717
|
1718 kumpf 1.27 void XmlWriter::appendReturnValueElement(
|
1719 mike 1.23 Array<Sint8>& out,
|
1720 kumpf 1.27 const CIMValue& value)
1721 {
1722 out << "<RETURNVALUE";
1723
1724 CIMType type = value.getType();
1725 if (type != CIMType::NONE)
1726 {
|
1727 kumpf 1.53 out << " PARAMTYPE=\"" << type.toString() << "\"";
|
1728 kumpf 1.27 }
1729
1730 out << ">\n";
|
1731 karl 1.37
|
1732 kumpf 1.54 // Add value.
1733 appendValueElement(out, value);
|
1734 kumpf 1.27 out << "</RETURNVALUE>\n";
1735 }
1736
1737 //------------------------------------------------------------------------------
1738 //
|
1739 kumpf 1.29 // _appendIReturnValueElementBegin()
1740 // _appendIReturnValueElementEnd()
|
1741 kumpf 1.27 //
1742 // <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
1743 // VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
1744 // OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
1745 // CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
1746 //
1747 //------------------------------------------------------------------------------
1748
|
1749 kumpf 1.29 void XmlWriter::_appendIReturnValueElementBegin(
|
1750 kumpf 1.27 Array<Sint8>& out)
1751 {
1752 out << "<IRETURNVALUE>\n";
1753 }
1754
|
1755 kumpf 1.29 void XmlWriter::_appendIReturnValueElementEnd(
|
1756 kumpf 1.27 Array<Sint8>& out)
|
1757 mike 1.23 {
|
1758 kumpf 1.27 out << "</IRETURNVALUE>\n";
|
1759 mike 1.23 }
1760
1761 //------------------------------------------------------------------------------
1762 //
|
1763 kumpf 1.27 // appendBooleanIParameter()
|
1764 mike 1.23 //
1765 //------------------------------------------------------------------------------
1766
|
1767 kumpf 1.27 void XmlWriter::appendBooleanIParameter(
|
1768 mike 1.23 Array<Sint8>& out,
1769 const char* name,
|
1770 kumpf 1.27 Boolean flag)
|
1771 mike 1.23 {
|
1772 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1773 kumpf 1.54 out << "<VALUE>";
1774 append(out, flag);
1775 out << "</VALUE>\n";
|
1776 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1777 mike 1.23 }
1778
1779 //------------------------------------------------------------------------------
1780 //
|
1781 kumpf 1.27 // appendStringIParameter()
|
1782 mike 1.23 //
1783 //------------------------------------------------------------------------------
1784
|
1785 kumpf 1.27 void XmlWriter::appendStringIParameter(
|
1786 mike 1.23 Array<Sint8>& out,
1787 const char* name,
|
1788 kumpf 1.27 const String& str)
|
1789 mike 1.23 {
|
1790 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1791 kumpf 1.27 out << "<VALUE>";
1792 appendSpecial(out, str);
1793 out << "</VALUE>\n";
|
1794 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1795 mike 1.23 }
1796
1797 //------------------------------------------------------------------------------
1798 //
|
1799 kumpf 1.27 // appendQualifierNameIParameter()
|
1800 mike 1.23 //
1801 //------------------------------------------------------------------------------
1802
|
1803 kumpf 1.27 void XmlWriter::appendQualifierNameIParameter(
|
1804 mike 1.23 Array<Sint8>& out,
1805 const char* name,
1806 const String& qualifierName)
1807 {
1808 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
1809 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
1810 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
1811 //
1812 // ATTN: notice that there is really no way to pass a qualifier name
1813 // as an IPARAMVALUE element according to the spec (look above). So we
1814 // just pass it as a class name. An answer must be obtained later.
1815
|
1816 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1817 kumpf 1.27 appendClassNameElement(out, qualifierName);
|
1818 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1819 mike 1.23 }
1820
1821 //------------------------------------------------------------------------------
1822 //
|
1823 kumpf 1.27 // appendClassNameIParameter()
|
1824 mike 1.23 //
1825 //------------------------------------------------------------------------------
1826
|
1827 kumpf 1.27 void XmlWriter::appendClassNameIParameter(
|
1828 mike 1.23 Array<Sint8>& out,
|
1829 kumpf 1.27 const char* name,
1830 const String& className)
|
1831 mike 1.23 {
|
1832 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1833 kumpf 1.27 appendClassNameElement(out, className);
|
1834 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1835 mike 1.23 }
1836
1837 //------------------------------------------------------------------------------
1838 //
|
1839 kumpf 1.27 // appendInstanceNameIParameter()
|
1840 mike 1.23 //
1841 //------------------------------------------------------------------------------
1842
|
1843 kumpf 1.27 void XmlWriter::appendInstanceNameIParameter(
|
1844 mike 1.23 Array<Sint8>& out,
|
1845 kumpf 1.27 const char* name,
|
1846 kumpf 1.59 const CIMObjectPath& instanceName)
|
1847 mike 1.23 {
|
1848 kumpf 1.29 _appendIParamValueElementBegin(out, name);
1849 appendInstanceNameElement(out, instanceName);
1850 _appendIParamValueElementEnd(out);
|
1851 kumpf 1.27 }
1852
1853 void XmlWriter::appendObjectNameIParameter(
1854 Array<Sint8>& out,
1855 const char* name,
|
1856 kumpf 1.59 const CIMObjectPath& objectName)
|
1857 kumpf 1.27 {
1858 if (objectName.isClassName())
1859 {
1860 XmlWriter::appendClassNameIParameter(
1861 out, name, objectName.getClassName());
1862 }
1863 else
1864 {
1865 XmlWriter::appendInstanceNameIParameter(
1866 out, name, objectName);
1867 }
1868 }
1869
1870 //------------------------------------------------------------------------------
1871 //
1872 // appendClassIParameter()
1873 //
1874 //------------------------------------------------------------------------------
1875
1876 void XmlWriter::appendClassIParameter(
1877 Array<Sint8>& out,
1878 kumpf 1.27 const char* name,
1879 const CIMConstClass& cimClass)
1880 {
|
1881 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1882 kumpf 1.55 appendClassElement(out, cimClass);
|
1883 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1884 mike 1.23 }
1885
1886 //------------------------------------------------------------------------------
1887 //
|
1888 kumpf 1.27 // appendInstanceIParameter()
|
1889 mike 1.23 //
1890 //------------------------------------------------------------------------------
1891
|
1892 kumpf 1.27 void XmlWriter::appendInstanceIParameter(
|
1893 mike 1.23 Array<Sint8>& out,
|
1894 kumpf 1.27 const char* name,
|
1895 mike 1.23 const CIMConstInstance& instance)
1896 {
|
1897 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1898 kumpf 1.55 appendInstanceElement(out, instance);
|
1899 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1900 mike 1.23 }
1901
|
1902 mike 1.24 //------------------------------------------------------------------------------
1903 //
|
1904 kumpf 1.27 // appendNamedInstanceIParameter()
|
1905 mike 1.24 //
1906 //------------------------------------------------------------------------------
1907
|
1908 kumpf 1.27 void XmlWriter::appendNamedInstanceIParameter(
|
1909 mike 1.24 Array<Sint8>& out,
|
1910 kumpf 1.27 const char* name,
|
1911 mike 1.24 const CIMNamedInstance& namedInstance)
1912 {
|
1913 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1914 kumpf 1.56 appendValueNamedInstanceElement(out, namedInstance);
|
1915 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1916 mike 1.24 }
1917
|
1918 mike 1.23 //----------------------------------------------------------
1919 //
|
1920 kumpf 1.27 // appendPropertyNameIParameter()
|
1921 mike 1.23 //
1922 // </IPARAMVALUE>
1923 // <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
1924 //
1925 // USE: Create parameter for getProperty operation
1926 //==========================================================
|
1927 kumpf 1.27 void XmlWriter::appendPropertyNameIParameter(
|
1928 mike 1.23 Array<Sint8>& out,
1929 const String& propertyName)
1930 {
|
1931 kumpf 1.29 _appendIParamValueElementBegin(out, "PropertyName");
|
1932 kumpf 1.27 out << "<VALUE>" << propertyName << "</VALUE>\n";
|
1933 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1934 kumpf 1.27 }
|
1935 mike 1.23
1936 //------------------------------------------------------------------------------
1937 //
|
1938 kumpf 1.27 // appendPropertyValueIParameter()
|
1939 mike 1.24 //
1940 //------------------------------------------------------------------------------
1941
|
1942 kumpf 1.27 void XmlWriter::appendPropertyValueIParameter(
|
1943 mike 1.24 Array<Sint8>& out,
|
1944 kumpf 1.27 const char* name,
|
1945 mike 1.24 const CIMValue& value)
1946 {
|
1947 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1948 kumpf 1.54 appendValueElement(out, value);
|
1949 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1950 mike 1.24 }
1951
1952 //------------------------------------------------------------------------------
1953 //
|
1954 kumpf 1.27 // appendPropertyListIParameter()
|
1955 mike 1.24 //
1956 //------------------------------------------------------------------------------
1957
|
1958 kumpf 1.27 void XmlWriter::appendPropertyListIParameter(
|
1959 mike 1.24 Array<Sint8>& out,
1960 const CIMPropertyList& propertyList)
1961 {
|
1962 karl 1.37 // ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list
|
1963 kumpf 1.29 _appendIParamValueElementBegin(out, "PropertyList");
|
1964 mike 1.24
|
1965 kumpf 1.27 out << "<VALUE.ARRAY>\n";
|
1966 mike 1.24 for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)
1967 {
|
1968 kumpf 1.27 out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";
|
1969 mike 1.24 }
|
1970 kumpf 1.27 out << "</VALUE.ARRAY>\n";
1971
|
1972 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1973 mike 1.24 }
1974
1975 //------------------------------------------------------------------------------
1976 //
|
1977 kumpf 1.27 // appendQualifierDeclarationIParameter()
|
1978 mike 1.23 //
1979 //------------------------------------------------------------------------------
1980
|
1981 kumpf 1.27 void XmlWriter::appendQualifierDeclarationIParameter(
|
1982 mike 1.23 Array<Sint8>& out,
|
1983 kumpf 1.27 const char* name,
|
1984 mike 1.23 const CIMConstQualifierDecl& qualifierDecl)
1985 {
|
1986 kumpf 1.29 _appendIParamValueElementBegin(out, name);
|
1987 kumpf 1.56 appendQualifierDeclElement(out, qualifierDecl);
|
1988 kumpf 1.29 _appendIParamValueElementEnd(out);
|
1989 kumpf 1.40 }
1990
1991 //------------------------------------------------------------------------------
1992 //
1993 // XmlWriter::formatHttpErrorRspMessage()
1994 //
1995 //------------------------------------------------------------------------------
1996
1997 Array<Sint8> XmlWriter::formatHttpErrorRspMessage(
1998 const String& status,
1999 const String& cimError,
|
2000 kumpf 1.41 const String& errorDetail)
|
2001 kumpf 1.40 {
2002 Array<Sint8> out;
2003
|
2004 kumpf 1.41 appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
|
2005 kumpf 1.40
|
2006 kumpf 1.41 return out;
|
2007 mike 1.23 }
2008
2009 //------------------------------------------------------------------------------
2010 //
|
2011 kumpf 1.27 // XmlWriter::formatSimpleMethodReqMessage()
|
2012 mike 1.23 //
2013 //------------------------------------------------------------------------------
2014
|
2015 kumpf 1.27 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
2016 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
2017 const char* host,
|
2018 kumpf 1.38 const String& nameSpace,
|
2019 kumpf 1.59 const CIMObjectPath& path,
|
2020 kumpf 1.27 const char* methodName,
|
2021 kumpf 1.30 const Array<CIMParamValue>& parameters,
|
2022 kumpf 1.27 const String& messageId,
|
2023 kumpf 1.30 const String& authenticationHeader)
|
2024 kumpf 1.27 {
2025 Array<Sint8> out;
2026 Array<Sint8> tmp;
|
2027 kumpf 1.59 CIMObjectPath localObjectPath = path;
|
2028 kumpf 1.38 localObjectPath.setNameSpace(nameSpace);
|
2029 kumpf 1.27
|
2030 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2031 _appendSimpleReqElementBegin(out);
2032 _appendMethodCallElementBegin(out, methodName);
|
2033 kumpf 1.38 appendLocalObjectPathElement(out, localObjectPath);
|
2034 kumpf 1.30 for (Uint32 i=0; i < parameters.size(); i++)
|
2035 kumpf 1.29 {
|
2036 kumpf 1.56 appendParamValueElement(out, parameters[i]);
|
2037 kumpf 1.29 }
2038 _appendMethodCallElementEnd(out);
2039 _appendSimpleReqElementEnd(out);
2040 _appendMessageElementEnd(out);
|
2041 kumpf 1.27
2042 appendMethodCallHeader(
2043 tmp,
2044 host,
2045 methodName,
|
2046 kumpf 1.39 localObjectPath.toString(false),
|
2047 kumpf 1.27 authenticationHeader,
2048 out.size());
2049 tmp << out;
2050
2051 return tmp;
2052 }
2053
2054 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
2055 const char* methodName,
2056 const String& messageId,
2057 const Array<Sint8>& body)
|
2058 mike 1.23 {
|
2059 kumpf 1.27 Array<Sint8> out;
2060 Array<Sint8> tmp;
2061
|
2062 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2063 _appendSimpleRspElementBegin(out);
2064 _appendMethodResponseElementBegin(out, methodName);
|
2065 kumpf 1.27 out << body;
|
2066 kumpf 1.29 _appendMethodResponseElementEnd(out);
2067 _appendSimpleRspElementEnd(out);
2068 _appendMessageElementEnd(out);
|
2069 mike 1.23
|
2070 kumpf 1.27 appendMethodResponseHeader(tmp, out.size());
2071 tmp << out;
|
2072 mike 1.23
|
2073 kumpf 1.27 return tmp;
|
2074 mike 1.23 }
2075
2076 //------------------------------------------------------------------------------
2077 //
|
2078 kumpf 1.28 // XmlWriter::formatSimpleMethodErrorRspMessage()
2079 //
2080 //------------------------------------------------------------------------------
2081
2082 Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(
2083 const String& methodName,
2084 const String& messageId,
|
2085 kumpf 1.42 const CIMException& cimException)
|
2086 kumpf 1.28 {
2087 ArrayDestroyer<char> tmp1(methodName.allocateCString());
2088 Array<Sint8> out;
2089 Array<Sint8> tmp;
2090
|
2091 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2092 _appendSimpleRspElementBegin(out);
2093 _appendMethodResponseElementBegin(out, tmp1.getPointer());
|
2094 kumpf 1.42 _appendErrorElement(out, cimException);
|
2095 kumpf 1.29 _appendMethodResponseElementEnd(out);
2096 _appendSimpleRspElementEnd(out);
2097 _appendMessageElementEnd(out);
|
2098 kumpf 1.28
2099 appendMethodResponseHeader(tmp, out.size());
2100 tmp << out;
2101
2102 return tmp;
2103 }
2104
2105 //------------------------------------------------------------------------------
2106 //
|
2107 kumpf 1.27 // XmlWriter::formatSimpleIMethodReqMessage()
|
2108 mike 1.23 //
2109 //------------------------------------------------------------------------------
2110
|
2111 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(
2112 const char* host,
2113 const String& nameSpace,
2114 const char* iMethodName,
2115 const String& messageId,
2116 const String& authenticationHeader,
2117 const Array<Sint8>& body)
|
2118 mike 1.23 {
|
2119 kumpf 1.27 Array<Sint8> out;
2120 Array<Sint8> tmp;
2121
|
2122 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2123 _appendSimpleReqElementBegin(out);
2124 _appendIMethodCallElementBegin(out, iMethodName);
2125 appendLocalNameSpacePathElement(out, nameSpace);
|
2126 kumpf 1.27 out << body;
|
2127 kumpf 1.29 _appendIMethodCallElementEnd(out);
2128 _appendSimpleReqElementEnd(out);
2129 _appendMessageElementEnd(out);
|
2130 kumpf 1.27
2131 appendMethodCallHeader(
2132 tmp,
2133 host,
2134 iMethodName,
2135 nameSpace,
2136 authenticationHeader,
2137 out.size());
2138 tmp << out;
|
2139 mike 1.23
|
2140 kumpf 1.27 return tmp;
|
2141 mike 1.23 }
2142
2143 //------------------------------------------------------------------------------
2144 //
|
2145 kumpf 1.27 // XmlWriter::formatSimpleIMethodRspMessage()
|
2146 mike 1.23 //
2147 //------------------------------------------------------------------------------
2148
|
2149 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(
2150 const char* iMethodName,
2151 const String& messageId,
2152 const Array<Sint8>& body)
|
2153 mike 1.23 {
|
2154 kumpf 1.27 Array<Sint8> out;
2155 Array<Sint8> tmp;
|
2156 mike 1.23
|
2157 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2158 _appendSimpleRspElementBegin(out);
2159 _appendIMethodResponseElementBegin(out, iMethodName);
|
2160 kumpf 1.45 if (body.size() != 0)
2161 {
2162 _appendIReturnValueElementBegin(out);
2163 out << body;
2164 _appendIReturnValueElementEnd(out);
2165 }
|
2166 kumpf 1.29 _appendIMethodResponseElementEnd(out);
2167 _appendSimpleRspElementEnd(out);
2168 _appendMessageElementEnd(out);
|
2169 mike 1.23
|
2170 kumpf 1.27 appendMethodResponseHeader(tmp, out.size());
2171 tmp << out;
|
2172 mike 1.23
|
2173 kumpf 1.27 return tmp;
2174 }
|
2175 mike 1.23
|
2176 kumpf 1.28 //------------------------------------------------------------------------------
2177 //
2178 // XmlWriter::formatSimpleIMethodErrorRspMessage()
2179 //
2180 //------------------------------------------------------------------------------
2181
2182 Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(
2183 const String& iMethodName,
2184 const String& messageId,
|
2185 kumpf 1.42 const CIMException& cimException)
|
2186 kumpf 1.28 {
2187 ArrayDestroyer<char> tmp1(iMethodName.allocateCString());
2188 Array<Sint8> out;
2189 Array<Sint8> tmp;
2190
|
2191 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2192 _appendSimpleRspElementBegin(out);
2193 _appendIMethodResponseElementBegin(out, tmp1.getPointer());
|
2194 kumpf 1.42 _appendErrorElement(out, cimException);
|
2195 kumpf 1.29 _appendIMethodResponseElementEnd(out);
2196 _appendSimpleRspElementEnd(out);
2197 _appendMessageElementEnd(out);
|
2198 kumpf 1.28
2199 appendMethodResponseHeader(tmp, out.size());
2200 tmp << out;
2201
2202 return tmp;
2203 }
2204
|
2205 kumpf 1.27 //******************************************************************************
2206 //
2207 // Export Messages (used for indications)
2208 //
2209 //******************************************************************************
|
2210 mike 1.23
|
2211 kumpf 1.27 //------------------------------------------------------------------------------
2212 //
2213 // appendEMethodRequestHeader()
2214 //
2215 // Build HTTP request header for export operation.
2216 //
2217 //------------------------------------------------------------------------------
|
2218 mike 1.23
|
2219 kumpf 1.27 void XmlWriter::appendEMethodRequestHeader(
2220 Array<Sint8>& out,
|
2221 kumpf 1.50 const char* requestUri,
|
2222 kumpf 1.27 const char* host,
2223 const char* cimMethod,
2224 const String& authenticationHeader,
2225 Uint32 contentLength)
2226 {
2227 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
|
2228 mike 1.23
|
2229 kumpf 1.50 out << "M-POST " << requestUri << " HTTP/1.1\r\n";
|
2230 kumpf 1.27 out << "HOST: " << host << "\r\n";
|
2231 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
2232 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
2233 out << "Man: http://www.hp.com; ns=";
2234 out << nn <<"\r\n";
|
2235 kumpf 1.32 out << nn << "-CIMExport: MethodRequest\r\n";
|
2236 kumpf 1.27 out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
2237 if (authenticationHeader.size())
2238 {
2239 out << authenticationHeader << "\r\n";
2240 }
2241 out << "\r\n";
2242 }
|
2243 mike 1.23
|
2244 kumpf 1.27 //------------------------------------------------------------------------------
2245 //
2246 // appendEMethodResponseHeader()
2247 //
2248 // Build HTTP response header for export operation.
2249 //
2250 //------------------------------------------------------------------------------
|
2251 mike 1.23
|
2252 kumpf 1.27 void XmlWriter::appendEMethodResponseHeader(
2253 Array<Sint8>& out,
2254 Uint32 contentLength)
2255 {
2256 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
|
2257 mike 1.23
|
2258 kumpf 1.48 out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
|
2259 kumpf 1.47 out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
|
2260 kumpf 1.27 out << "Content-Length: " << contentLength << "\r\n";
2261 out << "Ext:\r\n";
2262 out << "Cache-Control: no-cache\r\n";
|
2263 kumpf 1.47 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
|
2264 kumpf 1.27 out << nn <<"\r\n";
2265 out << nn << "-CIMExport: MethodResponse\r\n\r\n";
|
2266 mike 1.23 }
2267
2268 //------------------------------------------------------------------------------
2269 //
|
2270 kumpf 1.29 // _appendSimpleExportReqElementBegin()
2271 // _appendSimpleExportReqElementEnd()
|
2272 kumpf 1.27 //
2273 // <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
|
2274 mike 1.23 //
2275 //------------------------------------------------------------------------------
2276
|
2277 kumpf 1.29 void XmlWriter::_appendSimpleExportReqElementBegin(
|
2278 kumpf 1.27 Array<Sint8>& out)
|
2279 mike 1.23 {
|
2280 kumpf 1.27 out << "<SIMPLEEXPREQ>\n";
2281 }
|
2282 mike 1.23
|
2283 kumpf 1.29 void XmlWriter::_appendSimpleExportReqElementEnd(
|
2284 kumpf 1.27 Array<Sint8>& out)
2285 {
2286 out << "</SIMPLEEXPREQ>\n";
|
2287 mike 1.23 }
2288
2289 //------------------------------------------------------------------------------
2290 //
|
2291 kumpf 1.29 // _appendEMethodCallElementBegin()
2292 // _appendEMethodCallElementEnd()
|
2293 kumpf 1.27 //
2294 // <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>
2295 // <!ATTLIST EXPMETHODCALL %CIMName;>
|
2296 mike 1.23 //
2297 //------------------------------------------------------------------------------
2298
|
2299 kumpf 1.29 void XmlWriter::_appendEMethodCallElementBegin(
|
2300 mike 1.23 Array<Sint8>& out,
|
2301 kumpf 1.27 const char* name)
|
2302 mike 1.23 {
|
2303 kumpf 1.27 out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
|
2304 mike 1.24 }
2305
|
2306 kumpf 1.29 void XmlWriter::_appendEMethodCallElementEnd(
|
2307 kumpf 1.27 Array<Sint8>& out)
|
2308 mike 1.24 {
2309 out << "</EXPMETHODCALL>\n";
2310 }
2311
2312 //------------------------------------------------------------------------------
2313 //
|
2314 kumpf 1.29 // _appendSimpleExportRspElementBegin()
2315 // _appendSimpleExportRspElementEnd()
|
2316 mike 1.24 //
|
2317 kumpf 1.27 // <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
|
2318 mike 1.24 //
2319 //------------------------------------------------------------------------------
2320
|
2321 kumpf 1.29 void XmlWriter::_appendSimpleExportRspElementBegin(
|
2322 kumpf 1.27 Array<Sint8>& out)
2323 {
2324 out << "<SIMPLEEXPRSP>\n";
2325 }
2326
|
2327 kumpf 1.29 void XmlWriter::_appendSimpleExportRspElementEnd(
|
2328 kumpf 1.27 Array<Sint8>& out)
|
2329 mike 1.24 {
|
2330 kumpf 1.27 out << "</SIMPLEEXPRSP>\n";
|
2331 mike 1.24 }
2332
2333 //------------------------------------------------------------------------------
2334 //
|
2335 kumpf 1.29 // _appendEMethodResponseElementBegin()
2336 // _appendEMethodResponseElementEnd()
|
2337 mike 1.24 //
2338 // <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
2339 // <!ATTLIST EXPMETHODRESPONSE %CIMName;>
2340 //
2341 //------------------------------------------------------------------------------
2342
|
2343 kumpf 1.29 void XmlWriter::_appendEMethodResponseElementBegin(
|
2344 kumpf 1.27 Array<Sint8>& out,
2345 const char* name)
|
2346 mike 1.24 {
2347 out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
|
2348 kumpf 1.27 }
2349
|
2350 kumpf 1.29 void XmlWriter::_appendEMethodResponseElementEnd(
|
2351 kumpf 1.27 Array<Sint8>& out)
2352 {
|
2353 mike 1.24 out << "</EXPMETHODRESPONSE>\n";
2354 }
2355
2356 //------------------------------------------------------------------------------
2357 //
|
2358 kumpf 1.27 // XmlWriter::formatSimpleEMethodReqMessage()
|
2359 mike 1.24 //
2360 //------------------------------------------------------------------------------
2361
|
2362 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(
|
2363 kumpf 1.50 const char* requestUri,
|
2364 kumpf 1.27 const char* host,
2365 const char* eMethodName,
2366 const String& messageId,
2367 const String& authenticationHeader,
2368 const Array<Sint8>& body)
|
2369 mike 1.24 {
2370 Array<Sint8> out;
|
2371 kumpf 1.27 Array<Sint8> tmp;
2372
|
2373 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2374 _appendSimpleExportReqElementBegin(out);
2375 _appendEMethodCallElementBegin(out, eMethodName);
|
2376 kumpf 1.27 out << body;
|
2377 kumpf 1.29 _appendEMethodCallElementEnd(out);
2378 _appendSimpleExportReqElementEnd(out);
2379 _appendMessageElementEnd(out);
|
2380 kumpf 1.27
2381 appendEMethodRequestHeader(
2382 tmp,
|
2383 kumpf 1.50 requestUri,
|
2384 kumpf 1.27 host,
2385 eMethodName,
2386 authenticationHeader,
2387 out.size());
2388 tmp << out;
|
2389 mike 1.24
|
2390 kumpf 1.50 return tmp;
|
2391 mike 1.24 }
2392
2393 //------------------------------------------------------------------------------
2394 //
|
2395 kumpf 1.27 // XmlWriter::formatSimpleEMethodRspMessage()
|
2396 mike 1.24 //
2397 //------------------------------------------------------------------------------
2398
|
2399 kumpf 1.27 Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(
2400 const char* eMethodName,
|
2401 mike 1.24 const String& messageId,
2402 const Array<Sint8>& body)
2403 {
|
2404 kumpf 1.27 Array<Sint8> out;
2405 Array<Sint8> tmp;
2406
|
2407 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2408 _appendSimpleExportRspElementBegin(out);
2409 _appendEMethodResponseElementBegin(out, eMethodName);
|
2410 kumpf 1.27 out << body;
|
2411 kumpf 1.29 _appendEMethodResponseElementEnd(out);
2412 _appendSimpleExportRspElementEnd(out);
2413 _appendMessageElementEnd(out);
|
2414 kumpf 1.28
2415 appendEMethodResponseHeader(tmp, out.size());
2416 tmp << out;
2417
2418 return tmp;
2419 }
2420
2421 //------------------------------------------------------------------------------
2422 //
2423 // XmlWriter::formatSimpleEMethodErrorRspMessage()
2424 //
2425 //------------------------------------------------------------------------------
2426
2427 Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(
2428 const String& eMethodName,
2429 const String& messageId,
|
2430 kumpf 1.42 const CIMException& cimException)
|
2431 kumpf 1.28 {
2432 ArrayDestroyer<char> tmp1(eMethodName.allocateCString());
2433 Array<Sint8> out;
2434 Array<Sint8> tmp;
2435
|
2436 kumpf 1.29 _appendMessageElementBegin(out, messageId);
2437 _appendSimpleExportRspElementBegin(out);
2438 _appendEMethodResponseElementBegin(out, tmp1.getPointer());
|
2439 kumpf 1.42 _appendErrorElement(out, cimException);
|
2440 kumpf 1.29 _appendEMethodResponseElementEnd(out);
2441 _appendSimpleExportRspElementEnd(out);
2442 _appendMessageElementEnd(out);
|
2443 kumpf 1.27
2444 appendEMethodResponseHeader(tmp, out.size());
2445 tmp << out;
2446
2447 return tmp;
|
2448 mike 1.24 }
2449
2450 //------------------------------------------------------------------------------
2451 //
|
2452 kumpf 1.27 // _printAttributes()
|
2453 mike 1.24 //
2454 //------------------------------------------------------------------------------
2455
|
2456 kumpf 1.27 static void _printAttributes(
2457 PEGASUS_STD(ostream)& os,
2458 const XmlAttribute* attributes,
2459 Uint32 attributeCount)
|
2460 mike 1.24 {
|
2461 kumpf 1.27 for (Uint32 i = 0; i < attributeCount; i++)
2462 {
2463 os << attributes[i].name << "=";
2464
2465 os << '"';
2466 _appendSpecial(os, attributes[i].value);
2467 os << '"';
|
2468 mike 1.24
|
2469 kumpf 1.27 if (i + 1 != attributeCount)
2470 os << ' ';
2471 }
|
2472 mike 1.24 }
2473
2474 //------------------------------------------------------------------------------
2475 //
|
2476 kumpf 1.27 // _indent()
|
2477 mike 1.24 //
2478 //------------------------------------------------------------------------------
2479
|
2480 kumpf 1.27 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
|
2481 mike 1.24 {
|
2482 kumpf 1.27 Uint32 n = level * indentChars;
2483
2484 for (Uint32 i = 0; i < n; i++)
2485 os << ' ';
|
2486 mike 1.24 }
2487
2488 //------------------------------------------------------------------------------
2489 //
|
2490 kumpf 1.27 // indentedPrint()
|
2491 mike 1.24 //
2492 //------------------------------------------------------------------------------
2493
|
2494 kumpf 1.27 void XmlWriter::indentedPrint(
2495 PEGASUS_STD(ostream)& os,
2496 const char* text,
2497 Uint32 indentChars)
|
2498 mike 1.24 {
|
2499 kumpf 1.27 char* tmp = strcpy(new char[strlen(text) + 1], text);
2500
2501 XmlParser parser(tmp);
2502 XmlEntry entry;
2503 Stack<const char*> stack;
|
2504 kumpf 1.26
|
2505 kumpf 1.27 while (parser.next(entry))
|
2506 kumpf 1.26 {
|
2507 kumpf 1.27 switch (entry.type)
2508 {
2509 case XmlEntry::XML_DECLARATION:
2510 {
2511 _indent(os, stack.size(), indentChars);
2512
2513 os << "<?" << entry.text << " ";
2514 _printAttributes(os, entry.attributes, entry.attributeCount);
2515 os << "?>";
2516 break;
2517 }
2518
2519 case XmlEntry::START_TAG:
2520 {
2521 _indent(os, stack.size(), indentChars);
2522
2523 os << "<" << entry.text;
2524
2525 if (entry.attributeCount)
2526 os << ' ';
2527
2528 kumpf 1.27 _printAttributes(os, entry.attributes, entry.attributeCount);
2529 os << ">";
2530 stack.push(entry.text);
2531 break;
2532 }
2533
2534 case XmlEntry::EMPTY_TAG:
2535 {
2536 _indent(os, stack.size(), indentChars);
2537
2538 os << "<" << entry.text << " ";
2539 _printAttributes(os, entry.attributes, entry.attributeCount);
2540 os << "/>";
2541 break;
2542 }
2543
2544 case XmlEntry::END_TAG:
2545 {
2546 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
2547 stack.pop();
2548
2549 kumpf 1.27 _indent(os, stack.size(), indentChars);
2550
2551 os << "</" << entry.text << ">";
2552 break;
2553 }
2554
2555 case XmlEntry::COMMENT:
2556 {
2557
2558 _indent(os, stack.size(), indentChars);
2559 os << "<!--";
2560 _appendSpecial(os, entry.text);
2561 os << "-->";
2562 break;
2563 }
2564
2565 case XmlEntry::CONTENT:
2566 {
2567 _indent(os, stack.size(), indentChars);
2568 _appendSpecial(os, entry.text);
2569 break;
2570 kumpf 1.27 }
2571
2572 case XmlEntry::CDATA:
2573 {
2574 _indent(os, stack.size(), indentChars);
2575 os << "<![CDATA[...]]>";
2576 break;
2577 }
2578
2579 case XmlEntry::DOCTYPE:
2580 {
2581 _indent(os, stack.size(), indentChars);
2582 os << "<!DOCTYPE...>";
2583 break;
2584 }
2585 }
2586
2587 os << PEGASUS_STD(endl);
|
2588 kumpf 1.26 }
2589
|
2590 kumpf 1.27 delete [] tmp;
|
2591 mike 1.24 }
2592
2593 //------------------------------------------------------------------------------
2594 //
|
2595 kumpf 1.27 // XmlWriter::getNextMessageId()
|
2596 mike 1.24 //
2597 //------------------------------------------------------------------------------
2598
|
2599 kumpf 1.27 String XmlWriter::getNextMessageId()
|
2600 mike 1.24 {
|
2601 kumpf 1.27 // ATTN: make thread-safe:
2602 static Uint32 messageId = 1000;
|
2603 mike 1.24
|
2604 kumpf 1.27 messageId++;
|
2605 mike 1.24
|
2606 kumpf 1.27 if (messageId < 1000)
2607 messageId = 1001;
|
2608 mike 1.23
|
2609 kumpf 1.27 char buffer[16];
2610 sprintf(buffer, "%d", messageId);
2611 return buffer;
|
2612 mike 1.23 }
2613
2614 PEGASUS_NAMESPACE_END
|
Return to
XmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common