1 karl 1.1 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
4 // The Open Group, Tivoli Systems
5 //
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 karl 1.1 //==============================================================================
23 //
24 // Author: Mike Brasher (mbrasher@bmc.com)
25 //
26 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
27 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
28 // Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
29 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
30 // Carol Ann Krug Graves, Hewlett-Packard Company
31 // (carolann_graves@hp.com)
|
32 karl 1.3 // Karl Schopmeyer (k.schopmeyer@opengroup.org)
|
33 karl 1.1 //
34 //%/////////////////////////////////////////////////////////////////////////////
35
36 #include <Pegasus/Common/Config.h>
37 #include <iostream>
38 #include <Pegasus/Common/Constants.h>
39 #include <Pegasus/Common/XmlParser.h>
40 #include <Pegasus/Common/XmlReader.h>
41 #include <Pegasus/Common/System.h>
42 #include <Pegasus/Common/XmlWriter.h>
43 #include <Pegasus/Common/HTTPMessage.h>
44 #include <Pegasus/Common/CIMMessage.h>
45 #include <Pegasus/Common/Exception.h>
46 #include "CIMOperationResponseDecoder.h"
47
48 PEGASUS_USING_STD;
49
50 PEGASUS_NAMESPACE_BEGIN
51
52 CIMOperationResponseDecoder::CIMOperationResponseDecoder(
53 MessageQueue* outputQueue,
54 karl 1.1 MessageQueue* encoderQueue,
55 ClientAuthenticator* authenticator)
56 :
57 MessageQueue(PEGASUS_QUEUENAME_OPRESPDECODER),
58 _outputQueue(outputQueue),
59 _encoderQueue(encoderQueue),
60 _authenticator(authenticator)
61 {
62
63 }
64
65 CIMOperationResponseDecoder::~CIMOperationResponseDecoder()
66 {
67
68 }
69
70 void CIMOperationResponseDecoder::setEncoderQueue(MessageQueue* encoderQueue)
71 {
72 _encoderQueue = encoderQueue;
73 }
74
75 karl 1.1 void CIMOperationResponseDecoder::handleEnqueue()
76 {
77 Message* message = dequeue();
78
79 if (!message)
80 return;
81
82 switch (message->getType())
83 {
84 case HTTP_MESSAGE:
85 {
86
87 HTTPMessage* httpMessage = (HTTPMessage*)message;
88 _handleHTTPMessage(httpMessage);
89 break;
90 }
91
92 default:
93 PEGASUS_ASSERT(0);
94 break;
95 }
96 karl 1.1
97 delete message;
98 }
99
100 void CIMOperationResponseDecoder::_handleHTTPMessage(HTTPMessage* httpMessage)
101 {
102 //
103 // Parse the HTTP message:
104 //
105
106 String startLine;
107 Array<HTTPHeader> headers;
108 Sint8* content;
109 Uint32 contentLength;
110
111 if (httpMessage->message.size() == 0)
112 {
113 CIMClientMalformedHTTPException* malformedHTTPException =
114 new CIMClientMalformedHTTPException("Empty HTTP response message.");
115 ClientExceptionMessage * response =
116 new ClientExceptionMessage(malformedHTTPException);
117 karl 1.1
118 _outputQueue->enqueue(response);
119 return;
120 }
121
122 httpMessage->parse(startLine, headers, contentLength);
123
124 //
125 // Get the status line info
126 //
127
128 String httpVersion;
129 Uint32 statusCode;
130 String reasonPhrase;
131
132 Boolean parsableMessage = HTTPMessage::parseStatusLine(
133 startLine, httpVersion, statusCode, reasonPhrase);
134 if (!parsableMessage)
135 {
136 CIMClientMalformedHTTPException* malformedHTTPException = new
137 CIMClientMalformedHTTPException("Malformed HTTP response message.");
138 karl 1.1 ClientExceptionMessage * response =
139 new ClientExceptionMessage(malformedHTTPException);
140
141 _outputQueue->enqueue(response);
142 return;
143 }
144
145 try
146 {
147 if (_authenticator->checkResponseHeaderForChallenge(headers))
148 {
149 //
150 // Get the original request, put that in the encoder's queue for
151 // re-sending with authentication challenge response.
152 //
153 Message* reqMessage = _authenticator->getRequestMessage();
154 _encoderQueue->enqueue(reqMessage);
155
156 return;
157 }
158 else
159 karl 1.1 {
160 //
161 // Received a valid/error response from the server.
162 // We do not need the original request message anymore, hence delete
163 // the request message by getting the handle from the ClientAuthenticator.
164 //
165 Message* reqMessage = _authenticator->getRequestMessage();
166 _authenticator->clearRequest();
167 if (reqMessage)
168 {
169 delete reqMessage;
170 }
171 }
172 }
173 catch(InvalidAuthHeader& e)
174 {
175 CIMClientMalformedHTTPException* malformedHTTPException =
176 new CIMClientMalformedHTTPException(e.getMessage());
177 ClientExceptionMessage * response =
178 new ClientExceptionMessage(malformedHTTPException);
179
180 karl 1.1 _outputQueue->enqueue(response);
181 return;
182 }
183 catch(UnauthorizedAccess& e)
184 {
185 CannotConnectException* cannotConnectException =
186 new CannotConnectException(e.getMessage());
187 ClientExceptionMessage * response =
188 new ClientExceptionMessage(cannotConnectException);
189
190 _outputQueue->enqueue(response);
191 return;
192 }
193
194 //
195 // Check for a success (200 OK) response
196 //
|
197 karl 1.4 httpMessage->message.append('\0');
198
199 // Display of received packet. Displays the complete received packet
200 // For now, this is conditionally compiled.
201 if (getenv("PEGASUS_CLIENT_TRACE"))
202 XmlWriter::indentedPrint(cout, httpMessage->message.getData());
|
203 karl 1.1
204 if (statusCode != HTTP_STATUSCODE_OK)
205 {
206 String cimError;
207 String pegasusError;
208
209 HTTPMessage::lookupHeader(headers, "CIMError", cimError);
210 HTTPMessage::lookupHeader(headers, PEGASUS_HTTPHEADERTAG_ERRORDETAIL, pegasusError);
211
212 CIMClientHTTPErrorException* httpError =
213 new CIMClientHTTPErrorException(statusCode, cimError, pegasusError);
214 ClientExceptionMessage * response =
215 new ClientExceptionMessage(httpError);
216
217 _outputQueue->enqueue(response);
218 return;
219 }
220
221 //
222 // Search for "CIMOperation" header:
223 //
224 karl 1.1
225 String cimOperation;
226
227 if (!HTTPMessage::lookupHeader(
228 headers, "CIMOperation", cimOperation, true))
229 {
230 CIMClientMalformedHTTPException* malformedHTTPException = new
231 CIMClientMalformedHTTPException("Missing CIMOperation HTTP header");
232 ClientExceptionMessage * response =
233 new ClientExceptionMessage(malformedHTTPException);
234
235 _outputQueue->enqueue(response);
236 return;
237 }
238
239 //
240 // Zero-terminate the message:
241 //
242
|
243 karl 1.4 //httpMessage->message.append('\0');
|
244 karl 1.1
245 // Display of received packet. Displays the complete received packet
246 // For now, this is conditionally compiled.
|
247 karl 1.4 //if (getenv("PEGASUS_CLIENT_TRACE"))
248 // XmlWriter::indentedPrint(cout, httpMessage->message.getData());
|
249 karl 1.1
250 // Calculate the beginning of the content from the message size and
251 // the content length. Subtract 1 to take into account the null
252 // character we just added to the end of the message.
253
254 content = (Sint8*) httpMessage->message.getData() +
255 httpMessage->message.size() - contentLength - 1;
256
257 //
258 // If it is a method response, then dispatch it to be handled:
259 //
260
261 if (!String::equalNoCase(cimOperation, "MethodResponse"))
262 {
263 CIMClientMalformedHTTPException* malformedHTTPException =
264 new CIMClientMalformedHTTPException(
265 String("Received CIMOperation HTTP header value \"") +
266 cimOperation + "\", expected \"MethodResponse\"");
267 ClientExceptionMessage * response =
268 new ClientExceptionMessage(malformedHTTPException);
269
270 karl 1.1 _outputQueue->enqueue(response);
271 return;
272 }
273
274 _handleMethodResponse(content);
275 }
276
277 void CIMOperationResponseDecoder::_handleMethodResponse(char* content)
278 {
279 Message* response = 0;
280
281 //
282 // Create and initialize XML parser:
283 //
284
285 XmlParser parser((char*)content);
286 XmlEntry entry;
287
288 try
289 {
290 //
291 karl 1.1 // Process <?xml ... >
292 //
293
294 const char* xmlVersion = 0;
295 const char* xmlEncoding = 0;
296
297 XmlReader::getXmlDeclaration(parser, xmlVersion, xmlEncoding);
298
299 //
300 // Process <CIM ... >
301 //
302
303 const char* cimVersion = 0;
304 const char* dtdVersion = 0;
305
306 // ATTN-RK-P3-20020416: Need to validate these versions?
307 XmlReader::getCimStartTag(parser, cimVersion, dtdVersion);
308
309 //
310 // Expect <MESSAGE ... >
311 //
312 karl 1.1
313 String messageId;
314 String protocolVersion;
315
316 if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
317 throw XmlValidationError(
318 parser.getLine(), "expected MESSAGE element");
319
320 if (!String::equalNoCase(protocolVersion, "1.0"))
321 {
322 CIMClientResponseException* responseException =
323 new CIMClientResponseException(
324 String("Received unsupported protocol version \"") +
325 protocolVersion + "\", expected \"1.0\"");
326 ClientExceptionMessage * response =
327 new ClientExceptionMessage(responseException);
328
329 _outputQueue->enqueue(response);
330 return;
331 }
332
333 karl 1.1 //
334 // Expect <SIMPLERSP ... >
335 //
336
337 XmlReader::expectStartTag(parser, entry, "SIMPLERSP");
338
339 //
340 // Expect <IMETHODRESPONSE ... >
341 //
342
343 const char* iMethodResponseName = 0;
344
345 if (XmlReader::getIMethodResponseStartTag(parser, iMethodResponseName))
346 {
347 //
348 // Dispatch the method:
349 //
350
351 if (System::strcasecmp(iMethodResponseName, "GetClass") == 0)
352 response = _decodeGetClassResponse(parser, messageId);
353 else if (System::strcasecmp(iMethodResponseName, "GetInstance") == 0)
354 karl 1.1 response = _decodeGetInstanceResponse(parser, messageId);
355 else if (System::strcasecmp(iMethodResponseName, "EnumerateClassNames") == 0)
356 response = _decodeEnumerateClassNamesResponse(parser,messageId);
357 else if (System::strcasecmp(iMethodResponseName, "References") == 0)
358 response = _decodeReferencesResponse(parser, messageId);
359 else if (System::strcasecmp(iMethodResponseName, "ReferenceNames") == 0)
360 response = _decodeReferenceNamesResponse(parser, messageId);
361 else if (System::strcasecmp(iMethodResponseName, "AssociatorNames") == 0)
362 response = _decodeAssociatorNamesResponse(parser, messageId);
363 else if (System::strcasecmp(iMethodResponseName, "Associators") == 0)
364 response = _decodeAssociatorsResponse(parser, messageId);
365 else if (System::strcasecmp(iMethodResponseName, "CreateInstance") == 0)
366 response = _decodeCreateInstanceResponse(parser, messageId);
367 else if (System::strcasecmp(iMethodResponseName,"EnumerateInstanceNames") == 0)
368 response = _decodeEnumerateInstanceNamesResponse(
369 parser, messageId);
370 else if (System::strcasecmp(iMethodResponseName,"EnumerateInstances") == 0)
371 response = _decodeEnumerateInstancesResponse(parser, messageId);
372 else if (System::strcasecmp(iMethodResponseName, "GetProperty") == 0)
373 response = _decodeGetPropertyResponse(parser, messageId);
374 else if (System::strcasecmp(iMethodResponseName, "SetProperty") == 0)
375 karl 1.1 response = _decodeSetPropertyResponse(parser, messageId);
376 else if (System::strcasecmp(iMethodResponseName, "DeleteQualifier") == 0)
377 response = _decodeDeleteQualifierResponse(parser, messageId);
378 else if (System::strcasecmp(iMethodResponseName, "GetQualifier") == 0)
379 response = _decodeGetQualifierResponse(parser, messageId);
380 else if (System::strcasecmp(iMethodResponseName, "SetQualifier") == 0)
381 response = _decodeSetQualifierResponse(parser, messageId);
382 else if (System::strcasecmp(iMethodResponseName, "EnumerateQualifiers") == 0)
383 response = _decodeEnumerateQualifiersResponse(parser,messageId);
384 else if (System::strcasecmp(iMethodResponseName, "EnumerateClasses") == 0)
385 response = _decodeEnumerateClassesResponse(parser, messageId);
386 else if (System::strcasecmp(iMethodResponseName, "CreateClass") == 0)
387 response = _decodeCreateClassResponse(parser, messageId);
388 else if (System::strcasecmp(iMethodResponseName, "ModifyClass") == 0)
389 response = _decodeModifyClassResponse(parser, messageId);
390 else if (System::strcasecmp(iMethodResponseName, "ModifyInstance") == 0)
391 response = _decodeModifyInstanceResponse(parser, messageId);
392 else if (System::strcasecmp(iMethodResponseName, "DeleteClass") == 0)
393 response = _decodeDeleteClassResponse(parser, messageId);
394 else if (System::strcasecmp(iMethodResponseName, "DeleteInstance") == 0)
395 response = _decodeDeleteInstanceResponse(parser, messageId);
396 karl 1.1 else if (System::strcasecmp(iMethodResponseName, "ExecQuery") == 0)
397 response = _decodeExecQueryResponse(parser, messageId);
398 else
399 {
400 // Unrecognized IMethodResponse name attribute
401 throw XmlValidationError(parser.getLine(),
402 String("Unrecognized IMethodResponse name \"") +
403 iMethodResponseName + "\"");
404 }
405
406 //
407 // Handle end tag:
408 //
409
410 XmlReader::expectEndTag(parser, "IMETHODRESPONSE");
411 }
412 else if (XmlReader::getMethodResponseStartTag(parser,
413 iMethodResponseName))
414 {
415 response = _decodeInvokeMethodResponse(
416 parser, messageId, iMethodResponseName);
417 karl 1.1
418 //
419 // Handle end tag:
420 //
421 XmlReader::expectEndTag(parser, "METHODRESPONSE");
422 }
423 else
424 {
425 throw XmlValidationError(parser.getLine(),
426 "expected METHODRESPONSE or IMETHODRESPONSE element");
427 }
428
429 //
430 // Handle end tags:
431 //
432 XmlReader::expectEndTag(parser, "SIMPLERSP");
433 XmlReader::expectEndTag(parser, "MESSAGE");
434 XmlReader::expectEndTag(parser, "CIM");
435 }
436 catch (XmlException& x)
437 {
438 karl 1.1 if (response)
439 {
440 delete response;
441 }
442
443 response = new ClientExceptionMessage(
444 new CIMClientXmlException(x.getMessage()));
445 }
446 catch (Exception& x)
447 {
448 // Shouldn't ever get exceptions other than XmlExceptions.
449 PEGASUS_ASSERT(0);
450
451 if (response)
452 {
453 delete response;
454 }
455
456 response = new ClientExceptionMessage(
457 new Exception(x.getMessage()));
458 }
459 karl 1.1
460 _outputQueue->enqueue(response);
461 }
462
463 CIMCreateClassResponseMessage* CIMOperationResponseDecoder::_decodeCreateClassResponse(
464 XmlParser& parser,
465 const String& messageId)
466 {
467 XmlEntry entry;
468 CIMException cimException;
469
470 if (XmlReader::getErrorElement(parser, cimException))
471 {
472 return(new CIMCreateClassResponseMessage(
473 messageId,
474 cimException,
475 QueueIdStack()));
476
477 }
478 else
479 {
480 karl 1.1 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
481 {
482 XmlReader::expectEndTag(parser, "IRETURNVALUE");
483 }
484
485 return(new CIMCreateClassResponseMessage(
486 messageId,
487 cimException,
488 QueueIdStack()));
489 }
490 }
491
492 CIMGetClassResponseMessage* CIMOperationResponseDecoder::_decodeGetClassResponse(
493 XmlParser& parser, const String& messageId)
494 {
495 XmlEntry entry;
496 CIMException cimException;
497
498 if (XmlReader::getErrorElement(parser, cimException))
499 {
500 return(new CIMGetClassResponseMessage(
501 karl 1.1 messageId,
502 cimException,
503 QueueIdStack(),
504 CIMClass()));
505 }
506 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
507 {
508 CIMClass cimClass;
509
510 if (!XmlReader::getClassElement(parser, cimClass))
511 throw XmlValidationError(parser.getLine(),"expected CLASS element");
512
513 XmlReader::testEndTag(parser, "IRETURNVALUE");
514
515 return(new CIMGetClassResponseMessage(
516 messageId,
517 cimException,
518 QueueIdStack(),
519 cimClass));
520 }
521 else
522 karl 1.1 {
523 throw XmlValidationError(parser.getLine(),
524 "expected ERROR or IRETURNVALUE element");
525 }
526 }
527
528 CIMModifyClassResponseMessage* CIMOperationResponseDecoder::_decodeModifyClassResponse(
529 XmlParser& parser, const String& messageId)
530 {
531 XmlEntry entry;
532 CIMException cimException;
533
534 if (XmlReader::getErrorElement(parser, cimException))
535 {
536 return(new CIMModifyClassResponseMessage(
537 messageId,
538 cimException,
539 QueueIdStack()));
540 }
541 else
542 {
543 karl 1.1 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
544 {
545 XmlReader::expectEndTag(parser, "IRETURNVALUE");
546 }
547
548 return(new CIMModifyClassResponseMessage(
549 messageId,
550 cimException,
551 QueueIdStack()));
552 }
553 }
554
555 CIMEnumerateClassNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
556 XmlParser& parser, const String& messageId)
557 {
558 XmlEntry entry;
559 CIMException cimException;
560
561 if (XmlReader::getErrorElement(parser, cimException))
562 {
563 return(new CIMEnumerateClassNamesResponseMessage(
564 karl 1.1 messageId,
565 cimException,
566 QueueIdStack(),
567 Array<CIMName>()));
568 }
569 else
570 {
571 Array<CIMName> classNames;
572
|
573 karl 1.5 // KS 20020931 - Addition to allow empty tag return. BUGZILLA135
|
574 karl 1.3 // WBEMServices returns this tag wneh no instances exist.
575 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
576 if (entry.type != XmlEntry::EMPTY_TAG)
577 {
578 CIMName className;
579
580 while (XmlReader::getClassNameElement(parser, className, false))
581 classNames.append(className);
582
583 XmlReader::expectEndTag(parser, "IRETURNVALUE");
584 }
|
585 karl 1.1
586 return(new CIMEnumerateClassNamesResponseMessage(
587 messageId,
588 cimException,
589 QueueIdStack(),
590 classNames));
591 }
592 }
593
594 CIMEnumerateClassesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
595 XmlParser& parser, const String& messageId)
596 {
597 XmlEntry entry;
598 CIMException cimException;
599
600 if (XmlReader::getErrorElement(parser, cimException))
601 {
602 return(new CIMEnumerateClassesResponseMessage(
603 messageId,
604 cimException,
605 QueueIdStack(),
606 karl 1.1 Array<CIMClass>()));
607 }
608 else
609 {
610 Array<CIMClass> cimClasses;
611
|
612 karl 1.5 // KS 20020931 - Addition to allow empty tag return. BUGZILLA135
|
613 karl 1.3 // WBEMServices returns this tag wneh no instances exist.
614 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
615 if (entry.type != XmlEntry::EMPTY_TAG)
616 {
617 CIMClass cimClass;
618
619 while (XmlReader::getClassElement(parser, cimClass))
620 cimClasses.append(cimClass);
621
622 XmlReader::expectEndTag(parser, "IRETURNVALUE");
623 }
|
624 karl 1.1
625 return(new CIMEnumerateClassesResponseMessage(
626 messageId,
627 cimException,
628 QueueIdStack(),
629 cimClasses));
630 }
631 }
632
633 CIMDeleteClassResponseMessage* CIMOperationResponseDecoder::_decodeDeleteClassResponse(
634 XmlParser& parser, const String& messageId)
635 {
636 XmlEntry entry;
637 CIMException cimException;
638
639 if (XmlReader::getErrorElement(parser, cimException))
640 {
641 return(new CIMDeleteClassResponseMessage(
642 messageId,
643 cimException,
644 QueueIdStack()));
645 karl 1.1 }
646 else
647 {
648 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
649 {
650 XmlReader::expectEndTag(parser, "IRETURNVALUE");
651 }
652
653 return(new CIMDeleteClassResponseMessage(
654 messageId,
655 cimException,
656 QueueIdStack()));
657 }
658 }
659
660 CIMCreateInstanceResponseMessage* CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
661 XmlParser& parser, const String& messageId)
662 {
663 XmlEntry entry;
664 CIMException cimException;
665
666 karl 1.1 if (XmlReader::getErrorElement(parser, cimException))
667 {
668 return(new CIMCreateInstanceResponseMessage(
669 messageId,
670 cimException,
671 QueueIdStack(),
672 CIMObjectPath()));
673 }
674 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
675 {
676 CIMObjectPath instanceName;
677 XmlReader::getInstanceNameElement(parser, instanceName);
678
679 XmlReader::testEndTag(parser, "IRETURNVALUE");
680
681 return(new CIMCreateInstanceResponseMessage(
682 messageId,
683 cimException,
684 QueueIdStack(),
685 instanceName));
686 }
687 karl 1.1 else
688 {
689 throw XmlValidationError(parser.getLine(),
690 "expected ERROR or IRETURNVALUE element");
691 }
692 }
693
694 CIMGetInstanceResponseMessage* CIMOperationResponseDecoder::_decodeGetInstanceResponse(
695 XmlParser& parser, const String& messageId)
696 {
697 XmlEntry entry;
698 CIMException cimException;
699
700 if (XmlReader::getErrorElement(parser, cimException))
701 {
702 return(new CIMGetInstanceResponseMessage(
703 messageId,
704 cimException,
705 QueueIdStack(),
706 CIMInstance()));
707 }
708 karl 1.1 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
709 {
710 CIMInstance cimInstance;
711
712 if (!XmlReader::getInstanceElement(parser, cimInstance))
713 {
714 throw XmlValidationError(
715 parser.getLine(), "expected INSTANCE element");
716 }
717
718 XmlReader::testEndTag(parser, "IRETURNVALUE");
719
720 return(new CIMGetInstanceResponseMessage(
721 messageId,
722 cimException,
723 QueueIdStack(),
724 cimInstance));
725 }
726 else
727 {
728 throw XmlValidationError(parser.getLine(),
729 karl 1.1 "expected ERROR or IRETURNVALUE element");
730 }
731 }
732
733 CIMModifyInstanceResponseMessage* CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
734 XmlParser& parser, const String& messageId)
735 {
736 XmlEntry entry;
737 CIMException cimException;
738
739 if (XmlReader::getErrorElement(parser, cimException))
740 {
741 return(new CIMModifyInstanceResponseMessage(
742 messageId,
743 cimException,
744 QueueIdStack()));
745 }
746 else
747 {
748 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
749 {
750 karl 1.1 XmlReader::expectEndTag(parser, "IRETURNVALUE");
751 }
752
753 return(new CIMModifyInstanceResponseMessage(
754 messageId,
755 cimException,
756 QueueIdStack()));
757 }
758 }
759
760 CIMEnumerateInstanceNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
761 XmlParser& parser, const String& messageId)
762 {
763 XmlEntry entry;
764 CIMException cimException;
765
766 if (XmlReader::getErrorElement(parser, cimException))
767 {
768 return(new CIMEnumerateInstanceNamesResponseMessage(
769 messageId,
770 cimException,
771 karl 1.1 QueueIdStack(),
772 Array<CIMObjectPath>()));
773 }
774 else
775 {
776 Array<CIMObjectPath> instanceNames;
777
|
778 karl 1.5 // KS 20020931 - Addition to allow empty tag return. BUGZILLA135
|
779 karl 1.3 // WBEMServices returns this tag wneh no instances exist.
780 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
781 if (entry.type != XmlEntry::EMPTY_TAG)
782 {
783 String className;
784 Array<CIMKeyBinding> keyBindings;
785
786 while (XmlReader::getInstanceNameElement(
787 parser, className, keyBindings))
788 {
789 CIMObjectPath r(
790 String::EMPTY,
791 String::EMPTY,
792 className,
793 keyBindings);
794 instanceNames.append(r);
795 }
796
797 XmlReader::expectEndTag(parser, "IRETURNVALUE");
798 }
|
799 karl 1.1
800 return(new CIMEnumerateInstanceNamesResponseMessage(
801 messageId,
802 cimException,
803 QueueIdStack(),
804 instanceNames));
805 }
806 }
807
808 CIMEnumerateInstancesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(
809 XmlParser& parser, const String& messageId)
810 {
811 XmlEntry entry;
812 CIMException cimException;
813
814 if (XmlReader::getErrorElement(parser, cimException))
815 {
816 return(new CIMEnumerateInstancesResponseMessage(
817 messageId,
818 cimException,
819 QueueIdStack(),
820 karl 1.1 Array<CIMInstance>()));
821 }
822 else
823 {
824 Array<CIMInstance> namedInstances;
|
825 karl 1.3
|
826 karl 1.5 // KS 20020931 - Addition to allow empty tag return. BUGZILLA135
|
827 karl 1.3 // WBEMServices returns this tag wneh no instances exist.
828 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
|
829 karl 1.2 if (entry.type != XmlEntry::EMPTY_TAG)
830 {
831 CIMInstance namedInstance;
832
833 while (XmlReader::getNamedInstanceElement(parser, namedInstance))
834 namedInstances.append(namedInstance);
835
836 XmlReader::expectEndTag(parser, "IRETURNVALUE");
837 }
|
838 karl 1.1
839 return(new CIMEnumerateInstancesResponseMessage(
840 messageId,
841 cimException,
842 QueueIdStack(),
843 namedInstances));
844 }
845 }
846
847 CIMDeleteInstanceResponseMessage* CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
848 XmlParser& parser, const String& messageId)
849 {
850 XmlEntry entry;
851 CIMException cimException;
852
853 if (XmlReader::getErrorElement(parser, cimException))
854 {
855 return(new CIMDeleteInstanceResponseMessage(
856 messageId,
857 cimException,
858 QueueIdStack()));
859 karl 1.1 }
860 else
861 {
862 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
863 {
864 XmlReader::expectEndTag(parser, "IRETURNVALUE");
865 }
866
867 return(new CIMDeleteInstanceResponseMessage(
868 messageId,
869 cimException,
870 QueueIdStack()));
871 }
872 }
873
874 CIMGetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeGetPropertyResponse(
875 XmlParser& parser, const String& messageId)
876 {
877 XmlEntry entry;
878 CIMException cimException;
879
880 karl 1.1 if (XmlReader::getErrorElement(parser, cimException))
881 {
882 return(new CIMGetPropertyResponseMessage(
883 messageId,
884 cimException,
885 QueueIdStack(),
886 CIMValue()));
887 }
888 else
889 {
890 CIMValue cimValue(CIMTYPE_STRING, false);
891
892 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
893 {
894 if (!XmlReader::getPropertyValue(parser, cimValue))
895 {
896 // No value given; just return a null String value
897 }
898
899 XmlReader::expectEndTag(parser, "IRETURNVALUE");
900 }
901 karl 1.1 else
902 {
903 // No value given; just return a null String value
904 }
905
906 return(new CIMGetPropertyResponseMessage(
907 messageId,
908 cimException,
909 QueueIdStack(),
910 cimValue));
911 }
912 }
913
914 CIMSetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeSetPropertyResponse(
915 XmlParser& parser, const String& messageId)
916 {
917 XmlEntry entry;
918 CIMException cimException;
919
920 if (XmlReader::getErrorElement(parser, cimException))
921 {
922 karl 1.1 return(new CIMSetPropertyResponseMessage(
923 messageId,
924 cimException,
925 QueueIdStack()));
926 }
927 else
928 {
929 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
930 {
931 XmlReader::expectEndTag(parser, "IRETURNVALUE");
932 }
933
934 return(new CIMSetPropertyResponseMessage(
935 messageId,
936 cimException,
937 QueueIdStack()));
938 }
939 }
940
941 CIMSetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeSetQualifierResponse(
942 XmlParser& parser, const String& messageId)
943 karl 1.1 {
944 XmlEntry entry;
945 CIMException cimException;
946
947 if (XmlReader::getErrorElement(parser, cimException))
948 {
949 return(new CIMSetQualifierResponseMessage(
950 messageId,
951 cimException,
952 QueueIdStack()));
953 }
954 else
955 {
956 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
957 {
958 XmlReader::expectEndTag(parser, "IRETURNVALUE");
959 }
960
961 return(new CIMSetQualifierResponseMessage(
962 messageId,
963 cimException,
964 karl 1.1 QueueIdStack()));
965 }
966 }
967
968 CIMGetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeGetQualifierResponse(
969 XmlParser& parser, const String& messageId)
970 {
971 XmlEntry entry;
972 CIMException cimException;
973
974 if (XmlReader::getErrorElement(parser, cimException))
975 {
976 return(new CIMGetQualifierResponseMessage(
977 messageId,
978 cimException,
979 QueueIdStack(),
980 CIMQualifierDecl()));
981 }
982 else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
983 {
984 CIMQualifierDecl qualifierDecl;
985 karl 1.1 XmlReader::getQualifierDeclElement(parser, qualifierDecl);
986
987 XmlReader::testEndTag(parser, "IRETURNVALUE");
988
989 return(new CIMGetQualifierResponseMessage(
990 messageId,
991 cimException,
992 QueueIdStack(),
993 qualifierDecl));
994 }
995 else
996 {
997 throw XmlValidationError(parser.getLine(),
998 "expected ERROR or IRETURNVALUE element");
999 }
1000 }
1001
1002 CIMEnumerateQualifiersResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
1003 XmlParser& parser, const String& messageId)
1004 {
1005 XmlEntry entry;
1006 karl 1.1 CIMException cimException;
1007
1008 if (XmlReader::getErrorElement(parser, cimException))
1009 {
1010 return(new CIMEnumerateQualifiersResponseMessage(
1011 messageId,
1012 cimException,
1013 QueueIdStack(),
1014 Array<CIMQualifierDecl>()));
1015 }
1016 else
1017 {
1018 Array<CIMQualifierDecl> qualifierDecls;
1019
|
1020 karl 1.5 // KS 20020931 - Addition to allow empty tag return. BUGZILLA135
|
1021 karl 1.3 // WBEMServices returns this tag wneh no instances exist.
1022 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1023 if (entry.type != XmlEntry::EMPTY_TAG)
1024 {
1025 CIMQualifierDecl qualifierDecl;
1026
1027 while (XmlReader::getQualifierDeclElement(parser, qualifierDecl))
1028 qualifierDecls.append(qualifierDecl);
1029
1030 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1031 }
|
1032 karl 1.1
1033 return(new CIMEnumerateQualifiersResponseMessage(
1034 messageId,
1035 cimException,
1036 QueueIdStack(),
1037 qualifierDecls));
1038 }
1039 }
1040
1041 CIMDeleteQualifierResponseMessage* CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
1042 XmlParser& parser, const String& messageId)
1043 {
1044 XmlEntry entry;
1045 CIMException cimException;
1046
1047 if (XmlReader::getErrorElement(parser, cimException))
1048 {
1049 return(new CIMDeleteQualifierResponseMessage(
1050 messageId,
1051 cimException,
1052 QueueIdStack()));
1053 karl 1.1 }
1054 else
1055 {
1056 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1057 {
1058 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1059 }
1060
1061 return(new CIMDeleteQualifierResponseMessage(
1062 messageId,
1063 cimException,
1064 QueueIdStack()));
1065 }
1066 }
1067
1068
|
1069 karl 1.5 //********************Temporary code insertion**********************
|
1070 karl 1.4 // KS 20021001 - Added this duplicate from xmlreader to test changes
|
1071 karl 1.5 // BUGZILLA 136
|
1072 karl 1.4 // for wbemservices problem where it does not return objectpath element
1073 // Tests for ObjectPath OR InstancePathelemen or classpath element
1074 Boolean _getObjectPathElement(
1075 XmlParser& parser,
1076 CIMObjectPath& objectPath)
1077 {
1078 XmlEntry entry;
1079
1080 if (!XmlReader::testStartTag(parser, entry, "OBJECTPATH"))
1081 { // loop for the interop test
1082 //See getValueReferenceElement for good code.
1083 if (!parser.next(entry))
1084 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
1085 if (entry.type != XmlEntry::START_TAG &&
1086 entry.type != XmlEntry::EMPTY_TAG)
1087 {
1088 parser.putBack(entry);
1089 return false;
1090 }
1091 if (strcmp(entry.text, "CLASSPATH") == 0)
1092 {
1093 karl 1.4 parser.putBack(entry);
1094 XmlReader::getClassPathElement(parser, objectPath);
1095 return true;
1096 }
1097 else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
1098 {
1099 parser.putBack(entry);
1100 XmlReader::getLocalClassPathElement(parser, objectPath);
1101 return true;
1102 }
1103 else if (strcmp(entry.text, "CLASSNAME") == 0)
1104 {
1105 parser.putBack(entry);
1106 CIMName className;
1107 XmlReader::getClassNameElement(parser, className);
1108 objectPath.set(String(), CIMNamespaceName(), className);
1109 return true;
1110 }
1111 else if (strcmp(entry.text, "INSTANCEPATH") == 0)
1112 {
1113 parser.putBack(entry);
1114 karl 1.4 XmlReader::getInstancePathElement(parser, objectPath);
1115 return true;
1116 }
1117 else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
1118 {
1119 parser.putBack(entry);
1120 XmlReader::getLocalInstancePathElement(parser, objectPath);
1121 return true;
1122 }
1123 else if (strcmp(entry.text, "INSTANCENAME") == 0)
1124 {
1125 parser.putBack(entry);
1126 String className;
1127 Array<CIMKeyBinding> keyBindings;
1128 XmlReader::getInstanceNameElement(parser, className, keyBindings);
1129 objectPath.set(String(), CIMNamespaceName(), className, keyBindings);
1130 return true;
1131 }
1132 return false;
1133 }
1134
1135 karl 1.4 if (XmlReader::getClassPathElement(parser, objectPath))
1136 {
1137 XmlReader::expectEndTag(parser, "OBJECTPATH");
1138 return true;
1139 }
1140 else if (XmlReader::getInstancePathElement(parser, objectPath))
1141 {
1142 XmlReader::expectEndTag(parser, "OBJECTPATH");
1143 return true;
1144 }
1145 else
1146 {
1147 throw XmlValidationError(parser.getLine(),
1148 "expected INSTANCEPATH or CLASSPATH element");
1149 }
1150
1151 PEGASUS_UNREACHABLE ( return false; )
1152 }
|
1153 karl 1.5 //*******************END of Temporary code insertion******
1154
1155
1156 CIMReferenceNamesResponseMessage* CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
1157 XmlParser& parser, const String& messageId)
1158 {
1159 XmlEntry entry;
1160 CIMException cimException;
1161
1162 if (XmlReader::getErrorElement(parser, cimException))
1163 {
1164 return(new CIMReferenceNamesResponseMessage(
1165 messageId,
1166 cimException,
1167 QueueIdStack(),
1168 Array<CIMObjectPath>()));
1169 }
1170 else
1171 {
1172 Array<CIMObjectPath> objectPaths;
1173
1174 karl 1.5 // KS 20020931 - Addition to allow empty tag return. BUGZILLA135
1175 // WBEMServices returns this tag wneh no instances exist.
1176 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1177 if (entry.type != XmlEntry::EMPTY_TAG)
1178 {
1179 CIMObjectPath objectPath;
1180
1181 // KS 20021001 - Call local version of getobjectpath for
1182 // client responses. BUGZILLA 136. This added to correct
1183 // for Wbemservices problem (treats objectpath and instancepath
1184 // tags as optional) and should be removed when these problems
1185 // are corrected permanently.
1186
1187 //while (XmlReader::getObjectPathElement(parser, objectPath))
1188 // objectPaths.append(objectPath);
1189
1190 while (_getObjectPathElement(parser, objectPath))
1191 objectPaths.append(objectPath);
1192
1193 // End of BUGZILLA 136 fix
1194
1195 karl 1.5 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1196 }
1197
1198 return(new CIMReferenceNamesResponseMessage(
1199 messageId,
1200 cimException,
1201 QueueIdStack(),
1202 objectPaths));
1203 }
1204 }
|
1205 karl 1.4
|
1206 karl 1.5 CIMReferencesResponseMessage* CIMOperationResponseDecoder::_decodeReferencesResponse(
1207 XmlParser& parser, const String& messageId)
1208 {
1209 XmlEntry entry;
1210 CIMException cimException;
1211
1212 if (XmlReader::getErrorElement(parser, cimException))
1213 {
1214 return(new CIMReferencesResponseMessage(
1215 messageId,
1216 cimException,
1217 QueueIdStack(),
1218 Array<CIMObject>()));
1219 }
1220 else
1221 {
1222 Array<CIMObject> objectWithPathArray;
1223
1224
1225 // KS 20020931 - Addition to allow empty tag return. BUGZILLA135
1226 // WBEMServices returns this tag wneh no instances exist.
1227 karl 1.5 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1228 if (entry.type != XmlEntry::EMPTY_TAG)
1229 {
1230 CIMObject objectWithPath;
1231
1232 while (XmlReader::getValueObjectWithPathElement(parser, objectWithPath))
1233 objectWithPathArray.append(objectWithPath);
1234
1235 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1236 }
1237
1238 return(new CIMReferencesResponseMessage(
1239 messageId,
1240 cimException,
1241 QueueIdStack(),
1242 objectWithPathArray));
1243 }
1244 }
|
1245 karl 1.4
|
1246 karl 1.1 CIMAssociatorNamesResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
1247 XmlParser& parser, const String& messageId)
1248 {
1249 XmlEntry entry;
1250 CIMException cimException;
1251
1252 if (XmlReader::getErrorElement(parser, cimException))
1253 {
1254 return(new CIMAssociatorNamesResponseMessage(
1255 messageId,
1256 cimException,
1257 QueueIdStack(),
1258 Array<CIMObjectPath>()));
1259 }
1260 else
1261 {
1262 Array<CIMObjectPath> objectPaths;
|
1263 karl 1.4
|
1264 karl 1.5 // KS 20020931 - Addition to allow empty tag return. BUGZILLA 135
|
1265 karl 1.3 // WBEMServices returns this tag wneh no instances exist.
1266 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1267 if (entry.type != XmlEntry::EMPTY_TAG)
1268 {
1269 CIMObjectPath objectPath;
1270
|
1271 karl 1.5 // KS 20021001 - Call local version of getobjectpath for
1272 // client responses. BUGZILLA 136. This added to correct
1273 // for Wbemservices problem (treats objectpath and instancepath
1274 // tags as optional) and should be removed when these problems
1275 // are corrected permanently.
1276
|
1277 karl 1.4 //while (XmlReader::getObjectPathElement(parser, objectPath))
1278 // objectPaths.append(objectPath);
1279
1280 while (_getObjectPathElement(parser, objectPath))
|
1281 karl 1.3 objectPaths.append(objectPath);
|
1282 karl 1.5 // End of BUGZILLA 136 fix
|
1283 karl 1.4
|
1284 karl 1.3 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1285 }
|
1286 karl 1.1
1287 return(new CIMAssociatorNamesResponseMessage(
1288 messageId,
1289 cimException,
1290 QueueIdStack(),
1291 objectPaths));
1292 }
1293 }
1294
1295 CIMAssociatorsResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorsResponse(
1296 XmlParser& parser, const String& messageId)
1297 {
1298 XmlEntry entry;
1299 CIMException cimException;
1300
1301 if (XmlReader::getErrorElement(parser, cimException))
1302 {
1303 return(new CIMAssociatorsResponseMessage(
1304 messageId,
1305 cimException,
1306 QueueIdStack(),
1307 karl 1.1 Array<CIMObject>()));
1308 }
1309 else
1310 {
1311 Array<CIMObject> objectWithPathArray;
1312
|
1313 karl 1.3 // KS 20020931 - Addition to allow empty tag return.
1314 // WBEMServices returns this tag wneh no instances exist.
1315 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1316 if (entry.type != XmlEntry::EMPTY_TAG)
1317 {
1318 CIMObject objectWithPath;
1319
1320 while (XmlReader::getValueObjectWithPathElement(parser, objectWithPath))
1321 objectWithPathArray.append(objectWithPath);
1322
1323 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1324 }
|
1325 karl 1.1
1326 return(new CIMAssociatorsResponseMessage(
1327 messageId,
1328 cimException,
1329 QueueIdStack(),
1330 objectWithPathArray));
1331 }
1332 }
1333
1334 CIMExecQueryResponseMessage* CIMOperationResponseDecoder::_decodeExecQueryResponse(
1335 XmlParser& parser, const String& messageId)
1336 {
1337 XmlEntry entry;
1338 CIMException cimException;
1339
1340 if (XmlReader::getErrorElement(parser, cimException))
1341 {
1342 return(new CIMExecQueryResponseMessage(
1343 messageId,
1344 cimException,
1345 QueueIdStack(),
1346 karl 1.1 Array<CIMObject>()));
1347 }
1348 else
1349 {
1350 Array<CIMObject> objectWithPathArray;
1351
1352 if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1353 {
1354 XmlReader::getObjectArray(parser, objectWithPathArray);
1355
1356 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1357 }
1358
1359 return(new CIMExecQueryResponseMessage(
1360 messageId,
1361 cimException,
1362 QueueIdStack(),
1363 objectWithPathArray));
1364 }
1365 }
1366
1367 karl 1.1 CIMInvokeMethodResponseMessage* CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
1368 XmlParser& parser, const String& messageId, const String& methodName)
1369 {
1370 XmlEntry entry;
1371 CIMException cimException;
1372
1373 CIMParamValue paramValue;
1374 Array<CIMParamValue> outParameters;
1375 CIMValue returnValue;
1376 const char* paramName;
1377 String inValue;
1378
1379 if (XmlReader::getErrorElement(parser, cimException))
1380 {
1381 return(new CIMInvokeMethodResponseMessage(
1382 messageId,
1383 cimException,
1384 QueueIdStack(),
1385 returnValue,
1386 outParameters,
1387 methodName));
1388 karl 1.1 }
1389 else
1390 {
1391 Boolean isReturnValue = false;
1392 Boolean isParamValue = false;
1393 Boolean gotReturnValue = false;
1394
1395 while ((isReturnValue =
1396 XmlReader::getReturnValueElement(parser, returnValue)) ||
1397 (isParamValue =
1398 XmlReader::getParamValueElement(parser, paramValue)))
1399 {
1400 if (isReturnValue)
1401 {
1402 if (gotReturnValue)
1403 {
1404 throw XmlValidationError(parser.getLine(),
1405 "unexpected RETURNVALUE element");
1406 }
1407 gotReturnValue = true;
1408 }
1409 karl 1.1 else // isParamValue == true
1410 {
1411 outParameters.append(paramValue);
1412 }
1413
1414 isReturnValue = false;
1415 isParamValue = false;
1416 }
1417
1418 return(new CIMInvokeMethodResponseMessage(
1419 messageId,
1420 cimException,
1421 QueueIdStack(),
1422 returnValue,
1423 outParameters,
1424 methodName));
1425 }
1426 }
1427
1428 PEGASUS_NAMESPACE_END
|
Return to
CIMOperationResponseDecoder.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Client2