133 mike 1.2 if (reqMessage)
134 {
135 delete reqMessage;
136 }
137 }
138
139 //
140 // Search for "CIMOperation" header:
141 //
142
143 String cimOperation;
144
145 if (!HTTPMessage::lookupHeader(
146 headers, "*CIMOperation", cimOperation, true))
147 {
148 // ATTN: error discarded at this time!
149 return;
150 }
151
152 //
153 // Zero-terminate the message:
154 mike 1.2 //
155
156 httpMessage->message.append('\0');
157
158 // Calculate the beginning of the content from the message size and
159 // the content length. Subtract 1 to take into account the null
160 // character we just added to the end of the message.
161
162 content = (Sint8*) httpMessage->message.getData() +
163 httpMessage->message.size() - contentLength - 1;
164
165 //
166 // If it is a method response, then dispatch it to be handled:
167 //
168
169 if (!String::equalNoCase(cimOperation, "MethodResponse"))
170 {
171 // ATTN: error discarded at this time!
172 return;
173 }
174
175 mike 1.2 _handleMethodResponse(content);
176 }
177
178 void CIMOperationResponseDecoder::_handleMethodResponse(char* content)
179 {
180 Message* response = 0;
181
182 //
183 // Create and initialize XML parser:
184 //
185
186 XmlParser parser((char*)content);
187 XmlEntry entry;
188
189 try
190 {
191 //
192 // Process <?xml ... >
193 //
194
195 XmlReader::expectXmlDeclaration(parser, entry);
196 mike 1.2
197 //
198 // Process <CIM ... >
199 //
200
201 XmlReader::testCimStartTag(parser);
202
203 //
204 // Expect <MESSAGE ... >
205 //
206
207 String messageId;
208 const char* protocolVersion = 0;
209
210 if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
211 throw XmlValidationError(
212 parser.getLine(), "expected MESSAGE element");
213
214 if (strcmp(protocolVersion, "1.0") != 0)
215 {
216 // ATTN: protocol version being ignored at present!
217 mike 1.2
218 return;
219 }
220
221 //
222 // Expect <SIMPLERSP ... >
223 //
224
225 XmlReader::expectStartTag(parser, entry, "SIMPLERSP");
226
227 //
228 // Expect <IMETHODRESPONSE ... >
229 //
230
231 const char* iMethodResponseName = 0;
232
233 if (XmlReader::getIMethodResponseStartTag(parser, iMethodResponseName))
234 {
235 //
236 // Dispatch the method:
237 //
238 mike 1.2
239 if (EqualNoCase(iMethodResponseName, "GetClass"))
240 response = _decodeGetClassResponse(parser, messageId);
241 else if (EqualNoCase(iMethodResponseName, "GetInstance"))
242 response = _decodeGetInstanceResponse(parser, messageId);
243 else if (EqualNoCase(iMethodResponseName, "EnumerateClassNames"))
244 response = _decodeEnumerateClassNamesResponse(parser,messageId);
245 else if (EqualNoCase(iMethodResponseName, "References"))
246 response = _decodeReferencesResponse(parser, messageId);
247 else if (EqualNoCase(iMethodResponseName, "ReferenceNames"))
248 response = _decodeReferenceNamesResponse(parser, messageId);
249 else if (EqualNoCase(iMethodResponseName, "AssociatorNames"))
250 response = _decodeAssociatorNamesResponse(parser, messageId);
251 else if (EqualNoCase(iMethodResponseName, "Associators"))
252 response = _decodeAssociatorsResponse(parser, messageId);
253 else if (EqualNoCase(iMethodResponseName, "CreateInstance"))
254 response = _decodeCreateInstanceResponse(parser, messageId);
255 else if (EqualNoCase(iMethodResponseName,"EnumerateInstanceNames"))
256 response = _decodeEnumerateInstanceNamesResponse(
257 parser, messageId);
258 else if (EqualNoCase(iMethodResponseName,"EnumerateInstances"))
259 mike 1.2 response = _decodeEnumerateInstancesResponse(parser, messageId);
260 else if (EqualNoCase(iMethodResponseName, "GetProperty"))
261 response = _decodeGetPropertyResponse(parser, messageId);
262 else if (EqualNoCase(iMethodResponseName, "SetProperty"))
263 response = _decodeSetPropertyResponse(parser, messageId);
264 else if (EqualNoCase(iMethodResponseName, "DeleteQualifier"))
265 response = _decodeDeleteQualifierResponse(parser, messageId);
266 else if (EqualNoCase(iMethodResponseName, "GetQualifier"))
267 response = _decodeGetQualifierResponse(parser, messageId);
268 else if (EqualNoCase(iMethodResponseName, "SetQualifier"))
269 response = _decodeSetQualifierResponse(parser, messageId);
270 else if (EqualNoCase(iMethodResponseName, "EnumerateQualifiers"))
271 response = _decodeEnumerateQualifiersResponse(parser,messageId);
272 else if (EqualNoCase(iMethodResponseName, "EnumerateClasses"))
273 response = _decodeEnumerateClassesResponse(parser, messageId);
274 else if (EqualNoCase(iMethodResponseName, "CreateClass"))
275 response = _decodeCreateClassResponse(parser, messageId);
276 else if (EqualNoCase(iMethodResponseName, "ModifyClass"))
277 response = _decodeModifyClassResponse(parser, messageId);
278 else if (EqualNoCase(iMethodResponseName, "ModifyInstance"))
279 response = _decodeModifyInstanceResponse(parser, messageId);
280 mike 1.2 else if (EqualNoCase(iMethodResponseName, "DeleteClass"))
281 response = _decodeDeleteClassResponse(parser, messageId);
282 else if (EqualNoCase(iMethodResponseName, "DeleteInstance"))
283 response = _decodeDeleteInstanceResponse(parser, messageId);
284 else
285 {
286 // Unrecognized IMethodResponse name attribute
287 throw XmlValidationError(parser.getLine(),
288 String("Unrecognized IMethodResponse name \"") +
289 iMethodResponseName + "\"");
290 }
291
292 //
293 // Handle end tag:
294 //
295
296 XmlReader::expectEndTag(parser, "IMETHODRESPONSE");
297 }
298 else if (XmlReader::getMethodResponseStartTag(parser,
299 iMethodResponseName))
300 {
301 mike 1.2 response = _decodeInvokeMethodResponse(
302 parser, messageId, iMethodResponseName);
303
304 //
305 // Handle end tag:
306 //
307 XmlReader::expectEndTag(parser, "METHODRESPONSE");
308 }
309 else
310 {
311 throw XmlValidationError(parser.getLine(),
312 "expected METHODRESPONSE or IMETHODRESPONSE element");
313 }
314
315 //
316 // Handle end tags:
317 //
318 XmlReader::expectEndTag(parser, "SIMPLERSP");
319 XmlReader::expectEndTag(parser, "MESSAGE");
320 XmlReader::expectEndTag(parser, "CIM");
321 }
322 mike 1.2 catch (Exception& x)
323 {
324 // ATTN: ignore the exception for now!
325
326 cout << x.getMessage() << endl;
327 return;
328 }
329
330 _outputQueue->enqueue(response);
331 }
332
333 CIMCreateClassResponseMessage* CIMOperationResponseDecoder::_decodeCreateClassResponse(
334 XmlParser& parser,
335 const String& messageId)
336 {
337 XmlEntry entry;
338 CIMStatusCode code;
339 const char* description = 0;
340
341 if (XmlReader::getErrorElement(parser, code, description))
342 {
343 mike 1.2 return(new CIMCreateClassResponseMessage(
344 messageId,
345 code,
346 description,
347 QueueIdStack()));
348
349 }
350 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
351 {
352 XmlReader::testEndTag(parser, "IRETURNVALUE");
353
354 return(new CIMCreateClassResponseMessage(
355 messageId,
356 CIM_ERR_SUCCESS,
357 String(),
358 QueueIdStack()));
359 }
360 else
361 {
362 throw XmlValidationError(parser.getLine(),
363 "expected ERROR or IRETURNVALUE element");
364 mike 1.2 }
365 }
366
367 CIMGetClassResponseMessage* CIMOperationResponseDecoder::_decodeGetClassResponse(
368 XmlParser& parser, const String& messageId)
369 {
370 XmlEntry entry;
371 CIMStatusCode code;
372 const char* description = 0;
373
374 if (XmlReader::getErrorElement(parser, code, description))
375 {
376 return(new CIMGetClassResponseMessage(
377 messageId,
378 code,
379 description,
380 QueueIdStack(),
381 CIMClass()));
382 }
383 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
384 {
385 mike 1.2 CIMClass cimClass;
386
387 if (!XmlReader::getClassElement(parser, cimClass))
388 throw XmlValidationError(parser.getLine(),"expected CLASS element");
389
390 XmlReader::testEndTag(parser, "IRETURNVALUE");
391
392 return(new CIMGetClassResponseMessage(
393 messageId,
394 CIM_ERR_SUCCESS,
395 String(),
396 QueueIdStack(),
397 cimClass));
398 }
399 else
400 {
401 throw XmlValidationError(parser.getLine(),
402 "expected ERROR or IRETURNVALUE element");
403 }
404 }
405
406 mike 1.2 CIMModifyClassResponseMessage* CIMOperationResponseDecoder::_decodeModifyClassResponse(
407 XmlParser& parser, const String& messageId)
408 {
409 XmlEntry entry;
410 CIMStatusCode code;
411 const char* description = 0;
412
413 if (XmlReader::getErrorElement(parser, code, description))
414 {
415 return(new CIMModifyClassResponseMessage(
416 messageId,
417 code,
418 description,
419 QueueIdStack()));
420 }
421 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
422 {
423 XmlReader::testEndTag(parser, "IRETURNVALUE");
424
425 return(new CIMModifyClassResponseMessage(
426 messageId,
427 mike 1.2 CIM_ERR_SUCCESS,
428 String(),
429 QueueIdStack()));
430 }
431 else
432 {
433 throw XmlValidationError(parser.getLine(),
434 "expected ERROR or IRETURNVALUE element");
435 }
436 }
437
438 CIMEnumerateClassNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
439 XmlParser& parser, const String& messageId)
440 {
441 XmlEntry entry;
442 CIMStatusCode code;
443 const char* description = 0;
444
445 if (XmlReader::getErrorElement(parser, code, description))
446 {
447 return(new CIMEnumerateClassNamesResponseMessage(
448 mike 1.2 messageId,
449 code,
450 description,
451 QueueIdStack(),
452 Array<String>()));
453 }
454 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
455 {
456 Array<String> classNames;
457 String className;
458
459 while (XmlReader::getClassNameElement(parser, className, false))
460 classNames.append(className);
461
462 XmlReader::testEndTag(parser, "IRETURNVALUE");
463
464 return(new CIMEnumerateClassNamesResponseMessage(
465 messageId,
466 CIM_ERR_SUCCESS,
467 String(),
468 QueueIdStack(),
469 mike 1.2 classNames));
470 }
471 else
472 {
473 throw XmlValidationError(parser.getLine(),
474 "expected ERROR or IRETURNVALUE element");
475 }
476 }
477
478 CIMEnumerateClassesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
479 XmlParser& parser, const String& messageId)
480 {
481 XmlEntry entry;
482 CIMStatusCode code;
483 const char* description = 0;
484
485 if (XmlReader::getErrorElement(parser, code, description))
486 {
487 return(new CIMEnumerateClassesResponseMessage(
488 messageId,
489 code,
490 mike 1.2 description,
491 QueueIdStack(),
492 Array<CIMClass>()));
493 }
494 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
495 {
496 Array<CIMClass> cimClasses;
497 CIMClass cimClass;
498
499 while (XmlReader::getClassElement(parser, cimClass))
500 cimClasses.append(cimClass);
501
502 XmlReader::testEndTag(parser, "IRETURNVALUE");
503
504 return(new CIMEnumerateClassesResponseMessage(
505 messageId,
506 CIM_ERR_SUCCESS,
507 String(),
508 QueueIdStack(),
509 cimClasses));
510 }
511 mike 1.2 else
512 {
513 throw XmlValidationError(parser.getLine(),
514 "expected ERROR or IRETURNVALUE element");
515 }
516 }
517
518 CIMDeleteClassResponseMessage* CIMOperationResponseDecoder::_decodeDeleteClassResponse(
519 XmlParser& parser, const String& messageId)
520 {
521 XmlEntry entry;
522 CIMStatusCode code;
523 const char* description = 0;
524
525 if (XmlReader::getErrorElement(parser, code, description))
526 {
527 return(new CIMDeleteClassResponseMessage(
528 messageId,
529 code,
530 description,
531 QueueIdStack()));
532 mike 1.2 }
533 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
534 {
535 XmlReader::testEndTag(parser, "IRETURNVALUE");
536
537 return(new CIMDeleteClassResponseMessage(
538 messageId,
539 CIM_ERR_SUCCESS,
540 String(),
541 QueueIdStack()));
542 }
543 else
544 {
545 throw XmlValidationError(parser.getLine(),
546 "expected ERROR or IRETURNVALUE element");
547 }
548 }
549
550 CIMCreateInstanceResponseMessage* CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
551 XmlParser& parser, const String& messageId)
552 {
553 mike 1.2 XmlEntry entry;
554 CIMStatusCode code;
555 const char* description = 0;
556
557 if (XmlReader::getErrorElement(parser, code, description))
558 {
559 return(new CIMCreateInstanceResponseMessage(
560 messageId,
561 code,
562 description,
563 QueueIdStack(),
564 CIMReference()));
565 }
566 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
567 {
568 CIMReference instanceName;
569 XmlReader::getInstanceNameElement(parser, instanceName);
570
571 XmlReader::testEndTag(parser, "IRETURNVALUE");
572
573 return(new CIMCreateInstanceResponseMessage(
574 mike 1.2 messageId,
575 CIM_ERR_SUCCESS,
576 String(),
577 QueueIdStack(),
578 instanceName));
579 }
580 else
581 {
582 throw XmlValidationError(parser.getLine(),
583 "expected ERROR or IRETURNVALUE element");
584 }
585 }
586
587 CIMGetInstanceResponseMessage* CIMOperationResponseDecoder::_decodeGetInstanceResponse(
588 XmlParser& parser, const String& messageId)
589 {
590 XmlEntry entry;
591 CIMStatusCode code;
592 const char* description = 0;
593
594 if (XmlReader::getErrorElement(parser, code, description))
595 mike 1.2 {
596 return(new CIMGetInstanceResponseMessage(
597 messageId,
598 code,
599 description,
600 QueueIdStack(),
601 CIMInstance()));
602 }
603 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
604 {
605 CIMInstance cimInstance;
606
607 if (!XmlReader::getInstanceElement(parser, cimInstance))
608 {
609 throw XmlValidationError(
610 parser.getLine(), "expected INSTANCE element");
611 }
612
613 XmlReader::testEndTag(parser, "IRETURNVALUE");
614
615 return(new CIMGetInstanceResponseMessage(
616 mike 1.2 messageId,
617 CIM_ERR_SUCCESS,
618 String(),
619 QueueIdStack(),
620 cimInstance));
621 }
622 else
623 {
624 throw XmlValidationError(parser.getLine(),
625 "expected ERROR or IRETURNVALUE element");
626 }
627 }
628
629 CIMModifyInstanceResponseMessage* CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
630 XmlParser& parser, const String& messageId)
631 {
632 XmlEntry entry;
633 CIMStatusCode code;
634 const char* description = 0;
635
636 if (XmlReader::getErrorElement(parser, code, description))
637 mike 1.2 {
638 return(new CIMModifyInstanceResponseMessage(
639 messageId,
640 code,
641 description,
642 QueueIdStack()));
643 }
644 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
645 {
646 XmlReader::testEndTag(parser, "IRETURNVALUE");
647
648 return(new CIMModifyInstanceResponseMessage(
649 messageId,
650 CIM_ERR_SUCCESS,
651 String(),
652 QueueIdStack()));
653 }
654 else
655 {
656 throw XmlValidationError(parser.getLine(),
657 "expected ERROR or IRETURNVALUE element");
658 mike 1.2 }
659 }
660
661 CIMEnumerateInstanceNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
662 XmlParser& parser, const String& messageId)
663 {
664 XmlEntry entry;
665 CIMStatusCode code;
666 const char* description = 0;
667
668 if (XmlReader::getErrorElement(parser, code, description))
669 {
670 return(new CIMEnumerateInstanceNamesResponseMessage(
671 messageId,
672 code,
673 description,
674 QueueIdStack(),
675 Array<CIMReference>()));
676 }
677 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
678 {
679 mike 1.2 Array<CIMReference> instanceNames;
680 String className;
681 Array<KeyBinding> keyBindings;
682
683 while (XmlReader::getInstanceNameElement(
684 parser, className, keyBindings))
685 {
686 CIMReference r(
687 String::EMPTY,
688 String::EMPTY,
689 className,
690 keyBindings);
691 instanceNames.append(r);
692 }
693
694 XmlReader::testEndTag(parser, "IRETURNVALUE");
695
696 return(new CIMEnumerateInstanceNamesResponseMessage(
697 messageId,
698 CIM_ERR_SUCCESS,
699 String(),
700 mike 1.2 QueueIdStack(),
701 instanceNames));
702 }
703 else
704 {
705 throw XmlValidationError(parser.getLine(),
706 "expected ERROR or IRETURNVALUE element");
707 }
708 }
709
710 CIMEnumerateInstancesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(
711 XmlParser& parser, const String& messageId)
712 {
713 XmlEntry entry;
714 CIMStatusCode code;
715 const char* description = 0;
716
717 if (XmlReader::getErrorElement(parser, code, description))
718 {
719 return(new CIMEnumerateInstancesResponseMessage(
720 messageId,
721 mike 1.2 code,
722 description,
723 QueueIdStack(),
724 Array<CIMNamedInstance>()));
725 }
726 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
727 {
728 Array<CIMNamedInstance> namedInstances;
729 CIMNamedInstance tmp;
730
731 while (XmlReader::getNamedInstanceElement(parser, tmp))
732 namedInstances.append(tmp);
733
734 XmlReader::testEndTag(parser, "IRETURNVALUE");
735
736 return(new CIMEnumerateInstancesResponseMessage(
737 messageId,
738 CIM_ERR_SUCCESS,
739 String(),
740 QueueIdStack(),
741 namedInstances));
742 mike 1.2 }
743 else
744 {
745 throw XmlValidationError(parser.getLine(),
746 "expected ERROR or IRETURNVALUE element");
747 }
748 }
749
750 CIMDeleteInstanceResponseMessage* CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
751 XmlParser& parser, const String& messageId)
752 {
753 XmlEntry entry;
754 CIMStatusCode code;
755 const char* description = 0;
756
757 if (XmlReader::getErrorElement(parser, code, description))
758 {
759 return(new CIMDeleteInstanceResponseMessage(
760 messageId,
761 code,
762 description,
763 mike 1.2 QueueIdStack()));
764 }
765 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
766 {
767 XmlReader::testEndTag(parser, "IRETURNVALUE");
768
769 return(new CIMDeleteInstanceResponseMessage(
770 messageId,
771 CIM_ERR_SUCCESS,
772 String(),
773 QueueIdStack()));
774 }
775 else
776 {
777 throw XmlValidationError(parser.getLine(),
778 "expected ERROR or IRETURNVALUE element");
779 }
780 }
781
782 CIMGetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeGetPropertyResponse(
783 XmlParser& parser, const String& messageId)
784 mike 1.2 {
785 XmlEntry entry;
786 CIMStatusCode code;
787 const char* description = 0;
788
789 if (XmlReader::getErrorElement(parser, code, description))
790 {
791 return(new CIMGetPropertyResponseMessage(
792 messageId,
793 code,
794 description,
795 QueueIdStack(),
796 CIMValue()));
797 }
798 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
799 {
800 CIMValue cimValue;
801
802 if (!XmlReader::getPropertyValue(parser, cimValue))
803 {
804 // ATTN: Don't know what type of CIMValue to expect
805 mike 1.2 throw XmlValidationError(
806 parser.getLine(),
807 "expected VALUE, VALUE.ARRAY, or VALUE.REFERENCE element");
808 }
809
810 XmlReader::testEndTag(parser, "IRETURNVALUE");
811
812 return(new CIMGetPropertyResponseMessage(
813 messageId,
814 CIM_ERR_SUCCESS,
815 String(),
816 QueueIdStack(),
817 cimValue));
818 }
819 else
820 {
821 throw XmlValidationError(parser.getLine(),
822 "expected ERROR or IRETURNVALUE element");
823 }
824 }
825
826 mike 1.2 CIMSetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeSetPropertyResponse(
827 XmlParser& parser, const String& messageId)
828 {
829 XmlEntry entry;
830 CIMStatusCode code;
831 const char* description = 0;
832
833 if (XmlReader::getErrorElement(parser, code, description))
834 {
835 return(new CIMSetPropertyResponseMessage(
836 messageId,
837 code,
838 description,
839 QueueIdStack()));
840 }
841 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
842 {
843 XmlReader::testEndTag(parser, "IRETURNVALUE");
844
845 return(new CIMSetPropertyResponseMessage(
846 messageId,
847 mike 1.2 CIM_ERR_SUCCESS,
848 String(),
849 QueueIdStack()));
850 }
851 else
852 {
853 throw XmlValidationError(parser.getLine(),
854 "expected ERROR or IRETURNVALUE element");
855 }
856 }
857
858 CIMSetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeSetQualifierResponse(
859 XmlParser& parser, const String& messageId)
860 {
861 XmlEntry entry;
862 CIMStatusCode code;
863 const char* description = 0;
864
865 if (XmlReader::getErrorElement(parser, code, description))
866 {
867 return(new CIMSetQualifierResponseMessage(
868 mike 1.2 messageId,
869 code,
870 description,
871 QueueIdStack()));
872 }
873 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
874 {
875 XmlReader::testEndTag(parser, "IRETURNVALUE");
876
877 return(new CIMSetQualifierResponseMessage(
878 messageId,
879 CIM_ERR_SUCCESS,
880 String(),
881 QueueIdStack()));
882 }
883 else
884 {
885 throw XmlValidationError(parser.getLine(),
886 "expected ERROR or IRETURNVALUE element");
887 }
888 }
889 mike 1.2
890 CIMGetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeGetQualifierResponse(
891 XmlParser& parser, const String& messageId)
892 {
893 XmlEntry entry;
894 CIMStatusCode code;
895 const char* description = 0;
896
897 if (XmlReader::getErrorElement(parser, code, description))
898 {
899 return(new CIMGetQualifierResponseMessage(
900 messageId,
901 code,
902 description,
903 QueueIdStack(),
904 CIMQualifierDecl()));
905 }
906 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
907 {
908 CIMQualifierDecl qualifierDecl;
909 XmlReader::getQualifierDeclElement(parser, qualifierDecl);
910 mike 1.2
911 XmlReader::testEndTag(parser, "IRETURNVALUE");
912
913 return(new CIMGetQualifierResponseMessage(
914 messageId,
915 CIM_ERR_SUCCESS,
916 String(),
917 QueueIdStack(),
918 qualifierDecl));
919 }
920 else
921 {
922 throw XmlValidationError(parser.getLine(),
923 "expected ERROR or IRETURNVALUE element");
924 }
925 }
926
927 CIMEnumerateQualifiersResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
928 XmlParser& parser, const String& messageId)
929 {
930 XmlEntry entry;
931 mike 1.2 CIMStatusCode code;
932 const char* description = 0;
933
934 if (XmlReader::getErrorElement(parser, code, description))
935 {
936 return(new CIMEnumerateQualifiersResponseMessage(
937 messageId,
938 code,
939 description,
940 QueueIdStack(),
941 Array<CIMQualifierDecl>()));
942 }
943 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
944 {
945 Array<CIMQualifierDecl> qualifierDecls;
946 CIMQualifierDecl qualifierDecl;
947
948 while (XmlReader::getQualifierDeclElement(parser, qualifierDecl))
949 qualifierDecls.append(qualifierDecl);
950
951 XmlReader::testEndTag(parser, "IRETURNVALUE");
952 mike 1.2
953 return(new CIMEnumerateQualifiersResponseMessage(
954 messageId,
955 CIM_ERR_SUCCESS,
956 String(),
957 QueueIdStack(),
958 qualifierDecls));
959 }
960 else
961 {
962 throw XmlValidationError(parser.getLine(),
963 "expected ERROR or IRETURNVALUE element");
964 }
965 }
966
967 CIMDeleteQualifierResponseMessage* CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
968 XmlParser& parser, const String& messageId)
969 {
970 XmlEntry entry;
971 CIMStatusCode code;
972 const char* description = 0;
973 mike 1.2
974 if (XmlReader::getErrorElement(parser, code, description))
975 {
976 return(new CIMDeleteQualifierResponseMessage(
977 messageId,
978 code,
979 description,
980 QueueIdStack()));
981 }
982 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
983 {
984 XmlReader::testEndTag(parser, "IRETURNVALUE");
985
986 return(new CIMDeleteQualifierResponseMessage(
987 messageId,
988 CIM_ERR_SUCCESS,
989 String(),
990 QueueIdStack()));
991 }
992 else
993 {
994 mike 1.2 throw XmlValidationError(parser.getLine(),
995 "expected ERROR or IRETURNVALUE element");
996 }
997 }
998
999 //MEB:
1000
1001 CIMReferenceNamesResponseMessage* CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
1002 XmlParser& parser, const String& messageId)
1003 {
1004 XmlEntry entry;
1005 CIMStatusCode code;
1006 const char* description = 0;
1007
1008 if (XmlReader::getErrorElement(parser, code, description))
1009 {
1010 return(new CIMReferenceNamesResponseMessage(
1011 messageId,
1012 code,
1013 description,
1014 QueueIdStack(),
1015 mike 1.2 Array<CIMReference>()));
1016 }
1017 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1018 {
1019 CIMReference objectPath;
1020 Array<CIMReference> objectPaths;
1021
1022 while (XmlReader::getObjectPathElement(parser, objectPath))
1023 objectPaths.append(objectPath);
1024
1025 XmlReader::testEndTag(parser, "IRETURNVALUE");
1026
1027 return(new CIMReferenceNamesResponseMessage(
1028 messageId,
1029 CIM_ERR_SUCCESS,
1030 String(),
1031 QueueIdStack(),
1032 objectPaths));
1033 }
1034 else
1035 {
1036 mike 1.2 throw XmlValidationError(parser.getLine(),
1037 "expected ERROR or IRETURNVALUE element");
1038 }
1039 }
1040
1041 CIMReferencesResponseMessage* CIMOperationResponseDecoder::_decodeReferencesResponse(
1042 XmlParser& parser, const String& messageId)
1043 {
1044 XmlEntry entry;
1045 CIMStatusCode code;
1046 const char* description = 0;
1047
1048 if (XmlReader::getErrorElement(parser, code, description))
1049 {
1050 return(new CIMReferencesResponseMessage(
1051 messageId,
1052 code,
1053 description,
1054 QueueIdStack(),
1055 Array<CIMObjectWithPath>()));
1056 }
1057 mike 1.2 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1058 {
1059 Array<CIMObjectWithPath> objectWithPathArray;
1060 CIMObjectWithPath tmp;
1061
1062 while (XmlReader::getObjectWithPath(parser, tmp))
1063 objectWithPathArray.append(tmp);
1064
1065 XmlReader::testEndTag(parser, "IRETURNVALUE");
1066
1067 return(new CIMReferencesResponseMessage(
1068 messageId,
1069 CIM_ERR_SUCCESS,
1070 String(),
1071 QueueIdStack(),
1072 objectWithPathArray));
1073 }
1074 else
1075 {
1076 throw XmlValidationError(parser.getLine(),
1077 "expected ERROR or IRETURNVALUE element");
1078 mike 1.2 }
1079 }
1080
1081 CIMAssociatorNamesResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
1082 XmlParser& parser, const String& messageId)
1083 {
1084 XmlEntry entry;
1085 CIMStatusCode code;
1086 const char* description = 0;
1087
1088 if (XmlReader::getErrorElement(parser, code, description))
1089 {
1090 return(new CIMAssociatorNamesResponseMessage(
1091 messageId,
1092 code,
1093 description,
1094 QueueIdStack(),
1095 Array<CIMReference>()));
1096 }
1097 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1098 {
1099 mike 1.2 CIMReference objectPath;
1100 Array<CIMReference> objectPaths;
1101
1102 while (XmlReader::getObjectPathElement(parser, objectPath))
1103 objectPaths.append(objectPath);
1104
1105 XmlReader::testEndTag(parser, "IRETURNVALUE");
1106
1107 return(new CIMAssociatorNamesResponseMessage(
1108 messageId,
1109 CIM_ERR_SUCCESS,
1110 String(),
1111 QueueIdStack(),
1112 objectPaths));
1113 }
1114 else
1115 {
1116 throw XmlValidationError(parser.getLine(),
1117 "expected ERROR or IRETURNVALUE element");
1118 }
1119 }
1120 mike 1.2
1121 CIMAssociatorsResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorsResponse(
1122 XmlParser& parser, const String& messageId)
1123 {
1124 XmlEntry entry;
1125 CIMStatusCode code;
1126 const char* description = 0;
1127
1128 if (XmlReader::getErrorElement(parser, code, description))
1129 {
1130 return(new CIMAssociatorsResponseMessage(
1131 messageId,
1132 code,
1133 description,
1134 QueueIdStack(),
1135 Array<CIMObjectWithPath>()));
1136 }
1137 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1138 {
1139 Array<CIMObjectWithPath> objectWithPathArray;
1140 CIMObjectWithPath tmp;
1141 mike 1.2
1142 while (XmlReader::getObjectWithPath(parser, tmp))
1143 objectWithPathArray.append(tmp);
1144
1145 XmlReader::testEndTag(parser, "IRETURNVALUE");
1146
1147 return(new CIMAssociatorsResponseMessage(
1148 messageId,
1149 CIM_ERR_SUCCESS,
1150 String(),
1151 QueueIdStack(),
1152 objectWithPathArray));
1153 }
1154 else
1155 {
1156 throw XmlValidationError(parser.getLine(),
1157 "expected ERROR or IRETURNVALUE element");
1158 }
1159 }
1160
1161 CIMInvokeMethodResponseMessage* CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
1162 mike 1.2 XmlParser& parser, const String& messageId, const String& methodName)
1163 {
1164 XmlEntry entry;
1165 CIMStatusCode code;
1166 const char* description = 0;
1167
1168 CIMValue value;
1169 Array<CIMParamValue> outParameters;
1170 const char* paramName;
1171 String inValue;
1172
1173 if (XmlReader::getErrorElement(parser, code, description))
1174 {
1175 return(new CIMInvokeMethodResponseMessage(
1176 messageId,
1177 code,
1178 description,
1179 QueueIdStack(),
1180 value,
1181 outParameters,
1182 methodName));
1183 mike 1.2 }
|
Return to
CIMOperationResponseDecoder.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Client