1 mike 1.12 //%/////////////////////////////////////////////////////////////////////////////
|
2 mike 1.1 //
3 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a
6 // copy of this software and associated documentation files (the "Software"),
7 // to deal in the Software without restriction, including without limitation
8 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 // and/or sell copies of the Software, and to permit persons to whom the
10 // Software is furnished to do so, subject to the following conditions:
11 //
12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
17 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
18 // DEALINGS IN THE SOFTWARE.
19 //
|
20 mike 1.12 //==============================================================================
|
21 mike 1.1 //
|
22 mike 1.12 // Author: Mike Brasher (mbrasher@bmc.com)
|
23 mike 1.1 //
|
24 mike 1.12 // Modified By:
|
25 karl 1.11 //
|
26 mike 1.12 //%/////////////////////////////////////////////////////////////////////////////
|
27 mike 1.1
28 #include <cstdlib>
29 #include <cstdio>
|
30 mike 1.4 #include "CIMClass.h"
|
31 mike 1.7 #include "CIMInstance.h"
|
32 mike 1.4 #include "CIMQualifierDecl.h"
|
33 mike 1.1 #include "XmlWriter.h"
34 #include "XmlParser.h"
35
36 PEGASUS_NAMESPACE_BEGIN
37
38 inline void AppendChar(Array<Sint8>& out, Char16 c)
39 {
40 out.append(Sint8(c));
41 }
42
43 inline void AppendSpecialChar(Array<Sint8>& out, Char16 c)
44 {
45 // ATTN-B: Only UTF-8 handled for now.
46
47 switch (c)
48 {
49 case '&':
50 out.append("&", 5);
51 break;
52
53 case '<':
54 mike 1.1 out.append("<", 4);
55 break;
56
57 case '>':
58 out.append(">", 4);
59 break;
60
61 case '"':
62 out.append(""", 6);
63 break;
64
65 case '\'':
66 out.append("'", 6);
67 break;
68
69 default:
70 out.append(Sint8(c));
71 }
72 }
73
74 void XmlWriter::append(Array<Sint8>& out, Char16 x)
75 mike 1.1 {
76 AppendChar(out, x);
77 }
78
79 void XmlWriter::append(Array<Sint8>& out, Uint32 x)
80 {
81 char buffer[32];
82 sprintf(buffer, "%d", x);
83 append(out, buffer);
84 }
85
86 void XmlWriter::append(Array<Sint8>& out, const char* str)
87 {
88 while (*str)
89 AppendChar(out, *str++);
90 }
91
92 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)
93 {
94 AppendSpecialChar(out, x);
95 }
96 mike 1.1
97 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)
98 {
99 AppendSpecialChar(out, Char16(x));
100 }
101
102 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)
103 {
104 while (*str)
105 AppendSpecialChar(out, *str++);
106 }
107
108 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)
109 {
110 const Char16* tmp = str.getData();
111
112 while (*tmp)
113 AppendSpecialChar(out, *tmp++);
114 }
115
116 void XmlWriter::append(Array<Sint8>& out, const String& str)
117 mike 1.1 {
118 const Char16* tmp = str.getData();
119
120 while (*tmp)
121 AppendChar(out, *tmp++);
122 }
123
124 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)
125 {
126 for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
127 out.append(' ');
128 }
129
130 void XmlWriter::appendLocalNameSpaceElement(
131 Array<Sint8>& out,
132 const String& nameSpace)
133 {
134 out << "<LOCALNAMESPACEPATH>\n";
135
136 char* tmp = nameSpace.allocateCString();
137
138 mike 1.1 for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/"))
139 {
140 out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
141 }
|
142 mike 1.10
143 delete [] tmp;
|
144 mike 1.1
145 out << "</LOCALNAMESPACEPATH>\n";
146 }
147
148 static inline void AppendSpecialChar(std::ostream& os, char c)
149 {
150 switch (c)
151 {
152 case '&':
153 os << "&";
154 break;
155
156 case '<':
157 os << "<";
158 break;
159
160 case '>':
161 os << ">";
162 break;
163
164 case '"':
165 mike 1.1 os << """;
166 break;
167
168 case '\'':
169 os << "'";
170 break;
171
172 default:
173 os << c;
174 }
175 }
176
177 static inline void AppendSpecial(std::ostream& os, const char* str)
178 {
179 while (*str)
180 AppendSpecialChar(os, *str++);
181 }
182
183 //------------------------------------------------------------------------------
184 //
185 // formatGetHeader()
186 mike 1.1 //
187 //------------------------------------------------------------------------------
188
189 Array<Sint8> XmlWriter::formatGetHeader(
190 const char* documentPath)
191 {
192 Array<Sint8> out;
193 return out << "GET " << documentPath << "HTTP/1.0\r\n\r\n";
194 }
195
196 //------------------------------------------------------------------------------
197 //
198 // formatMPostHeader()
199 //
200 // Build HTTP request header.
201 //
202 //------------------------------------------------------------------------------
203
204 Array<Sint8> XmlWriter::formatMPostHeader(
205 const char* host,
206 const char* cimOperation,
207 mike 1.1 const char* cimMethod,
208 const String& cimObject,
209 const Array<Sint8>& content)
210 {
211 Array<Sint8> out;
212 out.reserve(1024);
213 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
214
215 out << "M-POST /cimom HTTP/1.1\r\n";
216 out << "HOST: " << host << "\r\n";
|
217 mike 1.4 out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
|
218 mike 1.1 out << "Content-Length: " << content.getSize() << "\r\n";
219 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
220 out << nn <<"\r\n";
221 out << nn << "-CIMOperation: " << cimOperation << "\r\n";
222 out << nn << "-CIMMethod: " << cimMethod << "\r\n";
223 out << nn << "-CIMObject: " << cimObject << "\r\n\r\n";
224 out << content;
225 return out;
226 }
227
228 //------------------------------------------------------------------------------
229 //
230 // formatMethodResponseHeader()
231 //
232 // Build HTTP response header.
233 //
234 //------------------------------------------------------------------------------
235
236 Array<Sint8> XmlWriter::formatMethodResponseHeader(
237 const Array<Sint8>& content)
238 {
239 mike 1.1 Array<Sint8> out;
240 out.reserve(1024);
241 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
242
243 out << "HTTP/1.1 200 OK\r\n";
|
244 mike 1.4 out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
|
245 mike 1.1 out << "Content-Length: " << content.getSize() << "\r\n";
246 out << "Ext:\r\n";
247 out << "Cache-Control: no-cache\r\n";
248 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
249 out << nn <<"\r\n";
250 out << nn << "-CIMOperation: MethodResponse\r\n\r\n";
251 out << content;
252 return out;
253 }
254
255 //------------------------------------------------------------------------------
256 //
257 // formatMessageElement()
258 //
259 // <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
260 // <!ATTLIST MESSAGE
261 // ID CDATA #REQUIRED
262 // PROTOCOLVERSION CDATA #REQUIRED>
263 //
264 //------------------------------------------------------------------------------
265
266 mike 1.1 Array<Sint8> XmlWriter::formatMessageElement(
267 Uint32 messageId,
268 const Array<Sint8>& body)
269 {
270 Array<Sint8> out;
271 out.reserve(1024);
272
273 out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
274 out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";
275 out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
276 out << body;
277 out << "</MESSAGE>\n";
278 out << "</CIM>\n";
279 return out;
280 }
281
282 //------------------------------------------------------------------------------
283 //
284 // formatSimpleReqElement()
285 //
286 // <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
287 mike 1.1 //
288 //------------------------------------------------------------------------------
289
290 Array<Sint8> XmlWriter::formatSimpleReqElement(
291 const Array<Sint8>& body)
292 {
293 Array<Sint8> out;
294 return out << "<SIMPLEREQ>\n" << body << "</SIMPLEREQ>\n";
295 }
296
297 //------------------------------------------------------------------------------
298 //
299 // formatSimpleRspElement()
300 //
301 // <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
302 //
303 //------------------------------------------------------------------------------
304
305 Array<Sint8> XmlWriter::formatSimpleRspElement(
306 const Array<Sint8>& body)
307 {
308 mike 1.1 Array<Sint8> out;
309 return out << "<SIMPLERSP>\n" << body << "</SIMPLERSP>\n";
310 }
311
312 //------------------------------------------------------------------------------
313 //
314 // formatIMethodCallElement()
315 //
316 // <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
317 // <!ATTLIST IMETHODCALL %CIMName;>
318 //
319 //------------------------------------------------------------------------------
320
321 Array<Sint8> XmlWriter::formatIMethodCallElement(
322 const char* name,
323 const String& nameSpace,
324 const Array<Sint8>& iParamValues)
325 {
326 Array<Sint8> out;
327 out << "<IMETHODCALL NAME=\"" << name << "\">\n";
328 XmlWriter::appendLocalNameSpaceElement(out, nameSpace);
329 mike 1.1 out << iParamValues;
330 out << "</IMETHODCALL>\n";
331 return out;
332 }
333
334 //------------------------------------------------------------------------------
335 //
336 // formatIMethodResponseElement()
337 //
338 // <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
339 // <!ATTLIST IMETHODRESPONSE %CIMName;>
340 //
341 //------------------------------------------------------------------------------
342
343 Array<Sint8> XmlWriter::formatIMethodResponseElement(
344 const char* name,
345 const Array<Sint8>& body)
346 {
347 Array<Sint8> out;
348 out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
349 out << body;
350 mike 1.1 out << "</IMETHODRESPONSE>\n";
351 return out;
352 }
353
354 //------------------------------------------------------------------------------
355 //
356 // formatIReturnValueElement()
357 //
358 // <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
359 // VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
360 // OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
361 // CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
362 //
363 //------------------------------------------------------------------------------
364
365 Array<Sint8> XmlWriter::formatIReturnValueElement(
366 const Array<Sint8>& body)
367 {
368 Array<Sint8> out;
369 return out << "<IRETURNVALUE>\n" << body << "</IRETURNVALUE>\n";
370 }
371 mike 1.1
372 //------------------------------------------------------------------------------
373 //
374 // formatIParamValueElement()
375 //
376 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
377 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
378 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
379 // <!ATTLIST IPARAMVALUE %CIMName;>
380 //
381 //------------------------------------------------------------------------------
382
383 Array<Sint8>& XmlWriter::formatIParamValueElement(
384 Array<Sint8>& out,
385 const char* name,
386 const Array<Sint8>& body)
387 {
388 out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
389 out << body;
390 out << "</IPARAMVALUE>\n";
391 return out;
392 mike 1.1 }
393
394 //------------------------------------------------------------------------------
395 //
396 // formatErrorElement()
397 //
398 //------------------------------------------------------------------------------
399
400 Array<Sint8> XmlWriter::formatErrorElement(
|
401 mike 1.8 CIMException::Code code,
|
402 mike 1.1 const char* description)
403 {
404 Array<Sint8> out;
405 out << "<ERROR";
406 out << " CODE=\"" << Uint32(code) << "\"";
407 out << " DESCRIPTION=\"";
408 appendSpecial(out, description);
409 out << "\"/>";
410 return out;
411 }
412
413 //------------------------------------------------------------------------------
414 //
415 // appendBooleanParameter()
416 //
417 //------------------------------------------------------------------------------
418
419 Array<Sint8>& XmlWriter::appendBooleanParameter(
420 Array<Sint8>& out,
421 const char* name,
422 Boolean flag)
423 mike 1.1 {
424 Array<Sint8> tmp;
425 tmp << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";
426 return formatIParamValueElement(out, name, tmp);
427 }
428
429 //------------------------------------------------------------------------------
430 //
431 // appendClassNameParameter()
432 //
433 //------------------------------------------------------------------------------
434
435 Array<Sint8>& XmlWriter::appendClassNameParameter(
436 Array<Sint8>& out,
437 const char* name,
438 const String& className)
439 {
440 Array<Sint8> tmp;
441 appendClassNameElement(tmp, className);
442 return formatIParamValueElement(out, name, tmp);
443 }
444 mike 1.1
445 //------------------------------------------------------------------------------
446 //
447 // appendQualifierNameParameter()
448 //
449 //------------------------------------------------------------------------------
450
451 Array<Sint8>& XmlWriter::appendQualifierNameParameter(
452 Array<Sint8>& out,
453 const char* name,
454 const String& qualifierName)
455 {
456 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
457 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
458 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
459 //
460 // ATTN: notice that there is really no way to pass a qualifier name
461 // as an IPARAMVALUE element according to the spec (look above). So we
462 // just pass it as a class name. An answer must be obtained later.
463
464 Array<Sint8> tmp;
465 mike 1.1 appendClassNameElement(tmp, qualifierName);
466 return formatIParamValueElement(out, name, tmp);
467 }
468
469 //------------------------------------------------------------------------------
470 //
471 // appendClassParameter()
472 //
473 //------------------------------------------------------------------------------
474
475 Array<Sint8>& XmlWriter::appendClassParameter(
476 Array<Sint8>& out,
477 const char* parameterName,
|
478 mike 1.9 const CIMConstClass& cimClass)
|
479 mike 1.1 {
480 Array<Sint8> tmp;
|
481 mike 1.6 cimClass.toXml(tmp);
|
482 mike 1.2 return formatIParamValueElement(out, parameterName, tmp);
483 }
484
485 //------------------------------------------------------------------------------
486 //
487 // appendInstanceNameParameter()
488 //
489 //------------------------------------------------------------------------------
490
491 Array<Sint8>& XmlWriter::appendInstanceNameParameter(
492 Array<Sint8>& out,
493 const char* parameterName,
|
494 mike 1.4 const CIMReference& instanceName)
|
495 mike 1.2 {
496 Array<Sint8> tmp;
497 instanceName.instanceNameToXml(tmp);
|
498 mike 1.7 return formatIParamValueElement(out, parameterName, tmp);
499 }
500
501 //------------------------------------------------------------------------------
502 //
503 // appendInstanceParameter()
504 //
505 //------------------------------------------------------------------------------
506
507 Array<Sint8>& XmlWriter::appendInstanceParameter(
508 Array<Sint8>& out,
509 const char* parameterName,
|
510 mike 1.9 const CIMConstInstance& instance)
|
511 mike 1.7 {
512 Array<Sint8> tmp;
513 instance.toXml(tmp);
|
514 mike 1.1 return formatIParamValueElement(out, parameterName, tmp);
515 }
|
516 karl 1.11
517 //----------------------------------------------------------
518 //
519 // appendPropertyNameParameter()
520 //
521 // </IPARAMVALUE>
522 // <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
523 //
524 // USE: Create parameter for getProperty operation
525 //==========================================================
526 Array<Sint8>& XmlWriter::appendPropertyNameParameter(
527 Array<Sint8>& out,
528 const String& propertyName)
529 {
530 Array<Sint8> tmp;
531 tmp << "<VALUE>" << propertyName << "</VALUE>\n";
532 return formatIParamValueElement(out,"PropertyName", tmp);}
|
533 mike 1.1
534 //------------------------------------------------------------------------------
535 //
536 // appendClassParameter()
537 //
538 //------------------------------------------------------------------------------
539
540 Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter(
541 Array<Sint8>& out,
542 const char* parameterName,
|
543 mike 1.5 const CIMConstQualifierDecl& qualifierDecl)
|
544 mike 1.1 {
545 Array<Sint8> tmp;
546 qualifierDecl.toXml(tmp);
547 return formatIParamValueElement(out, parameterName, tmp);
548 }
549
550 //------------------------------------------------------------------------------
551 //
552 // appendClassNameElement()
553 //
554 //------------------------------------------------------------------------------
555
556 Array<Sint8>& XmlWriter::appendClassNameElement(
557 Array<Sint8>& out,
558 const String& className)
559 {
560 return out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
|
561 mike 1.3 }
562
563 //------------------------------------------------------------------------------
564 //
565 // appendInstanceNameElement()
566 //
567 //------------------------------------------------------------------------------
568
569 Array<Sint8>& XmlWriter::appendInstanceNameElement(
570 Array<Sint8>& out,
|
571 mike 1.4 const CIMReference& instanceName)
|
572 mike 1.3 {
573 instanceName.instanceNameToXml(out);
574 return out;
|
575 mike 1.1 }
576
577 //------------------------------------------------------------------------------
578 //
579 // _printAttributes()
580 //
581 //------------------------------------------------------------------------------
582
583 static void _printAttributes(
584 std::ostream& os,
585 const XmlAttribute* attributes,
586 Uint32 attributeCount)
587 {
588 for (Uint32 i = 0; i < attributeCount; i++)
589 {
590 os << attributes[i].name << "=";
591
592 os << '"';
593 AppendSpecial(os, attributes[i].value);
594 os << '"';
595
596 mike 1.1 if (i + 1 != attributeCount)
597 os << ' ';
598 }
599 }
600
601 //------------------------------------------------------------------------------
602 //
603 // _indent()
604 //
605 //------------------------------------------------------------------------------
606
607 static void _indent(std::ostream& os, Uint32 level, Uint32 indentChars)
608 {
609 Uint32 n = level * indentChars;
610
611 for (Uint32 i = 0; i < n; i++)
612 os << ' ';
613 }
614
615 //------------------------------------------------------------------------------
616 //
617 mike 1.1 // indentedPrint()
618 //
619 //------------------------------------------------------------------------------
620
621 void XmlWriter::indentedPrint(
622 std::ostream& os,
623 const char* text,
624 Uint32 indentChars)
625 {
626 char* tmp = strcpy(new char[strlen(text) + 1], text);
627
628 XmlParser parser(tmp);
629 XmlEntry entry;
630 Stack<const char*> stack;
631
632 while (parser.next(entry))
633 {
634 switch (entry.type)
635 {
636 case XmlEntry::XML_DECLARATION:
637 {
638 mike 1.1 _indent(os, stack.getSize(), indentChars);
639
640 os << "<?" << entry.text << " ";
641 _printAttributes(os, entry.attributes, entry.attributeCount);
642 os << "?>";
643 break;
644 }
645
646 case XmlEntry::START_TAG:
647 {
648 _indent(os, stack.getSize(), indentChars);
649
650 os << "<" << entry.text;
651
652 if (entry.attributeCount)
653 os << ' ';
654
655 _printAttributes(os, entry.attributes, entry.attributeCount);
656 os << ">";
657 stack.push(entry.text);
658 break;
659 mike 1.1 }
660
661 case XmlEntry::EMPTY_TAG:
662 {
663 _indent(os, stack.getSize(), indentChars);
664
665 os << "<" << entry.text << " ";
666 _printAttributes(os, entry.attributes, entry.attributeCount);
667 os << "/>";
668 break;
669 }
670
671 case XmlEntry::END_TAG:
672 {
673 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
674 stack.pop();
675
676 _indent(os, stack.getSize(), indentChars);
677
678 os << "</" << entry.text << ">";
679 break;
680 mike 1.1 }
681
682 case XmlEntry::COMMENT:
683 {
684
685 _indent(os, stack.getSize(), indentChars);
686 os << "<!--";
687 AppendSpecial(os, entry.text);
688 os << "-->";
689 break;
690 }
691
692 case XmlEntry::CONTENT:
693 {
694 _indent(os, stack.getSize(), indentChars);
695 AppendSpecial(os, entry.text);
696 break;
697 }
698
699 case XmlEntry::CDATA:
700 {
701 mike 1.1 _indent(os, stack.getSize(), indentChars);
702 os << "<![CDATA[...]]>";
703 break;
704 }
705
706 case XmlEntry::DOCTYPE:
707 {
708 _indent(os, stack.getSize(), indentChars);
709 os << "<!DOCTYPE...>";
710 break;
711 }
712 }
713
714 os << std::endl;
715 }
716
717 delete [] tmp;
718 }
719
720 //------------------------------------------------------------------------------
721 //
722 mike 1.1 // XmlWriter::getNextMessageId()
723 //
724 //------------------------------------------------------------------------------
725
726 Uint32 XmlWriter::getNextMessageId()
727 {
728 // ATTN: make thread-safe:
729 static Uint32 messageId = 1000;
730
731 messageId++;
732
733 if (messageId < 1000)
734 messageId = 1001;
735
736 return messageId;
737 }
738
739 //------------------------------------------------------------------------------
740 //
741 // XmlWriter::formatSimpleReqMessage()
742 //
743 mike 1.1 //------------------------------------------------------------------------------
744
745 Array<Sint8> XmlWriter::formatSimpleReqMessage(
746 const char* host,
747 const String& nameSpace,
748 const char* iMethodName,
749 const Array<Sint8>& body)
750 {
751 return XmlWriter::formatMPostHeader(
752 host,
753 "MethodCall",
754 iMethodName,
755 nameSpace,
756 XmlWriter::formatMessageElement(
757 XmlWriter::getNextMessageId(),
758 XmlWriter::formatSimpleReqElement(
759 XmlWriter::formatIMethodCallElement(
760 iMethodName,
761 nameSpace,
762 body))));
763 }
764 mike 1.1
765 Array<Sint8> XmlWriter::formatSimpleRspMessage(
766 const char* iMethodName,
767 const Array<Sint8>& body)
768 {
769 return XmlWriter::formatMethodResponseHeader(
770 XmlWriter::formatMessageElement(
771 XmlWriter::getNextMessageId(),
772 XmlWriter::formatSimpleRspElement(
773 XmlWriter::formatIMethodResponseElement(
774 iMethodName,
775 XmlWriter::formatIReturnValueElement(body)))));
776 }
777
778 PEGASUS_NAMESPACE_END
|
Return to
XmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common