1 mike 1.1.2.1 //%/////////////////////////////////////////////////////////////////////////////
2 //
|
3 kumpf 1.1.2.5 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,
4 // The Open Group, Tivoli Systems
|
5 mike 1.1.2.1 //
6 // Permission is hereby granted, free of charge, to any person obtaining a copy
7 // of this software and associated documentation files (the "Software"), to
8 // deal in the Software without restriction, including without limitation the
9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 // sell copies of the Software, and to permit persons to whom the Software is
11 // furnished to do so, subject to the following conditions:
12 //
13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 //
22 //==============================================================================
23 //
24 // Author: Mike Brasher (mbrasher@bmc.com)
25 //
|
26 kumpf 1.1.2.5 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
|
27 mike 1.1.2.1 //
28 //%/////////////////////////////////////////////////////////////////////////////
29
30 #include <iostream>
31 #include <Pegasus/Common/Config.h>
|
32 mike 1.1.2.2 #include <Pegasus/Common/XmlParser.h>
33 #include <Pegasus/Common/XmlReader.h>
|
34 mike 1.1.2.1 #include <Pegasus/Common/System.h>
35 #include <Pegasus/Common/XmlWriter.h>
36 #include <Pegasus/Common/HTTPMessage.h>
37 #include <Pegasus/Common/CIMMessage.h>
38 #include "CIMOperationResponseDecoder.h"
39
40 PEGASUS_USING_STD;
41
42 PEGASUS_NAMESPACE_BEGIN
43
44 CIMOperationResponseDecoder::CIMOperationResponseDecoder(
45 MessageQueue* outputQueue) : _outputQueue(outputQueue)
46 {
47
48 }
49
50 CIMOperationResponseDecoder::~CIMOperationResponseDecoder()
51 {
52
53 }
54
55 mike 1.1.2.1 void CIMOperationResponseDecoder::handleEnqueue()
56 {
57 Message* message = dequeue();
58
59 if (!message)
60 return;
61
62 switch (message->getType())
63 {
64 case HTTP_MESSAGE:
65 {
66 HTTPMessage* httpMessage = (HTTPMessage*)message;
|
67 mike 1.1.2.2 _handleHTTPMessage(httpMessage);
68 break;
|
69 mike 1.1.2.1 }
70
71 default:
72 // ATTN: send this to the orphan queue!
73 break;
74 }
75
76 delete message;
77 }
78
79 const char* CIMOperationResponseDecoder::getQueueName() const
80 {
81 return "CIMOperationResponseDecoder";
82 }
83
|
84 mike 1.1.2.2 void CIMOperationResponseDecoder::_handleHTTPMessage(HTTPMessage* httpMessage)
85 {
86 //
87 // Parse the HTTP message:
88 //
89
90 String startLine;
91 Array<HTTPHeader> headers;
92 Sint8* content;
93 Uint32 contentLength;
94
95 httpMessage->parse(startLine, headers, content, contentLength);
96
97 //
98 // Search for "CIMOperation" header:
99 //
100
101 String cimOperation;
102
103 if (!HTTPMessage::lookupHeader(
104 headers, "*CIMOperation", cimOperation, true))
105 mike 1.1.2.2 {
106 // ATTN: error discarded at this time!
107 return;
108 }
109
110 //
111 // Zero-terminate the message:
112 //
113
114 httpMessage->message.append('\0');
115
116 //
117 // If it is a method response, then dispatch it to be handled:
118 //
119
|
120 mike 1.1.2.4 if (!String::equalNoCase(cimOperation, "MethodResponse"))
|
121 mike 1.1.2.2 {
122 // ATTN: error discarded at this time!
123 return;
124 }
125
126 _handleMethodResponse(content);
127 }
128
129 void CIMOperationResponseDecoder::_handleMethodResponse(char* content)
130 {
131 //
132 // Create and initialize XML parser:
133 //
134
135 XmlParser parser((char*)content);
136 XmlEntry entry;
137
138 try
139 {
140 //
141 // Process <?xml ... >
142 mike 1.1.2.2 //
143
144 XmlReader::expectXmlDeclaration(parser, entry);
145
146 //
147 // Process <CIM ... >
148 //
149
150 XmlReader::testCimStartTag(parser);
151
152 //
153 // Expect <MESSAGE ... >
154 //
155
156 String messageId;
157 const char* protocolVersion = 0;
158
159 if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
160 throw XmlValidationError(
161 parser.getLine(), "expected MESSAGE element");
162
163 mike 1.1.2.2 if (strcmp(protocolVersion, "1.0") != 0)
164 {
165 // ATTN: protocol version being ignored at present!
166
167 return;
168 }
169
170 //
171 // Expect <SIMPLERSP ... >
172 //
173
174 XmlReader::expectStartTag(parser, entry, "SIMPLERSP");
175
176 //
177 // Expect <IMETHODRESPONSE ... >
178 //
179
180 const char* iMethodResponseName = 0;
181
|
182 kumpf 1.1.2.5 if (XmlReader::getIMethodResponseStartTag(parser, iMethodResponseName))
|
183 mike 1.1.2.2 {
|
184 kumpf 1.1.2.5 //
185 // Dispatch the method:
186 //
187
188 if (EqualNoCase(iMethodResponseName, "GetClass"))
189 _decodeGetClassResponse(parser, messageId);
190 else if (EqualNoCase(iMethodResponseName, "GetInstance"))
191 _decodeGetInstanceResponse(parser, messageId);
192 else if (EqualNoCase(iMethodResponseName, "EnumerateClassNames"))
193 _decodeEnumerateClassNamesResponse(parser, messageId);
194 else if (EqualNoCase(iMethodResponseName, "References"))
195 _decodeReferencesResponse(parser, messageId);
196 else if (EqualNoCase(iMethodResponseName, "ReferenceNames"))
197 _decodeReferenceNamesResponse(parser, messageId);
198 else if (EqualNoCase(iMethodResponseName, "AssociatorNames"))
199 _decodeAssociatorNamesResponse(parser, messageId);
200 else if (EqualNoCase(iMethodResponseName, "Associators"))
201 _decodeAssociatorsResponse(parser, messageId);
202 else if (EqualNoCase(iMethodResponseName, "CreateInstance"))
203 _decodeCreateInstanceResponse(parser, messageId);
204 else if (EqualNoCase(iMethodResponseName,"EnumerateInstanceNames"))
205 kumpf 1.1.2.5 _decodeEnumerateInstanceNamesResponse(parser, messageId);
206 else if (EqualNoCase(iMethodResponseName, "DeleteQualifier"))
207 _decodeDeleteQualifierResponse(parser, messageId);
208 else if (EqualNoCase(iMethodResponseName, "GetQualifier"))
209 _decodeGetQualifierResponse(parser, messageId);
210 else if (EqualNoCase(iMethodResponseName, "SetQualifier"))
211 _decodeSetQualifierResponse(parser, messageId);
212 else if (EqualNoCase(iMethodResponseName, "EnumerateQualifiers"))
213 _decodeEnumerateQualifiersResponse(parser, messageId);
214 else if (EqualNoCase(iMethodResponseName, "EnumerateClasses"))
215 _decodeEnumerateClassesResponse(parser, messageId);
216 else if (EqualNoCase(iMethodResponseName, "CreateClass"))
217 _decodeCreateClassResponse(parser, messageId);
218 else if (EqualNoCase(iMethodResponseName, "ModifyClass"))
219 _decodeModifyClassResponse(parser, messageId);
220 else if (EqualNoCase(iMethodResponseName, "ModifyInstance"))
221 _decodeModifyInstanceResponse(parser, messageId);
222 else if (EqualNoCase(iMethodResponseName, "DeleteClass"))
223 _decodeDeleteClassResponse(parser, messageId);
224 else if (EqualNoCase(iMethodResponseName, "DeleteInstance"))
225 _decodeDeleteInstanceResponse(parser, messageId);
226 kumpf 1.1.2.5 //else
227 //{
228 //ATTN: This message is received due to InvokeMethod
229 //from Serevr
230 //return;
231 //}
232
233 //
234 // Handle end tags:
235 //
|
236 mike 1.1.2.2
|
237 kumpf 1.1.2.5 XmlReader::expectEndTag(parser, "IMETHODRESPONSE");
|
238 mike 1.1.2.2 }
|
239 kumpf 1.1.2.5 else if (XmlReader::getMethodResponseStartTag(parser,
240 iMethodResponseName))
241 {
242 _decodeInvokeMethodResponse(parser, messageId, iMethodResponseName);
|
243 mike 1.1.2.2
|
244 kumpf 1.1.2.5 //
245 // Handle end tags:
246 //
247 XmlReader::expectEndTag(parser, "METHODRESPONSE");
248 }
249 else
250 {
251 // ATTN: error ignored for now!
|
252 mike 1.1.2.2
|
253 kumpf 1.1.2.5 return;
254 }
|
255 mike 1.1.2.2
256 XmlReader::expectEndTag(parser, "SIMPLERSP");
257 XmlReader::expectEndTag(parser, "MESSAGE");
258 XmlReader::expectEndTag(parser, "CIM");
259 }
260 catch (Exception& x)
261 {
262 // ATTN: ignore the exception for now!
263
264 cout << x.getMessage() << endl;
265 return;
266 }
267 }
268
|
269 mike 1.1.2.1 void CIMOperationResponseDecoder::_decodeCreateClassResponse(
|
270 mike 1.1.2.2 XmlParser& parser,
271 const String& messageId)
|
272 mike 1.1.2.1 {
|
273 mike 1.1.2.3 XmlEntry entry;
274 CIMStatusCode code;
275 const char* description = 0;
276
277 if (XmlReader::getErrorElement(parser, code, description))
278 {
279 _outputQueue->enqueue(new CIMCreateClassResponseMessage(
280 messageId,
281 code,
282 description,
283 QueueIdStack()));
284
285 }
286 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
287 {
288 XmlReader::testEndTag(parser, "IRETURNVALUE");
289
290 _outputQueue->enqueue(new CIMCreateClassResponseMessage(
291 messageId,
292 CIM_ERR_SUCCESS,
293 String(),
294 mike 1.1.2.3 QueueIdStack()));
295 }
296 else
297 {
298 throw XmlValidationError(parser.getLine(),
299 "expected ERROR or IRETURNVALUE element");
300 }
|
301 mike 1.1.2.1 }
302
303 void CIMOperationResponseDecoder::_decodeGetClassResponse(
|
304 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
305 mike 1.1.2.1 {
|
306 mike 1.1.2.2 XmlEntry entry;
307 CIMStatusCode code;
308 const char* description = 0;
309
310 if (XmlReader::getErrorElement(parser, code, description))
311 {
|
312 mike 1.1.2.3 _outputQueue->enqueue(new CIMGetClassResponseMessage(
|
313 mike 1.1.2.2 messageId,
314 code,
315 description,
316 QueueIdStack(),
|
317 mike 1.1.2.3 CIMClass()));
|
318 mike 1.1.2.2 }
319 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
320 {
321 CIMClass cimClass;
322
323 if (!XmlReader::getClassElement(parser, cimClass))
324 throw XmlValidationError(parser.getLine(),"expected CLASS element");
325
326 XmlReader::testEndTag(parser, "IRETURNVALUE");
327
|
328 mike 1.1.2.3 _outputQueue->enqueue(new CIMGetClassResponseMessage(
|
329 mike 1.1.2.2 messageId,
330 CIM_ERR_SUCCESS,
331 String(),
332 QueueIdStack(),
|
333 mike 1.1.2.3 cimClass));
|
334 mike 1.1.2.2 }
335 else
336 {
337 throw XmlValidationError(parser.getLine(),
338 "expected ERROR or IRETURNVALUE element");
339 }
|
340 mike 1.1.2.1 }
341
342 void CIMOperationResponseDecoder::_decodeModifyClassResponse(
|
343 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
344 mike 1.1.2.1 {
|
345 mike 1.1.2.3 XmlEntry entry;
346 CIMStatusCode code;
347 const char* description = 0;
348
349 if (XmlReader::getErrorElement(parser, code, description))
350 {
351 _outputQueue->enqueue(new CIMModifyClassResponseMessage(
352 messageId,
353 code,
354 description,
355 QueueIdStack()));
356 }
357 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
358 {
359 XmlReader::testEndTag(parser, "IRETURNVALUE");
360
361 _outputQueue->enqueue(new CIMModifyClassResponseMessage(
362 messageId,
363 CIM_ERR_SUCCESS,
364 String(),
365 QueueIdStack()));
366 mike 1.1.2.3 }
367 else
368 {
369 throw XmlValidationError(parser.getLine(),
370 "expected ERROR or IRETURNVALUE element");
371 }
|
372 mike 1.1.2.1 }
373
374 void CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
|
375 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
376 mike 1.1.2.1 {
|
377 mike 1.1.2.3 XmlEntry entry;
378 CIMStatusCode code;
379 const char* description = 0;
380
381 if (XmlReader::getErrorElement(parser, code, description))
382 {
383 _outputQueue->enqueue(new CIMEnumerateClassNamesResponseMessage(
384 messageId,
385 code,
386 description,
387 QueueIdStack(),
388 Array<String>()));
389 }
390 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
391 {
392 Array<String> classNames;
393 String className;
394
395 while (XmlReader::getClassNameElement(parser, className, false))
396 classNames.append(className);
397
398 mike 1.1.2.3 XmlReader::testEndTag(parser, "IRETURNVALUE");
399
400 _outputQueue->enqueue(new CIMEnumerateClassNamesResponseMessage(
401 messageId,
402 CIM_ERR_SUCCESS,
403 String(),
404 QueueIdStack(),
405 classNames));
406 }
407 else
408 {
409 throw XmlValidationError(parser.getLine(),
410 "expected ERROR or IRETURNVALUE element");
411 }
|
412 mike 1.1.2.1 }
413
414 void CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
|
415 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
416 mike 1.1.2.1 {
|
417 mike 1.1.2.3 XmlEntry entry;
418 CIMStatusCode code;
419 const char* description = 0;
420
421 if (XmlReader::getErrorElement(parser, code, description))
422 {
423 _outputQueue->enqueue(new CIMEnumerateClassesResponseMessage(
424 messageId,
425 code,
426 description,
427 QueueIdStack(),
428 Array<CIMClass>()));
429 }
430 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
431 {
432 Array<CIMClass> cimClasses;
433 CIMClass cimClass;
434
435 while (XmlReader::getClassElement(parser, cimClass))
436 cimClasses.append(cimClass);
437
438 mike 1.1.2.3 XmlReader::testEndTag(parser, "IRETURNVALUE");
439
440 _outputQueue->enqueue(new CIMEnumerateClassesResponseMessage(
441 messageId,
442 CIM_ERR_SUCCESS,
443 String(),
444 QueueIdStack(),
445 cimClasses));
446 }
447 else
448 {
449 throw XmlValidationError(parser.getLine(),
450 "expected ERROR or IRETURNVALUE element");
451 }
|
452 mike 1.1.2.1 }
453
454 void CIMOperationResponseDecoder::_decodeDeleteClassResponse(
|
455 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
456 mike 1.1.2.1 {
|
457 mike 1.1.2.3 XmlEntry entry;
458 CIMStatusCode code;
459 const char* description = 0;
460
461 if (XmlReader::getErrorElement(parser, code, description))
462 {
463 _outputQueue->enqueue(new CIMDeleteClassResponseMessage(
464 messageId,
465 code,
466 description,
467 QueueIdStack()));
468 }
469 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
470 {
471 XmlReader::testEndTag(parser, "IRETURNVALUE");
472
473 _outputQueue->enqueue(new CIMDeleteClassResponseMessage(
474 messageId,
475 CIM_ERR_SUCCESS,
476 String(),
477 QueueIdStack()));
478 mike 1.1.2.3 }
479 else
480 {
481 throw XmlValidationError(parser.getLine(),
482 "expected ERROR or IRETURNVALUE element");
483 }
|
484 mike 1.1.2.1 }
485
486 void CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
|
487 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
488 mike 1.1.2.1 {
|
489 mike 1.1.2.3 XmlEntry entry;
490 CIMStatusCode code;
491 const char* description = 0;
492
493 if (XmlReader::getErrorElement(parser, code, description))
494 {
495 _outputQueue->enqueue(new CIMCreateInstanceResponseMessage(
496 messageId,
497 code,
498 description,
499 QueueIdStack()));
500 }
501 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
502 {
503 XmlReader::testEndTag(parser, "IRETURNVALUE");
504
505 _outputQueue->enqueue(new CIMCreateInstanceResponseMessage(
506 messageId,
507 CIM_ERR_SUCCESS,
508 String(),
509 QueueIdStack()));
510 mike 1.1.2.3 }
511 else
512 {
513 throw XmlValidationError(parser.getLine(),
514 "expected ERROR or IRETURNVALUE element");
515 }
|
516 mike 1.1.2.1 }
517
518 void CIMOperationResponseDecoder::_decodeGetInstanceResponse(
|
519 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
520 mike 1.1.2.1 {
|
521 mike 1.1.2.3 XmlEntry entry;
522 CIMStatusCode code;
523 const char* description = 0;
524
525 if (XmlReader::getErrorElement(parser, code, description))
526 {
527 _outputQueue->enqueue(new CIMGetInstanceResponseMessage(
528 messageId,
529 code,
530 description,
531 QueueIdStack(),
532 CIMInstance()));
533 }
534 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
535 {
536 CIMInstance cimInstance;
537
538 if (!XmlReader::getInstanceElement(parser, cimInstance))
539 {
540 throw XmlValidationError(
541 parser.getLine(), "expected INSTANCE element");
542 mike 1.1.2.3 }
543
544 XmlReader::testEndTag(parser, "IRETURNVALUE");
545
546 _outputQueue->enqueue(new CIMGetInstanceResponseMessage(
547 messageId,
548 CIM_ERR_SUCCESS,
549 String(),
550 QueueIdStack(),
551 cimInstance));
552 }
553 else
554 {
555 throw XmlValidationError(parser.getLine(),
556 "expected ERROR or IRETURNVALUE element");
557 }
|
558 mike 1.1.2.1 }
559
560 void CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
|
561 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
562 mike 1.1.2.1 {
|
563 mike 1.1.2.3 XmlEntry entry;
564 CIMStatusCode code;
565 const char* description = 0;
566
567 if (XmlReader::getErrorElement(parser, code, description))
568 {
569 _outputQueue->enqueue(new CIMModifyInstanceResponseMessage(
570 messageId,
571 code,
572 description,
573 QueueIdStack()));
574 }
575 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
576 {
577 XmlReader::testEndTag(parser, "IRETURNVALUE");
578
579 _outputQueue->enqueue(new CIMModifyInstanceResponseMessage(
580 messageId,
581 CIM_ERR_SUCCESS,
582 String(),
583 QueueIdStack()));
584 mike 1.1.2.3 }
585 else
586 {
587 throw XmlValidationError(parser.getLine(),
588 "expected ERROR or IRETURNVALUE element");
589 }
|
590 mike 1.1.2.1 }
591
592 void CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
|
593 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
594 mike 1.1.2.1 {
|
595 mike 1.1.2.3 XmlEntry entry;
596 CIMStatusCode code;
597 const char* description = 0;
598
599 if (XmlReader::getErrorElement(parser, code, description))
600 {
601 _outputQueue->enqueue(new CIMEnumerateInstanceNamesResponseMessage(
602 messageId,
603 code,
604 description,
605 QueueIdStack(),
606 Array<CIMReference>()));
607 }
608 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
609 {
610 Array<CIMReference> instanceNames;
611 String className;
612 Array<KeyBinding> keyBindings;
613
614 while (XmlReader::getInstanceNameElement(
615 parser, className, keyBindings))
616 mike 1.1.2.3 {
617 CIMReference r(
618 String::EMPTY,
619 String::EMPTY,
620 className,
621 keyBindings);
622 instanceNames.append(r);
623 }
624
625 XmlReader::testEndTag(parser, "IRETURNVALUE");
626
627 _outputQueue->enqueue(new CIMEnumerateInstanceNamesResponseMessage(
628 messageId,
629 CIM_ERR_SUCCESS,
630 String(),
631 QueueIdStack(),
632 instanceNames));
633 }
634 else
635 {
636 throw XmlValidationError(parser.getLine(),
637 mike 1.1.2.3 "expected ERROR or IRETURNVALUE element");
638 }
|
639 mike 1.1.2.1 }
640
641 void CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
|
642 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
643 mike 1.1.2.1 {
|
644 mike 1.1.2.3 XmlEntry entry;
645 CIMStatusCode code;
646 const char* description = 0;
647
648 if (XmlReader::getErrorElement(parser, code, description))
649 {
650 _outputQueue->enqueue(new CIMDeleteInstanceResponseMessage(
651 messageId,
652 code,
653 description,
654 QueueIdStack()));
655 }
656 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
657 {
658 XmlReader::testEndTag(parser, "IRETURNVALUE");
659
660 _outputQueue->enqueue(new CIMDeleteInstanceResponseMessage(
661 messageId,
662 CIM_ERR_SUCCESS,
663 String(),
664 QueueIdStack()));
665 mike 1.1.2.3 }
666 else
667 {
668 throw XmlValidationError(parser.getLine(),
669 "expected ERROR or IRETURNVALUE element");
670 }
|
671 mike 1.1.2.1 }
672
673 void CIMOperationResponseDecoder::_decodeSetQualifierResponse(
|
674 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
675 mike 1.1.2.1 {
|
676 mike 1.1.2.3 XmlEntry entry;
677 CIMStatusCode code;
678 const char* description = 0;
679
680 if (XmlReader::getErrorElement(parser, code, description))
681 {
682 _outputQueue->enqueue(new CIMSetQualifierResponseMessage(
683 messageId,
684 code,
685 description,
686 QueueIdStack()));
687 }
688 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
689 {
690 XmlReader::testEndTag(parser, "IRETURNVALUE");
691
692 _outputQueue->enqueue(new CIMSetQualifierResponseMessage(
693 messageId,
694 CIM_ERR_SUCCESS,
695 String(),
696 QueueIdStack()));
697 mike 1.1.2.3 }
698 else
699 {
700 throw XmlValidationError(parser.getLine(),
701 "expected ERROR or IRETURNVALUE element");
702 }
|
703 mike 1.1.2.1 }
704
705 void CIMOperationResponseDecoder::_decodeGetQualifierResponse(
|
706 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
707 mike 1.1.2.1 {
|
708 mike 1.1.2.3 XmlEntry entry;
709 CIMStatusCode code;
710 const char* description = 0;
711
712 if (XmlReader::getErrorElement(parser, code, description))
713 {
714 _outputQueue->enqueue(new CIMGetQualifierResponseMessage(
715 messageId,
716 code,
717 description,
718 QueueIdStack(),
719 CIMQualifierDecl()));
720 }
721 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
722 {
723 CIMQualifierDecl qualifierDecl;
724 XmlReader::getQualifierDeclElement(parser, qualifierDecl);
725
726 XmlReader::testEndTag(parser, "IRETURNVALUE");
727
728 _outputQueue->enqueue(new CIMGetQualifierResponseMessage(
729 mike 1.1.2.3 messageId,
730 CIM_ERR_SUCCESS,
731 String(),
732 QueueIdStack(),
733 qualifierDecl));
734 }
735 else
736 {
737 throw XmlValidationError(parser.getLine(),
738 "expected ERROR or IRETURNVALUE element");
739 }
|
740 mike 1.1.2.1 }
741
742 void CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
|
743 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
744 mike 1.1.2.1 {
|
745 mike 1.1.2.3 XmlEntry entry;
746 CIMStatusCode code;
747 const char* description = 0;
748
749 if (XmlReader::getErrorElement(parser, code, description))
750 {
751 _outputQueue->enqueue(new CIMEnumerateQualifiersResponseMessage(
752 messageId,
753 code,
754 description,
755 QueueIdStack(),
756 Array<CIMQualifierDecl>()));
757 }
758 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
759 {
760 Array<CIMQualifierDecl> qualifierDecls;
761 CIMQualifierDecl qualifierDecl;
762
763 while (XmlReader::getQualifierDeclElement(parser, qualifierDecl))
764 qualifierDecls.append(qualifierDecl);
765
766 mike 1.1.2.3 XmlReader::testEndTag(parser, "IRETURNVALUE");
767
768 _outputQueue->enqueue(new CIMEnumerateQualifiersResponseMessage(
769 messageId,
770 CIM_ERR_SUCCESS,
771 String(),
772 QueueIdStack(),
773 qualifierDecls));
774 }
775 else
776 {
777 throw XmlValidationError(parser.getLine(),
778 "expected ERROR or IRETURNVALUE element");
779 }
|
780 mike 1.1.2.1 }
781
782 void CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
|
783 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
784 mike 1.1.2.1 {
|
785 mike 1.1.2.3 XmlEntry entry;
786 CIMStatusCode code;
787 const char* description = 0;
788
789 if (XmlReader::getErrorElement(parser, code, description))
790 {
791 _outputQueue->enqueue(new CIMDeleteQualifierResponseMessage(
792 messageId,
793 code,
794 description,
795 QueueIdStack()));
796 }
797 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
798 {
799 XmlReader::testEndTag(parser, "IRETURNVALUE");
800
801 _outputQueue->enqueue(new CIMDeleteQualifierResponseMessage(
802 messageId,
803 CIM_ERR_SUCCESS,
804 String(),
805 QueueIdStack()));
806 mike 1.1.2.3 }
807 else
808 {
809 throw XmlValidationError(parser.getLine(),
810 "expected ERROR or IRETURNVALUE element");
811 }
|
812 mike 1.1.2.1 }
813
|
814 mike 1.1.2.3 //MEB:
815
|
816 mike 1.1.2.1 void CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
|
817 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
818 mike 1.1.2.1 {
|
819 mike 1.1.2.3 XmlEntry entry;
820 CIMStatusCode code;
821 const char* description = 0;
822
823 if (XmlReader::getErrorElement(parser, code, description))
824 {
825 _outputQueue->enqueue(new CIMReferenceNamesResponseMessage(
826 messageId,
827 code,
828 description,
829 QueueIdStack(),
830 Array<CIMReference>()));
831 }
832 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
833 {
834 CIMReference objectPath;
835 Array<CIMReference> objectPaths;
836
837 while (XmlReader::getObjectPathElement(parser, objectPath))
838 objectPaths.append(objectPath);
839
840 mike 1.1.2.3 XmlReader::testEndTag(parser, "IRETURNVALUE");
841
842 _outputQueue->enqueue(new CIMReferenceNamesResponseMessage(
843 messageId,
844 CIM_ERR_SUCCESS,
845 String(),
846 QueueIdStack(),
847 objectPaths));
848 }
849 else
850 {
851 throw XmlValidationError(parser.getLine(),
852 "expected ERROR or IRETURNVALUE element");
853 }
|
854 mike 1.1.2.1 }
855
856 void CIMOperationResponseDecoder::_decodeReferencesResponse(
|
857 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
858 mike 1.1.2.1 {
|
859 mike 1.1.2.3 XmlEntry entry;
860 CIMStatusCode code;
861 const char* description = 0;
862
863 if (XmlReader::getErrorElement(parser, code, description))
864 {
865 _outputQueue->enqueue(new CIMReferencesResponseMessage(
866 messageId,
867 code,
868 description,
869 QueueIdStack(),
870 Array<CIMObjectWithPath>()));
871 }
872 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
873 {
874 Array<CIMObjectWithPath> objectWithPathArray;
875 CIMObjectWithPath tmp;
876
877 while (XmlReader::getObjectWithPath(parser, tmp))
878 objectWithPathArray.append(tmp);
879
880 mike 1.1.2.3 XmlReader::testEndTag(parser, "IRETURNVALUE");
881
882 _outputQueue->enqueue(new CIMReferencesResponseMessage(
883 messageId,
884 CIM_ERR_SUCCESS,
885 String(),
886 QueueIdStack(),
887 objectWithPathArray));
888 }
889 else
890 {
891 throw XmlValidationError(parser.getLine(),
892 "expected ERROR or IRETURNVALUE element");
893 }
|
894 mike 1.1.2.1 }
895
896 void CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
|
897 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
898 mike 1.1.2.1 {
|
899 mike 1.1.2.3 XmlEntry entry;
900 CIMStatusCode code;
901 const char* description = 0;
902
903 if (XmlReader::getErrorElement(parser, code, description))
904 {
905 _outputQueue->enqueue(new CIMAssociatorNamesResponseMessage(
906 messageId,
907 code,
908 description,
909 QueueIdStack(),
910 Array<CIMReference>()));
911 }
912 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
913 {
914 CIMReference objectPath;
915 Array<CIMReference> objectPaths;
916
917 while (XmlReader::getObjectPathElement(parser, objectPath))
918 objectPaths.append(objectPath);
919
920 mike 1.1.2.3 XmlReader::testEndTag(parser, "IRETURNVALUE");
921
922 _outputQueue->enqueue(new CIMAssociatorNamesResponseMessage(
923 messageId,
924 CIM_ERR_SUCCESS,
925 String(),
926 QueueIdStack(),
927 objectPaths));
928 }
929 else
930 {
931 throw XmlValidationError(parser.getLine(),
932 "expected ERROR or IRETURNVALUE element");
933 }
|
934 mike 1.1.2.1 }
935
936 void CIMOperationResponseDecoder::_decodeAssociatorsResponse(
|
937 mike 1.1.2.2 XmlParser& parser, const String& messageId)
|
938 mike 1.1.2.1 {
|
939 mike 1.1.2.3 XmlEntry entry;
940 CIMStatusCode code;
941 const char* description = 0;
942
943 if (XmlReader::getErrorElement(parser, code, description))
944 {
945 _outputQueue->enqueue(new CIMAssociatorsResponseMessage(
946 messageId,
947 code,
948 description,
949 QueueIdStack(),
950 Array<CIMObjectWithPath>()));
951 }
952 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
953 {
954 Array<CIMObjectWithPath> objectWithPathArray;
955 CIMObjectWithPath tmp;
956
957 while (XmlReader::getObjectWithPath(parser, tmp))
958 objectWithPathArray.append(tmp);
959
960 mike 1.1.2.3 XmlReader::testEndTag(parser, "IRETURNVALUE");
961
962 _outputQueue->enqueue(new CIMAssociatorsResponseMessage(
963 messageId,
964 CIM_ERR_SUCCESS,
965 String(),
966 QueueIdStack(),
967 objectWithPathArray));
968 }
969 else
970 {
971 throw XmlValidationError(parser.getLine(),
972 "expected ERROR or IRETURNVALUE element");
|
973 kumpf 1.1.2.5 }
974 }
975
976 void CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
977 XmlParser& parser, const String& messageId, const String& methodName)
978 {
979 XmlEntry entry;
980 CIMStatusCode code;
981 const char* description = 0;
982
983 CIMValue value;
984 Array<CIMParamValue> outParameters;
985 const char* paramName;
986 String inValue;
987
988 if (XmlReader::getErrorElement(parser, code, description))
989 {
990 _outputQueue->enqueue(new CIMInvokeMethodResponseMessage(
991 messageId,
992 code,
993 description,
994 kumpf 1.1.2.5 QueueIdStack(),
995 value,
996 outParameters,
997 methodName));
998 }
999 else if (XmlReader::testStartTag(parser, entry, "RETURNVALUE"))
1000 {
1001 XmlReader::getValueElement(parser, CIMType::STRING, value);
1002
1003 XmlReader::testEndTag(parser, "RETURNVALUE");
1004
1005 while (XmlReader::getParamValueTag(parser, paramName))
1006 {
1007 //XmlReader::getValueElement(parser, CIMType::NONE, inValue);
1008 XmlReader::getStringValueElement(parser, inValue, true);
1009
1010 outParameters.append(CIMParamValue(
1011 CIMParameter(paramName, CIMType::STRING),
1012 CIMValue(inValue)));
1013
1014 XmlReader::expectEndTag(parser, "PARAMVALUE");
1015 kumpf 1.1.2.5 }
1016
1017 _outputQueue->enqueue(new CIMInvokeMethodResponseMessage(
1018 messageId,
1019 CIM_ERR_SUCCESS,
1020 String(),
1021 QueueIdStack(),
1022 value,
1023 outParameters,
1024 methodName));
1025 }
1026 else
1027 {
1028 throw XmlValidationError(parser.getLine(),
1029 "expected ERROR or RETURNVALUE element");
|
1030 mike 1.1.2.3 }
|
1031 mike 1.1.2.1 }
1032
1033 PEGASUS_NAMESPACE_END
|
Return to
CIMOperationResponseDecoder.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Client