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

No CVS admin address has been configured