1 mike  1.2 //%/////////////////////////////////////////////////////////////////////////////
   2           //
   3           // Copyright (c) 2000, 2001 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 mike  1.2 //==============================================================================
  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           //
  31           //%/////////////////////////////////////////////////////////////////////////////
  32           
  33           #include <Pegasus/Common/Config.h>
  34           #include <iostream>
  35           #include <Pegasus/Common/XmlParser.h>
  36           #include <Pegasus/Common/XmlReader.h>
  37           #include <Pegasus/Common/System.h>
  38           #include <Pegasus/Common/XmlWriter.h>
  39           #include <Pegasus/Common/HTTPMessage.h>
  40           #include <Pegasus/Common/CIMMessage.h>
  41           #include "CIMOperationResponseDecoder.h"
  42           
  43 mike  1.2 PEGASUS_USING_STD;
  44           
  45           PEGASUS_NAMESPACE_BEGIN
  46           
  47           CIMOperationResponseDecoder::CIMOperationResponseDecoder(
  48               MessageQueue* outputQueue,
  49               MessageQueue* encoderQueue,
  50               ClientAuthenticator* authenticator)
  51               :
  52               _outputQueue(outputQueue),
  53               _encoderQueue(encoderQueue),
  54               _authenticator(authenticator)
  55           {
  56           
  57           }
  58           
  59           CIMOperationResponseDecoder::~CIMOperationResponseDecoder()
  60           {
  61           
  62           }
  63           
  64 mike  1.2 void  CIMOperationResponseDecoder::setEncoderQueue(MessageQueue* encoderQueue)
  65           {
  66               _encoderQueue = encoderQueue;
  67           }
  68           
  69           void CIMOperationResponseDecoder::handleEnqueue()
  70           {
  71               Message* message = dequeue();
  72           
  73               if (!message)
  74           	return;
  75           
  76               switch (message->getType())
  77               {
  78           	case HTTP_MESSAGE:
  79           	{

  80 mday  1.3 

  81 mike  1.2 	    HTTPMessage* httpMessage = (HTTPMessage*)message;
  82           	    _handleHTTPMessage(httpMessage);
  83           	    break;
  84           	}
  85           
  86           	default:
  87           	    // ATTN: send this to the orphan queue!
  88           	    break;
  89               }
  90           
  91               delete message;
  92           }
  93           
  94           const char* CIMOperationResponseDecoder::getQueueName() const
  95           {
  96               return "CIMOperationResponseDecoder";
  97           }
  98           
  99           void CIMOperationResponseDecoder::_handleHTTPMessage(HTTPMessage* httpMessage)
 100           {
 101               //
 102 mike  1.2     // Parse the HTTP message:
 103               //
 104           
 105               String startLine;
 106               Array<HTTPHeader> headers;
 107               Sint8* content;
 108               Uint32 contentLength;
 109           
 110               httpMessage->parse(startLine, headers, contentLength);
 111           

 112 kumpf 1.8     try

 113 mike  1.2     {

 114 kumpf 1.8         if (_authenticator->checkResponseHeaderForChallenge(headers))
 115                   {
 116                       //
 117                       // Get the original request, put that in the encoder's queue for
 118                       // re-sending with authentication challenge response.
 119                       //
 120                       Message* reqMessage = _authenticator->getRequestMessage();
 121                       _encoderQueue->enqueue(reqMessage);

 122 mike  1.2 

 123 kumpf 1.8             return;
 124                   }
 125                   else
 126                   {
 127                       //
 128                       // Received a valid/error response from the server.
 129                       // We do not need the original request message anymore, hence delete
 130                       // the request message by getting the handle from the ClientAuthenticator.
 131                       //
 132                       Message* reqMessage = _authenticator->getRequestMessage();
 133                       _authenticator->clearRequest();
 134                       if (reqMessage)
 135                       {
 136                           delete reqMessage;
 137                       }
 138                   }

 139 mike  1.2     }

 140 kumpf 1.8     catch(InvalidAuthHeader& e)

 141 mike  1.2     {

 142 kumpf 1.8         // ATTN-NB-P2-20020304: This error is discarded like the other errors
 143                   // in this method. Implement an error handling code for all these errors.

 144 mike  1.2 

 145 kumpf 1.8         return;

 146 mike  1.2     }
 147           
 148               //
 149               // Search for "CIMOperation" header:
 150               //
 151           
 152               String cimOperation;
 153           
 154               if (!HTTPMessage::lookupHeader(
 155           	headers, "*CIMOperation", cimOperation, true))
 156               {
 157           	// ATTN: error discarded at this time!
 158           	return;
 159               }
 160           
 161               //
 162               // Zero-terminate the message:
 163               //
 164           
 165               httpMessage->message.append('\0');
 166           
 167 mike  1.2     // Calculate the beginning of the content from the message size and
 168               // the content length.  Subtract 1 to take into account the null
 169               // character we just added to the end of the message.
 170           
 171               content = (Sint8*) httpMessage->message.getData() +
 172           	httpMessage->message.size() - contentLength - 1;
 173           
 174               //
 175               // If it is a method response, then dispatch it to be handled:
 176               //
 177           
 178               if (!String::equalNoCase(cimOperation, "MethodResponse"))
 179               {
 180           	// ATTN: error discarded at this time!
 181           	return;
 182               }
 183           
 184               _handleMethodResponse(content);
 185           }
 186           
 187           void CIMOperationResponseDecoder::_handleMethodResponse(char* content)
 188 mike  1.2 {
 189               Message* response = 0;
 190           
 191               //
 192               // Create and initialize XML parser:
 193               //
 194           
 195               XmlParser parser((char*)content);
 196               XmlEntry entry;
 197           
 198               try
 199               {
 200           	//
 201           	// Process <?xml ... >
 202           	//
 203           
 204           	XmlReader::expectXmlDeclaration(parser, entry);
 205           
 206           	//
 207           	// Process <CIM ... >
 208           	//
 209 mike  1.2 

 210 kumpf 1.9         const char* cimVersion = 0;
 211                   const char* dtdVersion = 0;
 212           
 213           	XmlReader::getCimStartTag(parser, cimVersion, dtdVersion);

 214 mike  1.2 
 215           	//
 216           	// Expect <MESSAGE ... >
 217           	//
 218           
 219           	String messageId;

 220 kumpf 1.9 	String protocolVersion;

 221 mike  1.2 
 222           	if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
 223           	    throw XmlValidationError(
 224           		parser.getLine(), "expected MESSAGE element");
 225           

 226 kumpf 1.9         if (!String::equalNoCase(protocolVersion, "1.0"))

 227 mike  1.2 	{
 228           	    // ATTN: protocol version being ignored at present!
 229           
 230           	    return;
 231           	}
 232           
 233           	//
 234           	// Expect <SIMPLERSP ... >
 235           	//
 236           
 237           	XmlReader::expectStartTag(parser, entry, "SIMPLERSP");
 238           
 239           	//
 240           	// Expect <IMETHODRESPONSE ... >
 241           	//
 242           
 243           	const char* iMethodResponseName = 0;
 244           
 245           	if (XmlReader::getIMethodResponseStartTag(parser, iMethodResponseName))
 246           	{
 247           	    //
 248 mike  1.2 	    // Dispatch the method:
 249           	    //
 250           
 251           	    if (EqualNoCase(iMethodResponseName, "GetClass"))
 252           		response = _decodeGetClassResponse(parser, messageId);
 253           	    else if (EqualNoCase(iMethodResponseName, "GetInstance"))
 254           		response = _decodeGetInstanceResponse(parser, messageId);
 255           	    else if (EqualNoCase(iMethodResponseName, "EnumerateClassNames"))
 256           		response = _decodeEnumerateClassNamesResponse(parser,messageId);
 257           	    else if (EqualNoCase(iMethodResponseName, "References"))
 258           		response = _decodeReferencesResponse(parser, messageId);
 259           	    else if (EqualNoCase(iMethodResponseName, "ReferenceNames"))
 260           		response = _decodeReferenceNamesResponse(parser, messageId);
 261           	    else if (EqualNoCase(iMethodResponseName, "AssociatorNames"))
 262           		response = _decodeAssociatorNamesResponse(parser, messageId);
 263           	    else if (EqualNoCase(iMethodResponseName, "Associators"))
 264           		response = _decodeAssociatorsResponse(parser, messageId);
 265           	    else if (EqualNoCase(iMethodResponseName, "CreateInstance"))
 266           		response = _decodeCreateInstanceResponse(parser, messageId);
 267           	    else if (EqualNoCase(iMethodResponseName,"EnumerateInstanceNames"))
 268           		response = _decodeEnumerateInstanceNamesResponse(
 269 mike  1.2                   parser, messageId);
 270           	    else if (EqualNoCase(iMethodResponseName,"EnumerateInstances"))
 271           		response = _decodeEnumerateInstancesResponse(parser, messageId);
 272           	    else if (EqualNoCase(iMethodResponseName, "GetProperty"))
 273           		response = _decodeGetPropertyResponse(parser, messageId);
 274           	    else if (EqualNoCase(iMethodResponseName, "SetProperty"))
 275           		response = _decodeSetPropertyResponse(parser, messageId);
 276           	    else if (EqualNoCase(iMethodResponseName, "DeleteQualifier"))
 277           		response = _decodeDeleteQualifierResponse(parser, messageId);
 278           	    else if (EqualNoCase(iMethodResponseName, "GetQualifier"))
 279           		response = _decodeGetQualifierResponse(parser, messageId);
 280           	    else if (EqualNoCase(iMethodResponseName, "SetQualifier"))
 281           		response = _decodeSetQualifierResponse(parser, messageId);
 282           	    else if (EqualNoCase(iMethodResponseName, "EnumerateQualifiers"))
 283           		response = _decodeEnumerateQualifiersResponse(parser,messageId);
 284           	    else if (EqualNoCase(iMethodResponseName, "EnumerateClasses"))
 285           		response = _decodeEnumerateClassesResponse(parser, messageId);
 286           	    else if (EqualNoCase(iMethodResponseName, "CreateClass"))
 287           		response = _decodeCreateClassResponse(parser, messageId);
 288           	    else if (EqualNoCase(iMethodResponseName, "ModifyClass"))
 289           		response = _decodeModifyClassResponse(parser, messageId);
 290 mike  1.2 	    else if (EqualNoCase(iMethodResponseName, "ModifyInstance"))
 291           		response = _decodeModifyInstanceResponse(parser, messageId);
 292           	    else if (EqualNoCase(iMethodResponseName, "DeleteClass"))
 293           		response = _decodeDeleteClassResponse(parser, messageId);
 294           	    else if (EqualNoCase(iMethodResponseName, "DeleteInstance"))
 295           		response = _decodeDeleteInstanceResponse(parser, messageId);
 296           	    else
 297           	    {
 298                           // Unrecognized IMethodResponse name attribute
 299           	        throw XmlValidationError(parser.getLine(),
 300           	            String("Unrecognized IMethodResponse name \"") +
 301                                   iMethodResponseName + "\"");
 302           	    }
 303           	
 304           	    //
 305           	    // Handle end tag:
 306           	    //
 307           
 308           	    XmlReader::expectEndTag(parser, "IMETHODRESPONSE");
 309           	}
 310           	else if (XmlReader::getMethodResponseStartTag(parser, 
 311 mike  1.2 	    iMethodResponseName))
 312           	{
 313           	    response = _decodeInvokeMethodResponse(
 314                         parser, messageId, iMethodResponseName);
 315           
 316           	    //
 317           	    // Handle end tag:
 318           	    //
 319           	    XmlReader::expectEndTag(parser, "METHODRESPONSE");
 320           	}
 321           	else
 322           	{
 323           	    throw XmlValidationError(parser.getLine(),
 324           	        "expected METHODRESPONSE or IMETHODRESPONSE element");
 325           	}
 326           
 327                   //
 328                   // Handle end tags:
 329                   //
 330           	XmlReader::expectEndTag(parser, "SIMPLERSP");
 331           	XmlReader::expectEndTag(parser, "MESSAGE");
 332 mike  1.2 	XmlReader::expectEndTag(parser, "CIM");
 333               }
 334               catch (Exception& x)
 335               {
 336           	// ATTN: ignore the exception for now!
 337           
 338           	cout << x.getMessage() << endl;
 339           	return;
 340               }
 341           
 342               _outputQueue->enqueue(response);
 343           }
 344           
 345           CIMCreateClassResponseMessage* CIMOperationResponseDecoder::_decodeCreateClassResponse(
 346               XmlParser& parser, 
 347               const String& messageId)
 348           {
 349               XmlEntry entry;
 350               CIMStatusCode code;
 351               const char* description = 0;
 352           
 353 mike  1.2     if (XmlReader::getErrorElement(parser, code, description))
 354               {
 355           	return(new CIMCreateClassResponseMessage(
 356           	    messageId,
 357           	    code,
 358           	    description,
 359           	    QueueIdStack()));
 360           
 361               }
 362               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 363               {
 364           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 365           
 366           	return(new CIMCreateClassResponseMessage(
 367           	    messageId,
 368           	    CIM_ERR_SUCCESS,
 369           	    String(),
 370           	    QueueIdStack()));
 371               }
 372               else
 373               {
 374 mike  1.2 	throw XmlValidationError(parser.getLine(),
 375           	    "expected ERROR or IRETURNVALUE element");
 376               }
 377           }
 378           
 379           CIMGetClassResponseMessage* CIMOperationResponseDecoder::_decodeGetClassResponse(
 380               XmlParser& parser, const String& messageId)
 381           {
 382               XmlEntry entry;
 383               CIMStatusCode code;
 384               const char* description = 0;
 385           
 386               if (XmlReader::getErrorElement(parser, code, description))
 387               {
 388           	return(new CIMGetClassResponseMessage(
 389           	    messageId,
 390           	    code,
 391           	    description,
 392           	    QueueIdStack(),
 393           	    CIMClass()));
 394               }
 395 mike  1.2     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 396               {
 397           	CIMClass cimClass;
 398           
 399           	if (!XmlReader::getClassElement(parser, cimClass))
 400           	    throw XmlValidationError(parser.getLine(),"expected CLASS element");
 401           
 402           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 403           
 404           	return(new CIMGetClassResponseMessage(
 405           	    messageId,
 406           	    CIM_ERR_SUCCESS,
 407           	    String(),
 408           	    QueueIdStack(),
 409           	    cimClass));
 410               }
 411               else
 412               {
 413           	throw XmlValidationError(parser.getLine(),
 414           	    "expected ERROR or IRETURNVALUE element");
 415               }
 416 mike  1.2 }
 417           
 418           CIMModifyClassResponseMessage* CIMOperationResponseDecoder::_decodeModifyClassResponse(
 419               XmlParser& parser, const String& messageId)
 420           {
 421               XmlEntry entry;
 422               CIMStatusCode code;
 423               const char* description = 0;
 424           
 425               if (XmlReader::getErrorElement(parser, code, description))
 426               {
 427           	return(new CIMModifyClassResponseMessage(
 428           	    messageId,
 429           	    code,
 430           	    description,
 431           	    QueueIdStack()));
 432               }
 433               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 434               {
 435           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 436           
 437 mike  1.2 	return(new CIMModifyClassResponseMessage(
 438           	    messageId,
 439           	    CIM_ERR_SUCCESS,
 440           	    String(),
 441           	    QueueIdStack()));
 442               }
 443               else
 444               {
 445           	throw XmlValidationError(parser.getLine(),
 446           	    "expected ERROR or IRETURNVALUE element");
 447               }
 448           }
 449           
 450           CIMEnumerateClassNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
 451               XmlParser& parser, const String& messageId)
 452           {
 453               XmlEntry entry;
 454               CIMStatusCode code;
 455               const char* description = 0;
 456           
 457               if (XmlReader::getErrorElement(parser, code, description))
 458 mike  1.2     {
 459           	return(new CIMEnumerateClassNamesResponseMessage(
 460           	    messageId,
 461           	    code,
 462           	    description,
 463           	    QueueIdStack(),
 464           	    Array<String>()));
 465               }
 466               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 467               {
 468           	Array<String> classNames;
 469           	String className;
 470           
 471           	while (XmlReader::getClassNameElement(parser, className, false))
 472           	    classNames.append(className);
 473           
 474           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 475           
 476           	return(new CIMEnumerateClassNamesResponseMessage(
 477           	    messageId,
 478           	    CIM_ERR_SUCCESS,
 479 mike  1.2 	    String(),
 480           	    QueueIdStack(),
 481           	    classNames));
 482               }
 483               else
 484               {
 485           	throw XmlValidationError(parser.getLine(),
 486           	    "expected ERROR or IRETURNVALUE element");
 487               }
 488           }
 489           
 490           CIMEnumerateClassesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
 491               XmlParser& parser, const String& messageId)
 492           {
 493               XmlEntry entry;
 494               CIMStatusCode code;
 495               const char* description = 0;
 496           
 497               if (XmlReader::getErrorElement(parser, code, description))
 498               {
 499           	return(new CIMEnumerateClassesResponseMessage(
 500 mike  1.2 	    messageId,
 501           	    code,
 502           	    description,
 503           	    QueueIdStack(),
 504           	    Array<CIMClass>()));
 505               }
 506               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 507               {
 508           	Array<CIMClass> cimClasses;
 509           	CIMClass cimClass;
 510           
 511           	while (XmlReader::getClassElement(parser, cimClass))
 512           	    cimClasses.append(cimClass);
 513           
 514           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 515           
 516           	return(new CIMEnumerateClassesResponseMessage(
 517           	    messageId,
 518           	    CIM_ERR_SUCCESS,
 519           	    String(),
 520           	    QueueIdStack(),
 521 mike  1.2 	    cimClasses));
 522               }
 523               else
 524               {
 525           	throw XmlValidationError(parser.getLine(),
 526           	    "expected ERROR or IRETURNVALUE element");
 527               }
 528           }
 529           
 530           CIMDeleteClassResponseMessage* CIMOperationResponseDecoder::_decodeDeleteClassResponse(
 531               XmlParser& parser, const String& messageId)
 532           {
 533               XmlEntry entry;
 534               CIMStatusCode code;
 535               const char* description = 0;
 536           
 537               if (XmlReader::getErrorElement(parser, code, description))
 538               {
 539           	return(new CIMDeleteClassResponseMessage(
 540           	    messageId,
 541           	    code,
 542 mike  1.2 	    description,
 543           	    QueueIdStack()));
 544               }
 545               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 546               {
 547           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 548           
 549           	return(new CIMDeleteClassResponseMessage(
 550           	    messageId,
 551           	    CIM_ERR_SUCCESS,
 552           	    String(),
 553           	    QueueIdStack()));
 554               }
 555               else
 556               {
 557           	throw XmlValidationError(parser.getLine(),
 558           	    "expected ERROR or IRETURNVALUE element");
 559               }
 560           }
 561           
 562           CIMCreateInstanceResponseMessage* CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
 563 mike  1.2     XmlParser& parser, const String& messageId)
 564           {
 565               XmlEntry entry;
 566               CIMStatusCode code;
 567               const char* description = 0;
 568           
 569               if (XmlReader::getErrorElement(parser, code, description))
 570               {
 571           	return(new CIMCreateInstanceResponseMessage(
 572           	    messageId,
 573           	    code,
 574           	    description,
 575           	    QueueIdStack(),
 576           	    CIMReference()));
 577               }
 578               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 579               {
 580           	CIMReference instanceName;
 581           	XmlReader::getInstanceNameElement(parser, instanceName);
 582           
 583           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 584 mike  1.2 
 585           	return(new CIMCreateInstanceResponseMessage(
 586           	    messageId,
 587           	    CIM_ERR_SUCCESS,
 588           	    String(),
 589           	    QueueIdStack(),
 590           	    instanceName));
 591               }
 592               else
 593               {
 594           	throw XmlValidationError(parser.getLine(),
 595           	    "expected ERROR or IRETURNVALUE element");
 596               }
 597           }
 598           
 599           CIMGetInstanceResponseMessage* CIMOperationResponseDecoder::_decodeGetInstanceResponse(
 600               XmlParser& parser, const String& messageId)
 601           {
 602               XmlEntry entry;
 603               CIMStatusCode code;
 604               const char* description = 0;
 605 mike  1.2 
 606               if (XmlReader::getErrorElement(parser, code, description))
 607               {
 608           	return(new CIMGetInstanceResponseMessage(
 609           	    messageId,
 610           	    code,
 611           	    description,
 612           	    QueueIdStack(),
 613           	    CIMInstance()));
 614               }
 615               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 616               {
 617           	CIMInstance cimInstance;
 618           
 619           	if (!XmlReader::getInstanceElement(parser, cimInstance))
 620           	{
 621           	    throw XmlValidationError(
 622           		parser.getLine(), "expected INSTANCE element");
 623           	}
 624           
 625           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 626 mike  1.2 
 627           	return(new CIMGetInstanceResponseMessage(
 628           	    messageId,
 629           	    CIM_ERR_SUCCESS,
 630           	    String(),
 631           	    QueueIdStack(),
 632           	    cimInstance));
 633               }
 634               else
 635               {
 636           	throw XmlValidationError(parser.getLine(),
 637           	    "expected ERROR or IRETURNVALUE element");
 638               }
 639           }
 640           
 641           CIMModifyInstanceResponseMessage* CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
 642               XmlParser& parser, const String& messageId)
 643           {
 644               XmlEntry entry;
 645               CIMStatusCode code;
 646               const char* description = 0;
 647 mike  1.2 
 648               if (XmlReader::getErrorElement(parser, code, description))
 649               {
 650           	return(new CIMModifyInstanceResponseMessage(
 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           	return(new CIMModifyInstanceResponseMessage(
 661           	    messageId,
 662           	    CIM_ERR_SUCCESS,
 663           	    String(),
 664           	    QueueIdStack()));
 665               }
 666               else
 667               {
 668 mike  1.2 	throw XmlValidationError(parser.getLine(),
 669           	    "expected ERROR or IRETURNVALUE element");
 670               }
 671           }
 672           
 673           CIMEnumerateInstanceNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
 674               XmlParser& parser, const String& messageId)
 675           {
 676               XmlEntry entry;
 677               CIMStatusCode code;
 678               const char* description = 0;
 679           
 680               if (XmlReader::getErrorElement(parser, code, description))
 681               {
 682           	return(new CIMEnumerateInstanceNamesResponseMessage(
 683           	    messageId,
 684           	    code,
 685           	    description,
 686           	    QueueIdStack(),
 687           	    Array<CIMReference>()));
 688               }
 689 mike  1.2     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 690               {
 691           	Array<CIMReference> instanceNames;
 692           	String className;
 693           	Array<KeyBinding> keyBindings;
 694           
 695           	while (XmlReader::getInstanceNameElement(
 696           	    parser, className, keyBindings))
 697           	{
 698           	    CIMReference r(
 699           		String::EMPTY,
 700           		String::EMPTY,
 701           		className,
 702           		keyBindings);
 703           	    instanceNames.append(r);
 704           	}
 705           
 706           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 707           
 708           	return(new CIMEnumerateInstanceNamesResponseMessage(
 709           	    messageId,
 710 mike  1.2 	    CIM_ERR_SUCCESS,
 711           	    String(),
 712           	    QueueIdStack(),
 713           	    instanceNames));
 714               }
 715               else
 716               {
 717           	throw XmlValidationError(parser.getLine(),
 718           	    "expected ERROR or IRETURNVALUE element");
 719               }
 720           }
 721           
 722           CIMEnumerateInstancesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(
 723               XmlParser& parser, const String& messageId)
 724           {
 725               XmlEntry entry;
 726               CIMStatusCode code;
 727               const char* description = 0;
 728           
 729               if (XmlReader::getErrorElement(parser, code, description))
 730               {
 731 mike  1.2 	return(new CIMEnumerateInstancesResponseMessage(
 732           	    messageId,
 733           	    code,
 734           	    description,
 735           	    QueueIdStack(),
 736           	    Array<CIMNamedInstance>()));
 737               }
 738               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 739               {
 740           	Array<CIMNamedInstance> namedInstances;
 741           	CIMNamedInstance tmp;
 742           
 743           	while (XmlReader::getNamedInstanceElement(parser, tmp))
 744           	    namedInstances.append(tmp);
 745           
 746           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 747           
 748           	return(new CIMEnumerateInstancesResponseMessage(
 749           	    messageId,
 750           	    CIM_ERR_SUCCESS,
 751           	    String(),
 752 mike  1.2 	    QueueIdStack(),
 753           	    namedInstances));
 754               }
 755               else
 756               {
 757           	throw XmlValidationError(parser.getLine(),
 758           	    "expected ERROR or IRETURNVALUE element");
 759               }
 760           }
 761           
 762           CIMDeleteInstanceResponseMessage* CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
 763               XmlParser& parser, const String& messageId)
 764           {
 765               XmlEntry entry;
 766               CIMStatusCode code;
 767               const char* description = 0;
 768           
 769               if (XmlReader::getErrorElement(parser, code, description))
 770               {
 771           	return(new CIMDeleteInstanceResponseMessage(
 772           	    messageId,
 773 mike  1.2 	    code,
 774           	    description,
 775           	    QueueIdStack()));
 776               }
 777               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 778               {
 779           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 780           
 781           	return(new CIMDeleteInstanceResponseMessage(
 782           	    messageId,
 783           	    CIM_ERR_SUCCESS,
 784           	    String(),
 785           	    QueueIdStack()));
 786               }
 787               else
 788               {
 789           	throw XmlValidationError(parser.getLine(),
 790           	    "expected ERROR or IRETURNVALUE element");
 791               }
 792           }
 793           
 794 mike  1.2 CIMGetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeGetPropertyResponse(
 795               XmlParser& parser, const String& messageId)
 796           {
 797               XmlEntry entry;
 798               CIMStatusCode code;
 799               const char* description = 0;
 800           
 801               if (XmlReader::getErrorElement(parser, code, description))
 802               {
 803           	return(new CIMGetPropertyResponseMessage(
 804           	    messageId,
 805           	    code,
 806           	    description,
 807           	    QueueIdStack(),
 808           	    CIMValue()));
 809               }
 810               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 811               {
 812           	CIMValue cimValue;
 813           
 814           	if (!XmlReader::getPropertyValue(parser, cimValue))
 815 mike  1.2 	{

 816 kumpf 1.7             // No value given; not much we can do but assume String value
 817                       cimValue.setNullValue(CIMType::STRING, false);

 818 mike  1.2 	}
 819           
 820           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 821           
 822           	return(new CIMGetPropertyResponseMessage(
 823           	    messageId,
 824           	    CIM_ERR_SUCCESS,
 825           	    String(),
 826           	    QueueIdStack(),
 827           	    cimValue));
 828               }
 829               else
 830               {
 831           	throw XmlValidationError(parser.getLine(),
 832           	    "expected ERROR or IRETURNVALUE element");
 833               }
 834           }
 835           
 836           CIMSetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeSetPropertyResponse(
 837               XmlParser& parser, const String& messageId)
 838           {
 839 mike  1.2     XmlEntry entry;
 840               CIMStatusCode code;
 841               const char* description = 0;
 842           
 843               if (XmlReader::getErrorElement(parser, code, description))
 844               {
 845           	return(new CIMSetPropertyResponseMessage(
 846           	    messageId,
 847           	    code,
 848           	    description,
 849           	    QueueIdStack()));
 850               }
 851               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 852               {
 853           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 854           
 855           	return(new CIMSetPropertyResponseMessage(
 856           	    messageId,
 857           	    CIM_ERR_SUCCESS,
 858           	    String(),
 859           	    QueueIdStack()));
 860 mike  1.2     }
 861               else
 862               {
 863           	throw XmlValidationError(parser.getLine(),
 864           	    "expected ERROR or IRETURNVALUE element");
 865               }
 866           }
 867           
 868           CIMSetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeSetQualifierResponse(
 869               XmlParser& parser, const String& messageId)
 870           {
 871               XmlEntry entry;
 872               CIMStatusCode code;
 873               const char* description = 0;
 874           
 875               if (XmlReader::getErrorElement(parser, code, description))
 876               {
 877           	return(new CIMSetQualifierResponseMessage(
 878           	    messageId,
 879           	    code,
 880           	    description,
 881 mike  1.2 	    QueueIdStack()));
 882               }
 883               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 884               {
 885           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 886           
 887           	return(new CIMSetQualifierResponseMessage(
 888           	    messageId,
 889           	    CIM_ERR_SUCCESS,
 890           	    String(),
 891           	    QueueIdStack()));
 892               }
 893               else
 894               {
 895           	throw XmlValidationError(parser.getLine(),
 896           	    "expected ERROR or IRETURNVALUE element");
 897               }
 898           }
 899           
 900           CIMGetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeGetQualifierResponse(
 901               XmlParser& parser, const String& messageId)
 902 mike  1.2 {
 903               XmlEntry entry;
 904               CIMStatusCode code;
 905               const char* description = 0;
 906           
 907               if (XmlReader::getErrorElement(parser, code, description))
 908               {
 909           	return(new CIMGetQualifierResponseMessage(
 910           	    messageId,
 911           	    code,
 912           	    description,
 913           	    QueueIdStack(),
 914           	    CIMQualifierDecl()));
 915               }
 916               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 917               {
 918           	CIMQualifierDecl qualifierDecl;
 919           	XmlReader::getQualifierDeclElement(parser, qualifierDecl);
 920           
 921           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 922           
 923 mike  1.2 	return(new CIMGetQualifierResponseMessage(
 924           	    messageId,
 925           	    CIM_ERR_SUCCESS,
 926           	    String(),
 927           	    QueueIdStack(),
 928           	    qualifierDecl));
 929               }
 930               else
 931               {
 932           	throw XmlValidationError(parser.getLine(),
 933           	    "expected ERROR or IRETURNVALUE element");
 934               }
 935           }
 936           
 937           CIMEnumerateQualifiersResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
 938               XmlParser& parser, const String& messageId)
 939           {
 940               XmlEntry entry;
 941               CIMStatusCode code;
 942               const char* description = 0;
 943           
 944 mike  1.2     if (XmlReader::getErrorElement(parser, code, description))
 945               {
 946           	return(new CIMEnumerateQualifiersResponseMessage(
 947           	    messageId,
 948           	    code,
 949           	    description,
 950           	    QueueIdStack(),
 951           	    Array<CIMQualifierDecl>()));
 952               }
 953               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 954               {
 955           	Array<CIMQualifierDecl> qualifierDecls;
 956           	CIMQualifierDecl qualifierDecl;
 957           
 958           	while (XmlReader::getQualifierDeclElement(parser, qualifierDecl))
 959           	    qualifierDecls.append(qualifierDecl);
 960           
 961           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 962           
 963           	return(new CIMEnumerateQualifiersResponseMessage(
 964           	    messageId,
 965 mike  1.2 	    CIM_ERR_SUCCESS,
 966           	    String(),
 967           	    QueueIdStack(),
 968           	    qualifierDecls));
 969               }
 970               else
 971               {
 972           	throw XmlValidationError(parser.getLine(),
 973           	    "expected ERROR or IRETURNVALUE element");
 974               }
 975           }
 976           
 977           CIMDeleteQualifierResponseMessage* CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
 978               XmlParser& parser, const String& messageId)
 979           {
 980               XmlEntry entry;
 981               CIMStatusCode code;
 982               const char* description = 0;
 983           
 984               if (XmlReader::getErrorElement(parser, code, description))
 985               {
 986 mike  1.2 	return(new CIMDeleteQualifierResponseMessage(
 987           	    messageId,
 988           	    code,
 989           	    description,
 990           	    QueueIdStack()));
 991               }
 992               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
 993               {
 994           	XmlReader::testEndTag(parser, "IRETURNVALUE");
 995           
 996           	return(new CIMDeleteQualifierResponseMessage(
 997           	    messageId,
 998           	    CIM_ERR_SUCCESS,
 999           	    String(),
1000           	    QueueIdStack()));
1001               }
1002               else
1003               {
1004           	throw XmlValidationError(parser.getLine(),
1005           	    "expected ERROR or IRETURNVALUE element");
1006               }
1007 mike  1.2 }
1008           
1009           //MEB:
1010           
1011           CIMReferenceNamesResponseMessage* CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
1012               XmlParser& parser, const String& messageId)
1013           {
1014               XmlEntry entry;
1015               CIMStatusCode code;
1016               const char* description = 0;
1017           
1018               if (XmlReader::getErrorElement(parser, code, description))
1019               {
1020           	return(new CIMReferenceNamesResponseMessage(
1021           	    messageId,
1022           	    code,
1023           	    description,
1024           	    QueueIdStack(),
1025           	    Array<CIMReference>()));
1026               }
1027               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1028 mike  1.2     {
1029           	CIMReference objectPath;
1030           	Array<CIMReference> objectPaths;
1031           
1032           	while (XmlReader::getObjectPathElement(parser, objectPath))
1033           	    objectPaths.append(objectPath);
1034           
1035           	XmlReader::testEndTag(parser, "IRETURNVALUE");
1036           
1037           	return(new CIMReferenceNamesResponseMessage(
1038           	    messageId,
1039           	    CIM_ERR_SUCCESS,
1040           	    String(),
1041           	    QueueIdStack(),
1042           	    objectPaths));
1043               }
1044               else
1045               {
1046           	throw XmlValidationError(parser.getLine(),
1047           	    "expected ERROR or IRETURNVALUE element");
1048               }
1049 mike  1.2 }
1050           
1051           CIMReferencesResponseMessage* CIMOperationResponseDecoder::_decodeReferencesResponse(
1052               XmlParser& parser, const String& messageId)
1053           {
1054               XmlEntry entry;
1055               CIMStatusCode code;
1056               const char* description = 0;
1057           
1058               if (XmlReader::getErrorElement(parser, code, description))
1059               {
1060           	return(new CIMReferencesResponseMessage(
1061           	    messageId,
1062           	    code,
1063           	    description,
1064           	    QueueIdStack(),
1065           	    Array<CIMObjectWithPath>()));
1066               }
1067               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1068               {
1069           	Array<CIMObjectWithPath> objectWithPathArray;
1070 mike  1.2 	CIMObjectWithPath tmp;
1071           
1072           	while (XmlReader::getObjectWithPath(parser, tmp))
1073           	    objectWithPathArray.append(tmp);
1074           
1075           	XmlReader::testEndTag(parser, "IRETURNVALUE");
1076           
1077           	return(new CIMReferencesResponseMessage(
1078           	    messageId,
1079           	    CIM_ERR_SUCCESS,
1080           	    String(),
1081           	    QueueIdStack(),
1082           	    objectWithPathArray));
1083               }
1084               else
1085               {
1086           	throw XmlValidationError(parser.getLine(),
1087           	    "expected ERROR or IRETURNVALUE element");
1088               }
1089           }
1090           
1091 mike  1.2 CIMAssociatorNamesResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
1092               XmlParser& parser, const String& messageId)
1093           {
1094               XmlEntry entry;
1095               CIMStatusCode code;
1096               const char* description = 0;
1097           
1098               if (XmlReader::getErrorElement(parser, code, description))
1099               {
1100           	return(new CIMAssociatorNamesResponseMessage(
1101           	    messageId,
1102           	    code,
1103           	    description,
1104           	    QueueIdStack(),
1105           	    Array<CIMReference>()));
1106               }
1107               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1108               {
1109           	CIMReference objectPath;
1110           	Array<CIMReference> objectPaths;
1111           
1112 mike  1.2 	while (XmlReader::getObjectPathElement(parser, objectPath))
1113           	    objectPaths.append(objectPath);
1114           
1115           	XmlReader::testEndTag(parser, "IRETURNVALUE");
1116           
1117           	return(new CIMAssociatorNamesResponseMessage(
1118           	    messageId,
1119           	    CIM_ERR_SUCCESS,
1120           	    String(),
1121           	    QueueIdStack(),
1122           	    objectPaths));
1123               }
1124               else
1125               {
1126           	throw XmlValidationError(parser.getLine(),
1127           	    "expected ERROR or IRETURNVALUE element");
1128               }
1129           }
1130           
1131           CIMAssociatorsResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorsResponse(
1132               XmlParser& parser, const String& messageId)
1133 mike  1.2 {
1134               XmlEntry entry;
1135               CIMStatusCode code;
1136               const char* description = 0;
1137           
1138               if (XmlReader::getErrorElement(parser, code, description))
1139               {
1140           	return(new CIMAssociatorsResponseMessage(
1141           	    messageId,
1142           	    code,
1143           	    description,
1144           	    QueueIdStack(),
1145           	    Array<CIMObjectWithPath>()));
1146               }
1147               else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1148               {
1149           	Array<CIMObjectWithPath> objectWithPathArray;
1150           	CIMObjectWithPath tmp;
1151           
1152           	while (XmlReader::getObjectWithPath(parser, tmp))
1153           	    objectWithPathArray.append(tmp);
1154 mike  1.2 
1155           	XmlReader::testEndTag(parser, "IRETURNVALUE");
1156           
1157           	return(new CIMAssociatorsResponseMessage(
1158           	    messageId,
1159           	    CIM_ERR_SUCCESS,
1160           	    String(),
1161           	    QueueIdStack(),
1162           	    objectWithPathArray));
1163               }
1164               else
1165               {
1166           	throw XmlValidationError(parser.getLine(),
1167           	    "expected ERROR or IRETURNVALUE element");
1168               }
1169           }
1170           
1171           CIMInvokeMethodResponseMessage* CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
1172               XmlParser& parser, const String& messageId, const String& methodName)
1173           {
1174               XmlEntry entry;
1175 mike  1.2     CIMStatusCode code;
1176               const char* description = 0;
1177           

1178 kumpf 1.5     CIMParamValue paramValue;
1179               Array<CIMParamValue> outParameters;

1180 kumpf 1.6     CIMValue returnValue;

1181 mike  1.2     const char* paramName;
1182               String inValue;
1183           
1184               if (XmlReader::getErrorElement(parser, code, description))
1185               {
1186           	return(new CIMInvokeMethodResponseMessage(
1187           	    messageId,
1188           	    code,
1189           	    description,
1190           	    QueueIdStack(),

1191 kumpf 1.6 	    returnValue,

1192 mike  1.2 	    outParameters,
1193           	    methodName));
1194               }

1195 kumpf 1.4     else

1196 mike  1.2     {

1197 kumpf 1.4         Boolean isReturnValue = false;
1198                   Boolean isParamValue = false;
1199                   Boolean gotReturnValue = false;
1200           
1201                   while ((isReturnValue =

1202 kumpf 1.6                     XmlReader::getReturnValueElement(parser, returnValue)) ||

1203 kumpf 1.5                (isParamValue =
1204           		    XmlReader::getParamValueElement(parser, paramValue)))

1205 kumpf 1.4         {
1206                       if (isReturnValue)
1207                       {
1208                           if (gotReturnValue)
1209                           {
1210           	            throw XmlValidationError(parser.getLine(),
1211           	                "unexpected RETURNVALUE element");
1212                           }
1213                           gotReturnValue = true;
1214                       }
1215                       else    // isParamValue == true
1216                       {

1217 kumpf 1.5 	        outParameters.append(paramValue);

1218 kumpf 1.4             }
1219           
1220                       isReturnValue = false;
1221                       isParamValue = false;
1222                   }
1223           
1224                   if (!gotReturnValue)
1225                   {
1226                       throw XmlValidationError(parser.getLine(),
1227                           "expected ERROR or RETURNVALUE element");
1228                   }

1229 mike  1.2 
1230           	return(new CIMInvokeMethodResponseMessage(
1231           	    messageId,
1232           	    CIM_ERR_SUCCESS,
1233           	    String(),
1234           	    QueueIdStack(),

1235 kumpf 1.6 	    returnValue,

1236 mike  1.2 	    outParameters,
1237           	    methodName));
1238               }
1239           }
1240           
1241           PEGASUS_NAMESPACE_END