pegasus/src/Pegasus/Common/XmlWriter.cpp - annotate

Return to XmlWriter.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

1 mike 1.23 //%///////////////////////////////////////////////////////////////////////////// 2 //
3 kumpf 1.23.2.1 // 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.23 // Modified By:
27 kumpf 1.23.2.1 // Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
28 mike 1.23 // 29 //%///////////////////////////////////////////////////////////////////////////// 30 31 #include <cstdlib> 32 #include <cstdio> 33 #include "CIMClass.h" 34 #include "CIMInstance.h" 35 #include "CIMQualifierDecl.h" 36 #include "XmlWriter.h" 37 #include "XmlParser.h" 38 39 PEGASUS_NAMESPACE_BEGIN 40 41 inline void AppendChar(Array<Sint8>& out, Char16 c) 42 { 43 out.append(Sint8(c)); 44 } 45 46 inline void AppendSpecialChar(Array<Sint8>& out, Char16 c) 47 { 48 // ATTN-B: Only UTF-8 handled for now. 49 mike 1.23 50 switch (c) 51 { 52 case '&': 53 out.append("&", 5); 54 break; 55 56 case '<': 57 out.append("<", 4); 58 break; 59 60 case '>': 61 out.append(">", 4); 62 break; 63 64 case '"': 65 out.append(""", 6); 66 break; 67 68 case '\'': 69 out.append("'", 6); 70 mike 1.23 break; 71 72 default: 73 out.append(Sint8(c)); 74 } 75 } 76 77 void XmlWriter::append(Array<Sint8>& out, Char16 x) 78 { 79 AppendChar(out, x); 80 } 81 82 void XmlWriter::append(Array<Sint8>& out, Uint32 x) 83 { 84 char buffer[32]; 85 sprintf(buffer, "%d", x); 86 append(out, buffer); 87 } 88 89 void XmlWriter::append(Array<Sint8>& out, const char* str) 90 { 91 mike 1.23 while (str) 92 AppendChar(out, str++); 93 } 94 95 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x) 96 { 97 AppendSpecialChar(out, x); 98 } 99 100 void XmlWriter::appendSpecial(Array<Sint8>& out, char x) 101 { 102 AppendSpecialChar(out, Char16(x)); 103 } 104 105 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str) 106 { 107 while (str) 108 AppendSpecialChar(out, str++); 109 } 110 111 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str) 112 mike 1.23 { 113 const Char16* tmp = str.getData(); 114 115 while (tmp) 116 AppendSpecialChar(out, tmp++); 117 } 118 119 void XmlWriter::append(Array<Sint8>& out, const String& str) 120 { 121 const Char16* tmp = str.getData(); 122 123 while (tmp) 124 AppendChar(out, tmp++); 125 } 126 127 void XmlWriter::append(Array<Sint8>& out, const Indentor& x) 128 { 129 for (Uint32 i = 0; i < 4 * x.getLevel(); i++) 130 out.append(' '); 131 } 132 133 mike 1.23 void XmlWriter::appendLocalNameSpaceElement( 134 Array<Sint8>& out, 135 const String& nameSpace) 136 { 137 out << "<LOCALNAMESPACEPATH>\n"; 138 139 char* tmp = nameSpace.allocateCString(); 140 141 for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/")) 142 { 143 out << "<NAMESPACE NAME=\"" << p << "\"/>\n"; 144 } 145 146 delete [] tmp; 147 148 out << "</LOCALNAMESPACEPATH>\n"; 149 } 150 151 static inline void AppendSpecialChar(PEGASUS_STD(ostream)& os, char c) 152 { 153 switch (c) 154 mike 1.23 { 155 case '&': 156 os << "&"; 157 break; 158 159 case '<': 160 os << "<"; 161 break; 162 163 case '>': 164 os << ">"; 165 break; 166 167 case '"': 168 os << """; 169 break; 170 171 case '\'': 172 os << "'"; 173 break; 174 175 mike 1.23 default: 176 os << c; 177 } 178 } 179 180 static inline void AppendSpecial(PEGASUS_STD(ostream)& os, const char* str) 181 { 182 while (str) 183 AppendSpecialChar(os, str++); 184 } 185 186 //------------------------------------------------------------------------------ 187 // 188 // formatGetHeader() 189 // 190 //------------------------------------------------------------------------------ 191 192 Array<Sint8> XmlWriter::formatGetHeader( 193 const char* documentPath) 194 { 195 Array<Sint8> out; 196 mike 1.23 return out << "GET " << documentPath << "HTTP/1.0\r\n\r\n"; 197 } 198 199 //------------------------------------------------------------------------------ 200 // 201 // formatMPostHeader() 202 // 203 // Build HTTP request header. 204 // 205 //------------------------------------------------------------------------------ 206 207 Array<Sint8> XmlWriter::formatMPostHeader( 208 const char* host, 209 const char* cimOperation, 210 const char* cimMethod, 211 const String& cimObject, 212 const Array<Sint8>& content) 213 { 214 Array<Sint8> out; 215 out.reserve(1024); 216 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; 217 mike 1.23 218 out << "M-POST /cimom HTTP/1.1\r\n"; 219 out << "HOST: " << host << "\r\n"; 220 out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n"; 221 out << "Content-Length: " << content.size() << "\r\n"; 222 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns="; 223 out << nn <<"\r\n"; 224 out << nn << "-CIMOperation: " << cimOperation << "\r\n"; 225 out << nn << "-CIMMethod: " << cimMethod << "\r\n"; 226 out << nn << "-CIMObject: " << cimObject << "\r\n\r\n"; 227 out << content; 228 return out; 229 } 230 231 //------------------------------------------------------------------------------ 232 // 233 // formatMethodResponseHeader() 234 // 235 // Build HTTP response header. 236 // 237 //------------------------------------------------------------------------------ 238 mike 1.23 239 Array<Sint8> XmlWriter::formatMethodResponseHeader( 240 const Array<Sint8>& content) 241 { 242 Array<Sint8> out; 243 out.reserve(1024); 244 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; 245 246 out << "HTTP/1.1 200 OK\r\n"; 247 out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n"; 248 out << "Content-Length: " << content.size() << "\r\n"; 249 out << "Ext:\r\n"; 250 out << "Cache-Control: no-cache\r\n"; 251 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns="; 252 out << nn <<"\r\n"; 253 out << nn << "-CIMOperation: MethodResponse\r\n\r\n"; 254 out << content; 255 return out; 256 } 257 258 //------------------------------------------------------------------------------ 259 mike 1.23 // 260 // formatMessageElement() 261 // 262 // <!ELEMENT MESSAGE (SIMPLEREQ\|MULTIREQ\|SIMPLERSP\|MULTIRSP)> 263 // <!ATTLIST MESSAGE 264 // ID CDATA #REQUIRED 265 // PROTOCOLVERSION CDATA #REQUIRED> 266 // 267 //------------------------------------------------------------------------------ 268 269 Array<Sint8> XmlWriter::formatMessageElement( 270 const String& messageId, 271 const Array<Sint8>& body) 272 { 273 Array<Sint8> out; 274 out.reserve(1024); 275 276 out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"; 277 out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n"; 278 out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n"; 279 out << body; 280 mike 1.23 out << "</MESSAGE>\n"; 281 out << "</CIM>\n"; 282 return out; 283 } 284 285 //------------------------------------------------------------------------------ 286 // 287 // formatSimpleReqElement() 288 // 289 // <!ELEMENT SIMPLEREQ (IMETHODCALL\|METHODCALL)> 290 // 291 //------------------------------------------------------------------------------ 292 293 Array<Sint8> XmlWriter::formatSimpleReqElement( 294 const Array<Sint8>& body) 295 { 296 Array<Sint8> out; 297 return out << "<SIMPLEREQ>\n" << body << "</SIMPLEREQ>\n"; 298 } 299 300 //------------------------------------------------------------------------------ 301 mike 1.23 // 302 // formatSimpleRspElement() 303 // 304 // <!ELEMENT SIMPLERSP (METHODRESPONSE\|IMETHODRESPONSE)> 305 // 306 //------------------------------------------------------------------------------ 307 308 Array<Sint8> XmlWriter::formatSimpleRspElement( 309 const Array<Sint8>& body) 310 { 311 Array<Sint8> out; 312 return out << "<SIMPLERSP>\n" << body << "</SIMPLERSP>\n"; 313 } 314 315 //------------------------------------------------------------------------------ 316 // 317 // formatIMethodCallElement() 318 // 319 // <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE)> 320 // <!ATTLIST IMETHODCALL %CIMName;> 321 // 322 mike 1.23 //------------------------------------------------------------------------------ 323 324 Array<Sint8> XmlWriter::formatIMethodCallElement( 325 const char name, 326 const String& nameSpace, 327 const Array<Sint8>& iParamValues) 328 { 329 Array<Sint8> out; 330 out << "<IMETHODCALL NAME=\"" << name << "\">\n"; 331 XmlWriter::appendLocalNameSpaceElement(out, nameSpace); 332 out << iParamValues; 333 out << "</IMETHODCALL>\n"; 334 return out; 335 } 336 337 //------------------------------------------------------------------------------ 338 // 339 // formatIMethodResponseElement() 340 // 341 // <!ELEMENT IMETHODRESPONSE (ERROR\|IRETURNVALUE?)> 342 // <!ATTLIST IMETHODRESPONSE %CIMName;> 343 mike 1.23 // 344 //------------------------------------------------------------------------------ 345 346 Array<Sint8> XmlWriter::formatIMethodResponseElement( 347 const char* name, 348 const Array<Sint8>& body) 349 { 350 Array<Sint8> out; 351 out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n"; 352 out << body; 353 out << "</IMETHODRESPONSE>\n"; 354 return out; 355 } 356 357 //------------------------------------------------------------------------------ 358 // 359 // formatIReturnValueElement() 360 // 361 // <!ELEMENT IRETURNVALUE (CLASSNAME\|INSTANCENAME\|VALUE\| 362 // VALUE.OBJECTWITHPATH\|VALUE.OBJECTWITHLOCALPATH\|VALUE.OBJECT\| 363 // OBJECTPATH\|QUALIFIER.DECLARATION\|VALUE.ARRAY?\|VALUE.REFERENCE?\| 364 mike 1.23 // CLASS\|INSTANCE\|VALUE.NAMEDINSTANCE)> 365 // 366 //------------------------------------------------------------------------------ 367 368 Array<Sint8> XmlWriter::formatIReturnValueElement( 369 const Array<Sint8>& body) 370 { 371 Array<Sint8> out; 372 return out << "<IRETURNVALUE>\n" << body << "</IRETURNVALUE>\n"; 373 } 374 375 //------------------------------------------------------------------------------ 376 // 377 // formatIParamValueElement() 378 // 379 // <!ELEMENT IPARAMVALUE (VALUE\|VALUE.ARRAY\|VALUE.REFERENCE 380 // \|INSTANCENAME\|CLASSNAME\|QUALIFIER.DECLARATION 381 // \|CLASS\|INSTANCE\|VALUE.NAMEDINSTANCE)?> 382 // <!ATTLIST IPARAMVALUE %CIMName;> 383 // 384 //------------------------------------------------------------------------------ 385 mike 1.23 386 Array<Sint8>& XmlWriter::formatIParamValueElement( 387 Array<Sint8>& out, 388 const char name, 389 const Array<Sint8>& body) 390 { 391 out << "<IPARAMVALUE NAME=\"" << name << "\">\n"; 392 out << body; 393 out << "</IPARAMVALUE>\n"; 394 return out; 395 } 396 397 //------------------------------------------------------------------------------ 398 // 399 // formatErrorElement() 400 // 401 //------------------------------------------------------------------------------ 402 403 Array<Sint8> XmlWriter::formatErrorElement( 404 CIMStatusCode code, 405 const char* description) 406 mike 1.23 { 407 Array<Sint8> out; 408 out << "<ERROR"; 409 out << " CODE=\"" << Uint32(code) << "\""; 410 out << " DESCRIPTION=\""; 411 appendSpecial(out, description); 412 out << "\"/>"; 413 return out; 414 } 415 416 //------------------------------------------------------------------------------ 417 // 418 // appendBooleanParameter() 419 // 420 //------------------------------------------------------------------------------ 421 422 Array<Sint8>& XmlWriter::appendBooleanParameter( 423 Array<Sint8>& out, 424 const char* name, 425 Boolean flag) 426 { 427 mike 1.23 Array<Sint8> tmp; 428 tmp << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n"; 429 return formatIParamValueElement(out, name, tmp); 430 } 431 432 //------------------------------------------------------------------------------ 433 // 434 // appendStringParameter() 435 // 436 //------------------------------------------------------------------------------ 437 438 Array<Sint8>& XmlWriter::appendStringParameter( 439 Array<Sint8>& out, 440 const char* name, 441 const String& str) 442 { 443 Array<Sint8> tmp; 444 tmp << "<VALUE>"; 445 appendSpecial(tmp, str); 446 tmp << "</VALUE>\n"; 447 return formatIParamValueElement(out, name, tmp); 448 mike 1.23 } 449 450 //------------------------------------------------------------------------------ 451 // 452 // appendClassNameParameter() 453 // 454 //------------------------------------------------------------------------------ 455 456 Array<Sint8>& XmlWriter::appendClassNameParameter( 457 Array<Sint8>& out, 458 const char* name, 459 const String& className) 460 { 461 Array<Sint8> tmp; 462 appendClassNameElement(tmp, className); 463 return formatIParamValueElement(out, name, tmp); 464 } 465 466 //------------------------------------------------------------------------------ 467 // 468 // appendQualifierNameParameter() 469 mike 1.23 // 470 //------------------------------------------------------------------------------ 471 472 Array<Sint8>& XmlWriter::appendQualifierNameParameter( 473 Array<Sint8>& out, 474 const char* name, 475 const String& qualifierName) 476 { 477 // <!ELEMENT IPARAMVALUE (VALUE\|VALUE.ARRAY\|VALUE.REFERENCE 478 // \|INSTANCENAME\|CLASSNAME\|QUALIFIER.DECLARATION 479 // \|CLASS\|INSTANCE\|VALUE.NAMEDINSTANCE)?> 480 // 481 // ATTN: notice that there is really no way to pass a qualifier name 482 // as an IPARAMVALUE element according to the spec (look above). So we 483 // just pass it as a class name. An answer must be obtained later. 484 485 Array<Sint8> tmp; 486 appendClassNameElement(tmp, qualifierName); 487 return formatIParamValueElement(out, name, tmp); 488 } 489 490 mike 1.23 //------------------------------------------------------------------------------ 491 // 492 // appendClassParameter() 493 // 494 //------------------------------------------------------------------------------ 495 496 Array<Sint8>& XmlWriter::appendClassParameter( 497 Array<Sint8>& out, 498 const char* parameterName, 499 const CIMConstClass& cimClass) 500 { 501 Array<Sint8> tmp; 502 cimClass.toXml(tmp); 503 return formatIParamValueElement(out, parameterName, tmp); 504 } 505 506 //------------------------------------------------------------------------------ 507 // 508 // appendInstanceNameParameter() 509 // 510 //------------------------------------------------------------------------------ 511 mike 1.23 512 Array<Sint8>& XmlWriter::appendInstanceNameParameter( 513 Array<Sint8>& out, 514 const char* parameterName, 515 const CIMReference& instanceName) 516 { 517 Array<Sint8> tmp; 518 instanceName.instanceNameToXml(tmp); 519 return formatIParamValueElement(out, parameterName, tmp); 520 } 521 522 //------------------------------------------------------------------------------ 523 // 524 // appendInstanceParameter() 525 // 526 //------------------------------------------------------------------------------ 527 528 Array<Sint8>& XmlWriter::appendInstanceParameter( 529 Array<Sint8>& out, 530 const char* parameterName, 531 const CIMConstInstance& instance) 532 mike 1.23 { 533 Array<Sint8> tmp; 534 instance.toXml(tmp); 535 return formatIParamValueElement(out, parameterName, tmp); 536 } 537 538 //---------------------------------------------------------- 539 // 540 // appendPropertyNameParameter() 541 // 542 // </IPARAMVALUE> 543 // <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE> 544 // 545 // USE: Create parameter for getProperty operation 546 //========================================================== 547 Array<Sint8>& XmlWriter::appendPropertyNameParameter( 548 Array<Sint8>& out, 549 const String& propertyName) 550 { 551 Array<Sint8> tmp; 552 tmp << "<VALUE>" << propertyName << "</VALUE>\n"; 553 mike 1.23 return formatIParamValueElement(out,"PropertyName", tmp);} 554 555 //------------------------------------------------------------------------------ 556 // 557 // appendClassParameter() 558 // 559 //------------------------------------------------------------------------------ 560 561 Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter( 562 Array<Sint8>& out, 563 const char* parameterName, 564 const CIMConstQualifierDecl& qualifierDecl) 565 { 566 Array<Sint8> tmp; 567 qualifierDecl.toXml(tmp); 568 return formatIParamValueElement(out, parameterName, tmp); 569 } 570 571 //------------------------------------------------------------------------------ 572 // 573 // appendClassNameElement() 574 mike 1.23 // 575 //------------------------------------------------------------------------------ 576 577 Array<Sint8>& XmlWriter::appendClassNameElement( 578 Array<Sint8>& out, 579 const String& className) 580 { 581 return out << "<CLASSNAME NAME=\"" << className << "\"/>\n"; 582 } 583 584 //------------------------------------------------------------------------------ 585 // 586 // appendInstanceNameElement() 587 // 588 //------------------------------------------------------------------------------ 589 590 Array<Sint8>& XmlWriter::appendInstanceNameElement( 591 Array<Sint8>& out, 592 const CIMReference& instanceName) 593 { 594 instanceName.instanceNameToXml(out); 595 mike 1.23 return out; 596 } 597 598 //------------------------------------------------------------------------------ 599 // 600 // _printAttributes() 601 // 602 //------------------------------------------------------------------------------ 603 604 static void _printAttributes( 605 PEGASUS_STD(ostream)& os, 606 const XmlAttribute* attributes, 607 Uint32 attributeCount) 608 { 609 for (Uint32 i = 0; i < attributeCount; i++) 610 { 611 os << attributes[i].name << "="; 612 613 os << '"'; 614 AppendSpecial(os, attributes[i].value); 615 os << '"'; 616 mike 1.23 617 if (i + 1 != attributeCount) 618 os << ' '; 619 } 620 } 621 622 //------------------------------------------------------------------------------ 623 // 624 // _indent() 625 // 626 //------------------------------------------------------------------------------ 627 628 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars) 629 { 630 Uint32 n = level * indentChars; 631 632 for (Uint32 i = 0; i < n; i++) 633 os << ' '; 634 } 635 636 //------------------------------------------------------------------------------ 637 mike 1.23 // 638 // indentedPrint() 639 // 640 //------------------------------------------------------------------------------ 641 642 void XmlWriter::indentedPrint( 643 PEGASUS_STD(ostream)& os, 644 const char* text, 645 Uint32 indentChars) 646 { 647 char* tmp = strcpy(new char[strlen(text) + 1], text); 648 649 XmlParser parser(tmp); 650 XmlEntry entry; 651 Stack<const char> stack; 652 653 while (parser.next(entry)) 654 { 655 switch (entry.type) 656 { 657 case XmlEntry::XML_DECLARATION: 658 mike 1.23 { 659 _indent(os, stack.size(), indentChars); 660 661 os << "<?" << entry.text << " "; 662 _printAttributes(os, entry.attributes, entry.attributeCount); 663 os << "?>"; 664 break; 665 } 666 667 case XmlEntry::START_TAG: 668 { 669 _indent(os, stack.size(), indentChars); 670 671 os << "<" << entry.text; 672 673 if (entry.attributeCount) 674 os << ' '; 675 676 _printAttributes(os, entry.attributes, entry.attributeCount); 677 os << ">"; 678 stack.push(entry.text); 679 mike 1.23 break; 680 } 681 682 case XmlEntry::EMPTY_TAG: 683 { 684 _indent(os, stack.size(), indentChars); 685 686 os << "<" << entry.text << " "; 687 _printAttributes(os, entry.attributes, entry.attributeCount); 688 os << "/>"; 689 break; 690 } 691 692 case XmlEntry::END_TAG: 693 { 694 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0) 695 stack.pop(); 696 697 _indent(os, stack.size(), indentChars); 698 699 os << "</" << entry.text << ">"; 700 mike 1.23 break; 701 } 702 703 case XmlEntry::COMMENT: 704 { 705 706 _indent(os, stack.size(), indentChars); 707 os << "<!--"; 708 AppendSpecial(os, entry.text); 709 os << "-->"; 710 break; 711 } 712 713 case XmlEntry::CONTENT: 714 { 715 _indent(os, stack.size(), indentChars); 716 AppendSpecial(os, entry.text); 717 break; 718 } 719 720 case XmlEntry::CDATA: 721 mike 1.23 { 722 _indent(os, stack.size(), indentChars); 723 os << "<![CDATA[...]]>"; 724 break; 725 } 726 727 case XmlEntry::DOCTYPE: 728 { 729 _indent(os, stack.size(), indentChars); 730 os << "<!DOCTYPE...>"; 731 break; 732 } 733 } 734 735 os << PEGASUS_STD(endl); 736 } 737 738 delete [] tmp; 739 } 740 741 //------------------------------------------------------------------------------ 742 mike 1.23 // 743 // XmlWriter::getNextMessageId() 744 // 745 //------------------------------------------------------------------------------ 746 747 String XmlWriter::getNextMessageId() 748 { 749 // ATTN: make thread-safe: 750 static Uint32 messageId = 1000; 751 752 messageId++; 753 754 if (messageId < 1000) 755 messageId = 1001; 756 757 char buffer[16]; 758 sprintf(buffer, "%d", messageId); 759 return buffer; 760 } 761 762 //------------------------------------------------------------------------------ 763 mike 1.23 // 764 // XmlWriter::formatSimpleReqMessage() 765 // 766 //------------------------------------------------------------------------------ 767 768 Array<Sint8> XmlWriter::formatSimpleReqMessage( 769 const char host, 770 const String& nameSpace, 771 const char* iMethodName, 772 const Array<Sint8>& body) 773 { 774 return XmlWriter::formatMPostHeader( 775 host, 776 "MethodCall", 777 iMethodName, 778 nameSpace, 779 XmlWriter::formatMessageElement( 780 XmlWriter::getNextMessageId(), 781 XmlWriter::formatSimpleReqElement( 782 XmlWriter::formatIMethodCallElement( 783 iMethodName, 784 mike 1.23 nameSpace, 785 body)))); 786 } 787 788 Array<Sint8> XmlWriter::formatSimpleRspMessage( 789 const char* iMethodName, 790 const String& messageId, 791 const Array<Sint8>& body) 792 { 793 return XmlWriter::formatMethodResponseHeader( 794 XmlWriter::formatMessageElement( 795 messageId, 796 XmlWriter::formatSimpleRspElement( 797 XmlWriter::formatIMethodResponseElement( 798 iMethodName, 799 XmlWriter::formatIReturnValueElement(body))))); 800 } 801 802 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x) 803 { 804 XmlWriter::append(out, x); 805 mike 1.23 return out; 806 } 807 808 Array<Sint8>& operator<<(Array<Sint8>& out, char x) 809 { 810 XmlWriter::append(out, x); 811 return out; 812 } 813 814 Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x) 815 { 816 XmlWriter::append(out, x); 817 return out; 818 } 819 820 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x) 821 { 822 XmlWriter::append(out, x); 823 return out; 824 } 825 826 mike 1.23 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x) 827 { 828 XmlWriter::append(out, x); 829 return out; 830 } 831 832 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x) 833 { 834 out.appendArray(x); 835 return out; 836 } 837 838 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x) 839 { 840 XmlWriter::append(out, x); 841 return out; 842 } 843 844 Array<Sint8>& XmlWriter::appendObjectNameParameter( 845 Array<Sint8>& out, 846 const char* name, 847 mike 1.23 const CIMReference& objectName) 848 { 849 if (objectName.isClassName()) 850 { 851 XmlWriter::appendClassNameParameter( 852 out, name, objectName.getClassName()); 853 } 854 else 855 { 856 XmlWriter::appendInstanceNameParameter( 857 out, name, objectName); 858 } 859 860 return out;
861 kumpf 1.23.2.1 } 862 863 Array<Sint8> XmlWriter::formatEMethodCallElement( 864 const char* name, 865 const String& nameSpace, 866 const Array<Sint8>& iParamValues) 867 { 868 Array<Sint8> out; 869 out << "<EXPMETHODCALL NAME=\"" << name << "\">\n"; 870 out << iParamValues; 871 out << "</EXPMETHODCALL>\n"; 872 return out; 873 } 874 875 Array<Sint8> XmlWriter::formatSimpleIndicationReqMessage( 876 const char* host, 877 const String& nameSpace, 878 const char* iMethodName, 879 const Array<Sint8>& body) 880 { 881 return XmlWriter::formatMPostIndicationHeader( 882 kumpf 1.23.2.1 host, 883 "MethodRequest", 884 iMethodName, 885 nameSpace, 886 XmlWriter::formatMessageElement( 887 XmlWriter::getNextMessageId(), 888 XmlWriter::formatSimpleExportReqElement( 889 XmlWriter::formatEMethodCallElement( 890 iMethodName, 891 nameSpace, 892 body)))); 893 } 894 895 Array<Sint8> XmlWriter::formatMPostIndicationHeader( 896 const char* host, 897 const char* cimOperation, 898 const char* cimMethod, 899 const String& cimObject, 900 const Array<Sint8>& content) 901 { 902 Array<Sint8> out; 903 kumpf 1.23.2.1 out.reserve(1024); 904 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' }; 905 906 out << "M-POST /cimom HTTP/1.1\r\n"; 907 out << "HOST: " << host << "\r\n"; 908 out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n"; 909 out << "Content-Length: " << content.size() << "\r\n"; 910 out << "Man: http://www.hp.com; ns="; 911 out << nn <<"\r\n"; 912 out << nn << "-CIMExport: " << cimOperation << "\r\n"; 913 out << nn << "-CIMExportMethod: " << cimMethod << "\r\n\r\n"; 914 out << content; 915 return out; 916 } 917 918 Array<Sint8> XmlWriter::formatSimpleExportReqElement( 919 const Array<Sint8>& body) 920 { 921 Array<Sint8> out; 922 return out << "<SIMPLEEXPREQ>\n" << body << "</SIMPLEEXPREQ>\n";
923 mike 1.23 } 924 925 PEGASUS_NAMESPACE_END

No CVS admin address has been configured