(file) Return to CIMOperationResponseDecoder.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Client

   1 karl  1.74 //%2006////////////////////////////////////////////////////////////////////////
   2 mike  1.2  //
   3 karl  1.61 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   4            // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   5            // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   6 karl  1.51 // IBM Corp.; EMC Corporation, The Open Group.
   7 karl  1.61 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   8            // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   9 karl  1.65 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
  10            // EMC Corporation; VERITAS Software Corporation; The Open Group.
  11 karl  1.74 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
  12            // EMC Corporation; Symantec Corporation; The Open Group.
  13 mike  1.2  //
  14            // Permission is hereby granted, free of charge, to any person obtaining a copy
  15            // of this software and associated documentation files (the "Software"), to
  16            // deal in the Software without restriction, including without limitation the
  17            // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  18            // sell copies of the Software, and to permit persons to whom the Software is
  19            // furnished to do so, subject to the following conditions:
  20 kumpf 1.25 // 
  21 mike  1.2  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
  22            // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
  23            // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
  24            // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  25            // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  26            // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  27            // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28            // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29            //
  30            //==============================================================================
  31            //
  32            //%/////////////////////////////////////////////////////////////////////////////
  33            
  34            #include <Pegasus/Common/Config.h>
  35            #include <iostream>
  36 kumpf 1.15 #include <Pegasus/Common/Constants.h>
  37 mike  1.2  #include <Pegasus/Common/XmlParser.h>
  38            #include <Pegasus/Common/XmlReader.h>
  39            #include <Pegasus/Common/System.h>
  40            #include <Pegasus/Common/XmlWriter.h>
  41            #include <Pegasus/Common/HTTPMessage.h>
  42            #include <Pegasus/Common/CIMMessage.h>
  43 kumpf 1.60 #include <Pegasus/Common/Exception.h>
  44 mike  1.2  #include "CIMOperationResponseDecoder.h"
  45            
  46 kumpf 1.76 #include <Pegasus/Common/MessageLoader.h>
  47 humberto 1.43 
  48 mike     1.2  PEGASUS_USING_STD;
  49               
  50               PEGASUS_NAMESPACE_BEGIN
  51               
  52               CIMOperationResponseDecoder::CIMOperationResponseDecoder(
  53                   MessageQueue* outputQueue,
  54                   MessageQueue* encoderQueue,
  55 karl     1.41     ClientAuthenticator* authenticator,
  56                   Uint32 showInput)
  57 mike     1.2      :
  58 kumpf    1.16     MessageQueue(PEGASUS_QUEUENAME_OPRESPDECODER),
  59 mike     1.2      _outputQueue(outputQueue),
  60                   _encoderQueue(encoderQueue),
  61 karl     1.41     _authenticator(authenticator),
  62                   _showInput(showInput)
  63 mike     1.2  {
  64               }
  65               
  66               CIMOperationResponseDecoder::~CIMOperationResponseDecoder()
  67               {
  68               }
  69               
  70               void  CIMOperationResponseDecoder::setEncoderQueue(MessageQueue* encoderQueue)
  71               {
  72                   _encoderQueue = encoderQueue;
  73               }
  74               
  75               void CIMOperationResponseDecoder::handleEnqueue()
  76               {
  77                   Message* message = dequeue();
  78               
  79                   if (!message)
  80 kumpf    1.60         return;
  81 mike     1.2  
  82                   switch (message->getType())
  83                   {
  84 kumpf    1.60         case HTTP_MESSAGE:
  85                       {
  86                           HTTPMessage* httpMessage = (HTTPMessage*)message;
  87                           _handleHTTPMessage(httpMessage);
  88                           break;
  89                       }
  90 mike     1.2  
  91 kumpf    1.60         default:
  92 kumpf    1.17             PEGASUS_ASSERT(0);
  93 kumpf    1.60             break;
  94 mike     1.2      }
  95               
  96                   delete message;
  97               }
  98               
  99 a.dunfey 1.73 void CIMOperationResponseDecoder::setDataStorePointer(
 100                   ClientPerfDataStore* perfDataStore_ptr)
 101               {   dataStore = perfDataStore_ptr;
 102               }
 103               
 104 mike     1.2  void CIMOperationResponseDecoder::_handleHTTPMessage(HTTPMessage* httpMessage)
 105               {
 106                   //
 107                   // Parse the HTTP message:
 108                   //
 109 w.white  1.67     TimeValue networkEndTime = TimeValue::getCurrentTime();
 110 w.white  1.64 
 111 j.alex   1.68     String  connectClose;
 112                   String  startLine;
 113 mike     1.2      Array<HTTPHeader> headers;
 114 j.alex   1.68     char*   content;
 115                   Uint32  contentLength;
 116                   Boolean cimReconnect=false;
 117 mike     1.2  
 118 kumpf    1.19     if (httpMessage->message.size() == 0)
 119 kumpf    1.60     {
 120 kumpf    1.76         MessageLoaderParms mlParms(
 121                           "Client.CIMOperationResponseDecoder.EMPTY_RESPONSE",
 122                           "Empty HTTP response message.");
 123 kumpf    1.60         String mlString(MessageLoader::getMessage(mlParms));
 124               
 125                       CIMClientMalformedHTTPException* malformedHTTPException =
 126                           new CIMClientMalformedHTTPException(mlString);
 127               
 128                       ClientExceptionMessage * response =
 129                           new ClientExceptionMessage(malformedHTTPException);
 130               
 131                       _outputQueue->enqueue(response);
 132                       return;
 133                   }
 134 kumpf    1.19 
 135 j.alex   1.68 
 136 mike     1.2      httpMessage->parse(startLine, headers, contentLength);
 137               
 138 kumpf    1.19     //
 139 kumpf    1.76     // Check for Connection: Close
 140 j.alex   1.68     //
 141 j.alex   1.69     if (HTTPMessage::lookupHeader(headers, "Connection", connectClose, false))
 142 j.alex   1.68     {
 143                       if (String::equalNoCase(connectClose, "Close"))
 144                       {
 145                           //reconnect and then resend next request.
 146                           cimReconnect=true;
 147                       }
 148                   }
 149                   //
 150 kumpf    1.19     // Get the status line info
 151                   //
 152                   String httpVersion;
 153                   Uint32 statusCode;
 154                   String reasonPhrase;
 155               
 156                   Boolean parsableMessage = HTTPMessage::parseStatusLine(
 157                       startLine, httpVersion, statusCode, reasonPhrase);
 158                   if (!parsableMessage)
 159                   {
 160 kumpf    1.76         MessageLoaderParms mlParms(
 161                           "Client.CIMOperationResponseDecoder.MALFORMED_RESPONSE",
 162                           "Malformed HTTP response message.");
 163 kumpf    1.60         String mlString(MessageLoader::getMessage(mlParms));
 164               
 165                       CIMClientMalformedHTTPException* malformedHTTPException =
 166                           new CIMClientMalformedHTTPException(mlString);
 167 kumpf    1.19 
 168 kumpf    1.60         ClientExceptionMessage * response =
 169                           new ClientExceptionMessage(malformedHTTPException);
 170 kumpf    1.76 
 171 j.alex   1.68         response->setCloseConnect(cimReconnect);
 172 humberto 1.43 
 173 kumpf    1.60         _outputQueue->enqueue(response);
 174                       return;
 175 kumpf    1.19     }
 176               
 177 karl     1.41 #ifdef PEGASUS_CLIENT_TRACE_ENABLE
 178                   if (_showInput & 1)
 179                   {
 180                       cout << "CIMOperatonResponseDecoder";
 181                       httpMessage->printAll(cout);
 182                   }
 183                   if (_showInput & 2)
 184                   {
 185                       Uint32 size = httpMessage->message.size();
 186                       char* tmpBuf = new char[size+1];
 187               
 188                       strncpy( tmpBuf, httpMessage->message.getData(), size );
 189                       tmpBuf[size] = '\0';
 190                       Logger::put(Logger::STANDARD_LOG,
 191 yi.zhou  1.75             System::CIMSERVER,
 192 kumpf    1.60             Logger::TRACE,
 193                           "CIMOperationRequestDecoder::Response, XML content: $1",
 194                           tmpBuf);
 195 karl     1.41         delete []tmpBuf;
 196                   }
 197               #endif
 198               
 199 kumpf    1.8      try
 200 mike     1.2      {
 201 kumpf    1.8          if (_authenticator->checkResponseHeaderForChallenge(headers))
 202                       {
 203                           //
 204                           // Get the original request, put that in the encoder's queue for
 205                           // re-sending with authentication challenge response.
 206                           //
 207 kumpf    1.70             Message* reqMessage = _authenticator->releaseRequestMessage();
 208               
 209 j.alex   1.69             if (cimReconnect == true)
 210                           {
 211 kumpf    1.70                 reqMessage->setCloseConnect(cimReconnect);
 212 j.alex   1.69                 _outputQueue->enqueue(reqMessage);
 213 kumpf    1.76             }
 214                           else
 215 j.alex   1.69             {
 216                               _encoderQueue->enqueue(reqMessage);
 217                           }
 218 mike     1.2  
 219 kumpf    1.8              return;
 220                       }
 221                       else
 222                       {
 223                           //
 224                           // Received a valid/error response from the server.
 225 kumpf    1.76             // We do not need the original request message anymore, hence
 226                           // delete the request message by getting the handle from the
 227                           // ClientAuthenticator.
 228 kumpf    1.8              //
 229 kumpf    1.70             Message* reqMessage = _authenticator->releaseRequestMessage();
 230                           delete reqMessage;
 231 kumpf    1.8          }
 232 mike     1.2      }
 233 kumpf    1.76     catch (InvalidAuthHeader& e)
 234 mike     1.2      {
 235 kumpf    1.20         CIMClientMalformedHTTPException* malformedHTTPException =
 236                           new CIMClientMalformedHTTPException(e.getMessage());
 237 kumpf    1.17         ClientExceptionMessage * response =
 238                           new ClientExceptionMessage(malformedHTTPException);
 239 mike     1.2  
 240 j.alex   1.68         response->setCloseConnect(cimReconnect);
 241 kumpf    1.17         _outputQueue->enqueue(response);
 242 kumpf    1.15         return;
 243                   }
 244 kumpf    1.36 
 245 kumpf    1.52     // We have the response.  If authentication failed, we will generate a
 246                   // CIMClientHTTPErrorException below with the "401 Unauthorized" status
 247                   // in the (re-challenge) response.
 248 kumpf    1.15 
 249                   //
 250                   // Check for a success (200 OK) response
 251                   //
 252 kumpf    1.17     if (statusCode != HTTP_STATUSCODE_OK)
 253 kumpf    1.15     {
 254                       String cimError;
 255                       String pegasusError;
 256               
 257 brian.campbell 1.57         HTTPMessage::lookupHeader(headers, "CIMError", cimError, true);
 258 kumpf          1.76         HTTPMessage::lookupHeader(
 259                                 headers, PEGASUS_HTTPHEADERTAG_ERRORDETAIL, pegasusError);
 260 kumpf          1.35         try
 261                             {
 262                                 pegasusError = XmlReader::decodeURICharacters(pegasusError);
 263                             }
 264 brian.campbell 1.57         catch (ParseError&)
 265 kumpf          1.35         {
 266                                 // Ignore this exception.  We're more interested in having the
 267                                 // message in encoded form than knowing that the format is invalid.
 268                             }
 269 kumpf          1.15 
 270 kumpf          1.32         CIMClientHTTPErrorException* httpError =
 271 kumpf          1.54             new CIMClientHTTPErrorException(statusCode, reasonPhrase,
 272                                                                 cimError, pegasusError);
 273 kumpf          1.17         ClientExceptionMessage * response =
 274                                 new ClientExceptionMessage(httpError);
 275 kumpf          1.15 
 276 j.alex         1.68         response->setCloseConnect(cimReconnect);
 277 kumpf          1.15         _outputQueue->enqueue(response);
 278 kumpf          1.8          return;
 279 mike           1.2      }
 280                     
 281                         //
 282                         // Search for "CIMOperation" header:
 283                         //
 284                         String cimOperation;
 285                     
 286                         if (!HTTPMessage::lookupHeader(
 287 kumpf          1.60         headers, "CIMOperation", cimOperation, true))
 288 mike           1.2      {
 289 kumpf          1.76         MessageLoaderParms mlParms(
 290                                 "Client.CIMOperationResponseDecoder.MISSING_CIMOP_HEADER",
 291                                 "Missing CIMOperation HTTP header");
 292                             String mlString(MessageLoader::getMessage(mlParms));
 293 humberto       1.43 
 294 kumpf          1.76         CIMClientMalformedHTTPException* malformedHTTPException =
 295                                 new CIMClientMalformedHTTPException(mlString);
 296 kumpf          1.60 
 297 kumpf          1.17         ClientExceptionMessage * response =
 298                                 new ClientExceptionMessage(malformedHTTPException);
 299                     
 300 j.alex         1.68         response->setCloseConnect(cimReconnect);
 301                     
 302 kumpf          1.17         _outputQueue->enqueue(response);
 303                             return;
 304 mike           1.2      }
 305                     
 306 david          1.42     //
 307                         // Search for "Content-Type" header:
 308                         //
 309 kumpf          1.60 
 310                         // BUG 572, Use of Content-Type header and change error msg.
 311                         // If header exists, test type.  If not, ignore. We will find
 312                         // content type errors in text analysis.
 313                         // content-type header  value format:
 314                         //              type "/" subtype *( ";" parameter )
 315                         // ex. text/xml;Charset="utf8"
 316                         String cimContentType;
 317                     
 318                         if (HTTPMessage::lookupHeader(
 319                                 headers, "Content-Type", cimContentType, true))
 320                         {
 321                             Uint32 len;
 322                             String contentTypeValue;
 323                             if ((len = cimContentType.find(';')) != PEG_NOT_FOUND)
 324                                 contentTypeValue = cimContentType.subString(0,len);
 325                             else
 326                                 contentTypeValue = cimContentType;
 327                     
 328                             if (!String::equalNoCase(contentTypeValue, "text/xml") &&
 329                                 !String::equalNoCase(contentTypeValue, "application/xml"))
 330 kumpf          1.60         {
 331                                 CIMClientMalformedHTTPException* malformedHTTPException = new
 332                                     CIMClientMalformedHTTPException
 333                                         ("Bad Content-Type HTTP header; " + contentTypeValue);
 334                                 ClientExceptionMessage * response =
 335                                     new ClientExceptionMessage(malformedHTTPException);
 336                     
 337 j.alex         1.68             response->setCloseConnect(cimReconnect);
 338                     
 339 kumpf          1.60             _outputQueue->enqueue(response);
 340                                 return;
 341                             }
 342                         }
 343                         // comment out the error rejection code if the content-type header does
 344                         //    not exist
 345 karl           1.48 #ifdef PEGASUS_REJECT_ON_MISSING_CONTENTTYPE_HEADER
 346 kumpf          1.60     else
 347                         {
 348                             CIMClientMalformedHTTPException* malformedHTTPException = new
 349                                 CIMClientMalformedHTTPException
 350                                     ("Missing Content-Type HTTP header; ");
 351                             ClientExceptionMessage * response =
 352                                 new ClientExceptionMessage(malformedHTTPException);
 353                     
 354 j.alex         1.68         response->setCloseConnect(cimReconnect);
 355                     
 356 kumpf          1.60         _outputQueue->enqueue(response);
 357                             return;
 358                         }
 359 karl           1.48 #endif
 360 kumpf          1.60 
 361                         // look for any cim status codes. The HTTPConnection level would have
 362                         // added them here.
 363                     
 364                         String cimStatusCodeValue;
 365                         Boolean found = HTTPMessage::lookupHeader(headers, "CIMStatusCode",
 366                             cimStatusCodeValue, true);
 367                         CIMStatusCode cimStatusCodeNumber = CIM_ERR_SUCCESS;
 368                     
 369                         if (found == true &&
 370                             (cimStatusCodeNumber = (CIMStatusCode)
 371                              atoi(cimStatusCodeValue.getCString())) != CIM_ERR_SUCCESS)
 372                         {
 373                             String cimStatusCodeDescription;
 374                             found = HTTPMessage::lookupHeader(headers, "CIMStatusCodeDescription",
 375                                 cimStatusCodeDescription, true);
 376                             if (found == true && cimStatusCodeDescription.size() > 0)
 377                             {
 378                                 try
 379                                 {
 380                                     cimStatusCodeDescription =
 381 kumpf          1.60                     XmlReader::decodeURICharacters(cimStatusCodeDescription);
 382                                 }
 383                                 catch (ParseError&)
 384                                 {
 385                                 }
 386                             } // if there is a description with the code
 387                     
 388                             CIMException* cimStatusException =
 389                                 new CIMException(cimStatusCodeNumber,cimStatusCodeDescription);
 390 brian.campbell 1.62         cimStatusException->setContentLanguages(httpMessage->contentLanguages);
 391 kumpf          1.60         ClientExceptionMessage * response =
 392                                 new ClientExceptionMessage(cimStatusException);
 393 kumpf          1.76 
 394 j.alex         1.68         response->setCloseConnect(cimReconnect);
 395                     
 396 kumpf          1.60         _outputQueue->enqueue(response);
 397                             return;
 398                         }
 399 w.white        1.64     String serverTime;
 400 kumpf          1.76     if (HTTPMessage::lookupHeader(
 401                                 headers, "WBEMServerResponseTime", serverTime, true))
 402 w.white        1.64     {
 403                             Uint32 sTime = (Uint32) atol(serverTime.getCString());
 404                             dataStore->setServerTime(sTime);
 405                         }
 406                     
 407 brian.campbell 1.59 
 408 mike           1.2      //
 409                         // Zero-terminate the message:
 410                         //
 411                         httpMessage->message.append('\0');
 412 keith.petley   1.40 
 413 mike           1.2      // Calculate the beginning of the content from the message size and
 414                         // the content length.  Subtract 1 to take into account the null
 415                         // character we just added to the end of the message.
 416                     
 417 david.dillard  1.63     content = (char *) httpMessage->message.getData() +
 418 karl           1.41         httpMessage->message.size() - contentLength - 1;
 419 mike           1.2  
 420                         //
 421                         // If it is a method response, then dispatch it to be handled:
 422                         //
 423                     
 424                         if (!String::equalNoCase(cimOperation, "MethodResponse"))
 425                         {
 426 kumpf          1.76         MessageLoaderParms mlParms(
 427                                 "Client.CIMOperationResponseDecoder.EXPECTED_METHODRESPONSE",
 428                                 "Received CIMOperation HTTP header value \"$1\", expected "
 429                                     "\"MethodResponse\"",
 430                                 cimOperation);
 431 kumpf          1.60         String mlString(MessageLoader::getMessage(mlParms));
 432 humberto       1.43 
 433 kumpf          1.60         CIMClientMalformedHTTPException* malformedHTTPException =
 434                                 new CIMClientMalformedHTTPException(mlString);
 435 humberto       1.43 
 436 kumpf          1.60         ClientExceptionMessage * response =
 437                                 new ClientExceptionMessage(malformedHTTPException);
 438 kumpf          1.17 
 439 j.alex         1.68         response->setCloseConnect(cimReconnect);
 440                     
 441 kumpf          1.17         _outputQueue->enqueue(response);
 442                             return;
 443 mike           1.2      }
 444                     
 445 w.white        1.64     dataStore->setResponseSize(contentLength);
 446                         dataStore->setEndNetworkTime(networkEndTime);
 447 kumpf          1.76     _handleMethodResponse(content, httpMessage->contentLanguages,cimReconnect);
 448 mike           1.2  }
 449                     
 450 j.alex         1.68 void CIMOperationResponseDecoder::_handleMethodResponse(
 451                         char* content,
 452 kumpf          1.72     const ContentLanguageList& contentLanguages,
 453 kumpf          1.76     Boolean cimReconnect)
 454 mike           1.2  {
 455                         Message* response = 0;
 456                     
 457                         //
 458                         // Create and initialize XML parser:
 459                         //
 460                     
 461                         XmlParser parser((char*)content);
 462                         XmlEntry entry;
 463                     
 464                         try
 465                         {
 466 kumpf          1.60         //
 467                             // Process <?xml ... >
 468                             //
 469 mike           1.2  
 470 kumpf          1.11         const char* xmlVersion = 0;
 471                             const char* xmlEncoding = 0;
 472                     
 473 kumpf          1.60         XmlReader::getXmlDeclaration(parser, xmlVersion, xmlEncoding);
 474 mike           1.2  
 475 kumpf          1.60         //
 476                             // Process <CIM ... >
 477                             //
 478 mike           1.2  
 479 kumpf          1.9          const char* cimVersion = 0;
 480                             const char* dtdVersion = 0;
 481                     
 482 kumpf          1.17         // ATTN-RK-P3-20020416: Need to validate these versions?
 483 kumpf          1.60         XmlReader::getCimStartTag(parser, cimVersion, dtdVersion);
 484 mike           1.2  
 485 kumpf          1.60         //
 486                             // Expect <MESSAGE ... >
 487                             //
 488 mike           1.2  
 489 kumpf          1.60         String messageId;
 490                             String protocolVersion;
 491 mike           1.2  
 492 kumpf          1.60         if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
 493                             {
 494 kumpf          1.76             MessageLoaderParms mlParms(
 495                                     "Client.CIMOperationResponseDecoder.EXPECTED_MESSAGE_ELEMENT",
 496 kumpf          1.60                 "expected MESSAGE element");
 497                                 throw XmlValidationError(parser.getLine(), mlParms);
 498                             }
 499 humberto       1.43 
 500 mike           1.2  
 501 david.dillard  1.71         //
 502 kumpf          1.76         // This code for checking the protocol version was taken from the
 503                             // server code.
 504 david.dillard  1.71         //
 505                             Boolean protocolVersionAccepted = false;
 506                     
 507                             if ((protocolVersion.size() >= 3) &&
 508                                (protocolVersion[0] == '1') &&
 509                                (protocolVersion[1] == '.'))
 510                             {
 511                                // Verify that all characters after the '.' are digits
 512                                Uint32 index = 2;
 513                                while ((index < protocolVersion.size()) &&
 514                                       (protocolVersion[index] >= '0') &&
 515                                       (protocolVersion[index] <= '9'))
 516                                {
 517                                   index++;
 518                                }
 519                     
 520                                if (index == protocolVersion.size())
 521                                {
 522                                   protocolVersionAccepted = true;
 523                                }
 524                             }
 525 humberto       1.43 
 526 david.dillard  1.71         if (!protocolVersionAccepted)
 527                             {
 528 kumpf          1.76             MessageLoaderParms mlParms(
 529                                     "Client.CIMOperationResponseDecoder.UNSUPPORTED_PROTOCOL",
 530                                     "Received unsupported protocol version \"$0\", expected "
 531                                         "\"$1\"",
 532                                     protocolVersion,
 533                                     "1.[0-9]+");
 534 kumpf          1.60             String mlString(MessageLoader::getMessage(mlParms));
 535 humberto       1.43 
 536 kumpf          1.60             CIMClientResponseException* responseException =
 537                                     new CIMClientResponseException(mlString);
 538 humberto       1.43 
 539 kumpf          1.17             ClientExceptionMessage * response =
 540                                     new ClientExceptionMessage(responseException);
 541 mike           1.2  
 542 j.alex         1.68             response->setCloseConnect(cimReconnect);
 543                     
 544 kumpf          1.17             _outputQueue->enqueue(response);
 545                                 return;
 546 kumpf          1.60         }
 547                     
 548                             //
 549                             // Expect <SIMPLERSP ... >
 550                             //
 551                     
 552                             XmlReader::expectStartTag(parser, entry, "SIMPLERSP");
 553                     
 554                             //
 555                             // Expect <IMETHODRESPONSE ... >
 556                             //
 557 mike           1.2  
 558 kumpf          1.60         const char* iMethodResponseName = 0;
 559                             Boolean isEmptyTag = false;
 560 humberto       1.43 
 561 kumpf          1.60         if (XmlReader::getIMethodResponseStartTag(
 562                                     parser, iMethodResponseName, isEmptyTag))
 563                             {
 564                                 //
 565                                 // Dispatch the method:
 566                                 //
 567                     
 568                                 if (System::strcasecmp(iMethodResponseName, "GetClass") == 0)
 569                                     response = _decodeGetClassResponse(
 570                                         parser, messageId, isEmptyTag);
 571 kumpf          1.76             else if (System::strcasecmp(
 572                                              iMethodResponseName, "GetInstance") == 0)
 573 kumpf          1.60                 response = _decodeGetInstanceResponse(
 574                                         parser, messageId, isEmptyTag);
 575 kumpf          1.76             else if (System::strcasecmp(
 576                                              iMethodResponseName, "EnumerateClassNames") == 0)
 577 kumpf          1.60                 response = _decodeEnumerateClassNamesResponse(
 578                                         parser, messageId, isEmptyTag);
 579 kumpf          1.76             else if (System::strcasecmp(
 580                                              iMethodResponseName, "References") == 0)
 581 kumpf          1.60                 response = _decodeReferencesResponse(
 582                                         parser, messageId, isEmptyTag);
 583 kumpf          1.76             else if (System::strcasecmp(
 584                                              iMethodResponseName, "ReferenceNames") == 0)
 585 kumpf          1.60                 response = _decodeReferenceNamesResponse(
 586                                         parser, messageId, isEmptyTag);
 587 kumpf          1.76             else if (System::strcasecmp(
 588                                              iMethodResponseName, "AssociatorNames") == 0)
 589 kumpf          1.60                 response = _decodeAssociatorNamesResponse(
 590                                         parser, messageId, isEmptyTag);
 591 kumpf          1.76             else if (System::strcasecmp(
 592                                              iMethodResponseName, "Associators") == 0)
 593 kumpf          1.60                 response = _decodeAssociatorsResponse(
 594                                         parser, messageId, isEmptyTag);
 595 kumpf          1.76             else if (System::strcasecmp(
 596                                              iMethodResponseName, "CreateInstance") == 0)
 597 kumpf          1.60                 response = _decodeCreateInstanceResponse(
 598                                         parser, messageId, isEmptyTag);
 599 kumpf          1.76             else if (System::strcasecmp(
 600                                              iMethodResponseName,"EnumerateInstanceNames") == 0)
 601 kumpf          1.60                 response = _decodeEnumerateInstanceNamesResponse(
 602                                         parser, messageId, isEmptyTag);
 603 kumpf          1.76             else if (System::strcasecmp(
 604                                              iMethodResponseName,"EnumerateInstances") == 0)
 605 kumpf          1.60                 response = _decodeEnumerateInstancesResponse(
 606                                         parser, messageId, isEmptyTag);
 607 kumpf          1.76             else if (System::strcasecmp(
 608                                              iMethodResponseName, "GetProperty") == 0)
 609 kumpf          1.60                 response = _decodeGetPropertyResponse(
 610                                         parser, messageId, isEmptyTag);
 611 kumpf          1.76             else if (System::strcasecmp(
 612                                              iMethodResponseName, "SetProperty") == 0)
 613 kumpf          1.60                 response = _decodeSetPropertyResponse(
 614                                         parser, messageId, isEmptyTag);
 615 kumpf          1.76             else if (System::strcasecmp(
 616                                              iMethodResponseName, "DeleteQualifier") == 0)
 617 kumpf          1.60                 response = _decodeDeleteQualifierResponse(
 618                                         parser, messageId, isEmptyTag);
 619 kumpf          1.76             else if (System::strcasecmp(
 620                                              iMethodResponseName, "GetQualifier") == 0)
 621 kumpf          1.60                 response = _decodeGetQualifierResponse(
 622                                         parser, messageId, isEmptyTag);
 623 kumpf          1.76             else if (System::strcasecmp(
 624                                              iMethodResponseName, "SetQualifier") == 0)
 625 kumpf          1.60                 response = _decodeSetQualifierResponse(
 626                                         parser, messageId, isEmptyTag);
 627 kumpf          1.76             else if (System::strcasecmp(
 628                                              iMethodResponseName, "EnumerateQualifiers") == 0)
 629 kumpf          1.60                 response = _decodeEnumerateQualifiersResponse(
 630                                         parser, messageId, isEmptyTag);
 631 kumpf          1.76             else if (System::strcasecmp(
 632                                              iMethodResponseName, "EnumerateClasses") == 0)
 633 kumpf          1.60                 response = _decodeEnumerateClassesResponse(
 634                                         parser, messageId, isEmptyTag);
 635 kumpf          1.76             else if (System::strcasecmp(
 636                                              iMethodResponseName, "CreateClass") == 0)
 637 kumpf          1.60                 response = _decodeCreateClassResponse(
 638                                         parser, messageId, isEmptyTag);
 639 kumpf          1.76             else if (System::strcasecmp(
 640                                              iMethodResponseName, "ModifyClass") == 0)
 641 kumpf          1.60                 response = _decodeModifyClassResponse(
 642                                         parser, messageId, isEmptyTag);
 643 kumpf          1.76             else if (System::strcasecmp(
 644                                              iMethodResponseName, "ModifyInstance") == 0)
 645 kumpf          1.60                 response = _decodeModifyInstanceResponse(
 646                                         parser, messageId, isEmptyTag);
 647 kumpf          1.76             else if (System::strcasecmp(
 648                                              iMethodResponseName, "DeleteClass") == 0)
 649 kumpf          1.60                 response = _decodeDeleteClassResponse(
 650                                         parser, messageId, isEmptyTag);
 651 kumpf          1.76             else if (System::strcasecmp(
 652                                              iMethodResponseName, "DeleteInstance") == 0)
 653 kumpf          1.60                 response = _decodeDeleteInstanceResponse(
 654                                         parser, messageId, isEmptyTag);
 655                                 else if (System::strcasecmp(iMethodResponseName, "ExecQuery") == 0)
 656                                     response = _decodeExecQueryResponse(
 657                                         parser, messageId, isEmptyTag);
 658                                 else
 659                                 {
 660                                     MessageLoaderParms mlParms(
 661                                         "Client.CIMOperationResponseDecoder.UNRECOGNIZED_NAME",
 662                                         "Unrecognized IMethodResponse name \"$0\"",
 663                                         iMethodResponseName);
 664                                     throw XmlValidationError(parser.getLine(), mlParms);
 665                                 }
 666 humberto       1.43 
 667 kumpf          1.60             //
 668                                 // Handle end tag:
 669                                 //
 670 humberto       1.43 
 671 kumpf          1.60             if (!isEmptyTag)
 672                                 {
 673                                     XmlReader::expectEndTag(parser, "IMETHODRESPONSE");
 674                                 }
 675                             }
 676                             else if (XmlReader::getMethodResponseStartTag(
 677                                          parser, iMethodResponseName, isEmptyTag))
 678                             {
 679                                 response = _decodeInvokeMethodResponse(
 680                                     parser, messageId, iMethodResponseName, isEmptyTag);
 681                     
 682 j.alex         1.68 
 683 kumpf          1.60             //
 684                                 // Handle end tag:
 685                                 //
 686                                 if (!isEmptyTag)
 687                                 {
 688                                     XmlReader::expectEndTag(parser, "METHODRESPONSE");
 689                                 }
 690                             }
 691                             else
 692                             {
 693 kumpf          1.76             MessageLoaderParms mlParms(
 694                                     "Client.CIMOperationResponseDecoder."
 695                                         "EXPECTED_METHODRESPONSE_OR_IMETHODRESPONSE_ELEMENT",
 696 kumpf          1.60                 "expected METHODRESPONSE or IMETHODRESPONSE element");
 697                                 throw XmlValidationError(parser.getLine(), mlParms);
 698                             }
 699 mike           1.2  
 700                             //
 701                             // Handle end tags:
 702                             //
 703 kumpf          1.60         XmlReader::expectEndTag(parser, "SIMPLERSP");
 704                             XmlReader::expectEndTag(parser, "MESSAGE");
 705                             XmlReader::expectEndTag(parser, "CIM");
 706 mike           1.2      }
 707 kumpf          1.17     catch (XmlException& x)
 708                         {
 709 kumpf          1.60         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::TRACE,
 710 kumpf          1.76             "CIMOperationResponseDecoder::_handleMethodResponse - "
 711                                     "XmlException has occurred. Message: $0",
 712                                 x.getMessage());
 713 david          1.38 
 714 kumpf          1.17         if (response)
 715                             {
 716 karl           1.41 //#ifdef PEGASUS_SNIA_INTEROP_TEST
 717                     //         httpMessage->printAll(cout);
 718                     //#endif
 719 kumpf          1.60 
 720 kumpf          1.17             delete response;
 721                             }
 722                     
 723                             response = new ClientExceptionMessage(
 724 kumpf          1.20             new CIMClientXmlException(x.getMessage()));
 725 kumpf          1.17     }
 726 mike           1.2      catch (Exception& x)
 727                         {
 728 kumpf          1.50         // Might get MalformedObjectNameException, InvalidNameException, etc.
 729 kumpf          1.17 
 730                             if (response)
 731                             {
 732                                 delete response;
 733                             }
 734 mike           1.2  
 735 kumpf          1.17         response = new ClientExceptionMessage(
 736 kumpf          1.53             new CIMClientResponseException(x.getMessage()));
 737 mike           1.2      }
 738 chuck          1.39 
 739                     //l10n start
 740                     // l10n TODO - might want to move A-L and C-L to Message
 741                     // to make this more maintainable
 742 kumpf          1.60     // Add the language header to the request
 743                         CIMMessage * cimmsg = dynamic_cast<CIMMessage *>(response);
 744                         if (cimmsg != NULL)
 745                         {
 746 kumpf          1.76         cimmsg->operationContext.set(
 747                                 ContentLanguageListContainer(contentLanguages));
 748 kumpf          1.60     }
 749                         else
 750                         {
 751                             ;    // l10n TODO - error back to client here
 752                         }
 753                     // l10n end
 754 mike           1.2  
 755 j.alex         1.68     response->setCloseConnect(cimReconnect);
 756                     
 757                     
 758 mike           1.2      _outputQueue->enqueue(response);
 759                     }
 760                     
 761 kumpf          1.76 CIMCreateClassResponseMessage*
 762                         CIMOperationResponseDecoder::_decodeCreateClassResponse(
 763                             XmlParser& parser,
 764                             const String& messageId,
 765                             Boolean isEmptyImethodresponseTag)
 766 mike           1.2  {
 767                         XmlEntry entry;
 768 kumpf          1.12     CIMException cimException;
 769 mike           1.2  
 770 kumpf          1.60     if (!isEmptyImethodresponseTag)
 771 mike           1.2      {
 772 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
 773                             {
 774 kumpf          1.76             return new CIMCreateClassResponseMessage(
 775 kumpf          1.60                 messageId,
 776                                     cimException,
 777 kumpf          1.76                 QueueIdStack());
 778 kumpf          1.60         }
 779 mike           1.2  
 780 kumpf          1.60         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
 781                             {
 782                                 if (entry.type != XmlEntry::EMPTY_TAG)
 783                                 {
 784                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
 785                                 }
 786                             }
 787 mike           1.2      }
 788 kumpf          1.60 
 789 kumpf          1.76     return new CIMCreateClassResponseMessage(
 790 kumpf          1.60         messageId,
 791                             cimException,
 792 kumpf          1.76         QueueIdStack());
 793 mike           1.2  }
 794                     
 795 kumpf          1.76 CIMGetClassResponseMessage*
 796                         CIMOperationResponseDecoder::_decodeGetClassResponse(
 797                             XmlParser& parser,
 798                             const String& messageId,
 799                             Boolean isEmptyImethodresponseTag)
 800 mike           1.2  {
 801                         XmlEntry entry;
 802 kumpf          1.12     CIMException cimException;
 803 mike           1.2  
 804 kumpf          1.60     if (isEmptyImethodresponseTag)
 805                         {
 806                             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
 807                                 "Expected open of $0 element", "IMETHODRESPONSE");
 808                             throw XmlValidationError(parser.getLine(), mlParms);
 809                         }
 810                         else if (XmlReader::getErrorElement(parser, cimException))
 811 mike           1.2      {
 812 kumpf          1.76         return new CIMGetClassResponseMessage(
 813 kumpf          1.60             messageId,
 814                                 cimException,
 815                                 QueueIdStack(),
 816 kumpf          1.76             CIMClass());
 817 mike           1.2      }
 818 kumpf          1.37     else if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
 819 mike           1.2      {
 820 kumpf          1.60         CIMClass cimClass;
 821 mike           1.2  
 822 kumpf          1.60         if ((entry.type == XmlEntry::EMPTY_TAG) ||
 823                                 !XmlReader::getClassElement(parser, cimClass))
 824                             {
 825                                 MessageLoaderParms mlParms(
 826                                     "Client.CIMOperationResponseDecoder.EXPECTED_CLASS_ELEMENT",
 827                                     "expected CLASS element");
 828                                 throw XmlValidationError(parser.getLine(), mlParms);
 829                             }
 830 humberto       1.43 
 831 kumpf          1.60         XmlReader::expectEndTag(parser, "IRETURNVALUE");
 832 humberto       1.43 
 833 kumpf          1.76         return new CIMGetClassResponseMessage(
 834 kumpf          1.60             messageId,
 835                                 cimException,
 836                                 QueueIdStack(),
 837 kumpf          1.76             cimClass);
 838 mike           1.2      }
 839                         else
 840                         {
 841 kumpf          1.76         MessageLoaderParms mlParms(
 842                                 "Client.CIMOperationResponseDecoder."
 843                                     "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
 844 kumpf          1.60             "expected ERROR or IRETURNVALUE element");
 845                             throw XmlValidationError(parser.getLine(), mlParms);
 846 mike           1.2      }
 847                     }
 848                     
 849 kumpf          1.76 CIMModifyClassResponseMessage*
 850                         CIMOperationResponseDecoder::_decodeModifyClassResponse(
 851                             XmlParser& parser,
 852                             const String& messageId,
 853                             Boolean isEmptyImethodresponseTag)
 854 mike           1.2  {
 855                         XmlEntry entry;
 856 kumpf          1.12     CIMException cimException;
 857 mike           1.2  
 858 kumpf          1.60     if (!isEmptyImethodresponseTag)
 859 mike           1.2      {
 860 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
 861                             {
 862 kumpf          1.76             return new CIMModifyClassResponseMessage(
 863 kumpf          1.60                 messageId,
 864                                     cimException,
 865 kumpf          1.76                 QueueIdStack());
 866 kumpf          1.60         }
 867                     
 868                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
 869                             {
 870                                 if (entry.type != XmlEntry::EMPTY_TAG)
 871                                 {
 872                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
 873                                 }
 874                             }
 875 mike           1.2      }
 876 kumpf          1.60 
 877 kumpf          1.76     return new CIMModifyClassResponseMessage(
 878 kumpf          1.60         messageId,
 879                             cimException,
 880 kumpf          1.76         QueueIdStack());
 881 mike           1.2  }
 882                     
 883 kumpf          1.76 CIMEnumerateClassNamesResponseMessage*
 884                         CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
 885                             XmlParser& parser,
 886                             const String& messageId,
 887                             Boolean isEmptyImethodresponseTag)
 888 mike           1.2  {
 889                         XmlEntry entry;
 890 kumpf          1.12     CIMException cimException;
 891 kumpf          1.60     Array<CIMName> classNames;
 892 mike           1.2  
 893 kumpf          1.60     if (!isEmptyImethodresponseTag)
 894 mike           1.2      {
 895 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
 896                             {
 897 kumpf          1.76             return new CIMEnumerateClassNamesResponseMessage(
 898 kumpf          1.60                 messageId,
 899                                     cimException,
 900                                     QueueIdStack(),
 901 kumpf          1.76                 Array<CIMName>());
 902 kumpf          1.60         }
 903                     
 904                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
 905                             {
 906                                 if (entry.type != XmlEntry::EMPTY_TAG)
 907                                 {
 908                                     CIMName className;
 909                     
 910                                     while (XmlReader::getClassNameElement(parser, className, false))
 911                                         classNames.append(className);
 912                     
 913                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
 914                                 }
 915                             }
 916 mike           1.2      }
 917                     
 918 kumpf          1.76     return new CIMEnumerateClassNamesResponseMessage(
 919 kumpf          1.60         messageId,
 920                             cimException,
 921                             QueueIdStack(),
 922 kumpf          1.76         classNames);
 923 mike           1.2  }
 924                     
 925 kumpf          1.76 CIMEnumerateClassesResponseMessage*
 926                         CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
 927                             XmlParser& parser,
 928                             const String& messageId,
 929                             Boolean isEmptyImethodresponseTag)
 930 mike           1.2  {
 931                         XmlEntry entry;
 932 kumpf          1.12     CIMException cimException;
 933 kumpf          1.60     Array<CIMClass> cimClasses;
 934 mike           1.2  
 935 kumpf          1.60     if (!isEmptyImethodresponseTag)
 936 mike           1.2      {
 937 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
 938                             {
 939 kumpf          1.76             return new CIMEnumerateClassesResponseMessage(
 940 kumpf          1.60                 messageId,
 941                                     cimException,
 942                                     QueueIdStack(),
 943 kumpf          1.76                 Array<CIMClass>());
 944 kumpf          1.60         }
 945                     
 946                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
 947                             {
 948                                 if (entry.type != XmlEntry::EMPTY_TAG)
 949                                 {
 950                                     CIMClass cimClass;
 951                     
 952                                     while (XmlReader::getClassElement(parser, cimClass))
 953                                         cimClasses.append(cimClass);
 954                     
 955                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
 956                                 }
 957                             }
 958 mike           1.2      }
 959                     
 960 kumpf          1.76     return new CIMEnumerateClassesResponseMessage(
 961 kumpf          1.60         messageId,
 962                             cimException,
 963                             QueueIdStack(),
 964 kumpf          1.76         cimClasses);
 965 mike           1.2  }
 966                     
 967 kumpf          1.76 CIMDeleteClassResponseMessage*
 968                         CIMOperationResponseDecoder::_decodeDeleteClassResponse(
 969                             XmlParser& parser,
 970                             const String& messageId,
 971                             Boolean isEmptyImethodresponseTag)
 972 mike           1.2  {
 973                         XmlEntry entry;
 974 kumpf          1.12     CIMException cimException;
 975 mike           1.2  
 976 kumpf          1.60     if (!isEmptyImethodresponseTag)
 977 mike           1.2      {
 978 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
 979                             {
 980 kumpf          1.76             return new CIMDeleteClassResponseMessage(
 981 kumpf          1.60                 messageId,
 982                                     cimException,
 983 kumpf          1.76                 QueueIdStack());
 984 kumpf          1.60         }
 985                     
 986                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
 987                             {
 988                                 if (entry.type != XmlEntry::EMPTY_TAG)
 989                                 {
 990                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
 991                                 }
 992                             }
 993 mike           1.2      }
 994 kumpf          1.60 
 995 kumpf          1.76     return new CIMDeleteClassResponseMessage(
 996 kumpf          1.60         messageId,
 997                             cimException,
 998 kumpf          1.76         QueueIdStack());
 999 mike           1.2  }
1000                     
1001 kumpf          1.76 CIMCreateInstanceResponseMessage*
1002                         CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
1003                             XmlParser& parser,
1004                             const String& messageId,
1005                             Boolean isEmptyImethodresponseTag)
1006 mike           1.2  {
1007                         XmlEntry entry;
1008 kumpf          1.12     CIMException cimException;
1009 mike           1.2  
1010 kumpf          1.60     if (isEmptyImethodresponseTag)
1011                         {
1012                             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
1013                                 "Expected open of $0 element", "IMETHODRESPONSE");
1014                             throw XmlValidationError(parser.getLine(), mlParms);
1015                         }
1016                         else if (XmlReader::getErrorElement(parser, cimException))
1017 mike           1.2      {
1018 kumpf          1.76         return new CIMCreateInstanceResponseMessage(
1019 kumpf          1.60             messageId,
1020                                 cimException,
1021                                 QueueIdStack(),
1022 kumpf          1.76             CIMObjectPath());
1023 mike           1.2      }
1024                         else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1025                         {
1026 kumpf          1.60         CIMObjectPath instanceName;
1027                             XmlReader::getInstanceNameElement(parser, instanceName);
1028 mike           1.2  
1029 kumpf          1.60         XmlReader::expectEndTag(parser, "IRETURNVALUE");
1030 mike           1.2  
1031 kumpf          1.76         return new CIMCreateInstanceResponseMessage(
1032 kumpf          1.60             messageId,
1033                                 cimException,
1034                                 QueueIdStack(),
1035 kumpf          1.76             instanceName);
1036 mike           1.2      }
1037                         else
1038                         {
1039 kumpf          1.76         MessageLoaderParms mlParms(
1040                                 "Client.CIMOperationResponseDecoder."
1041                                     "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
1042 kumpf          1.60             "expected ERROR or IRETURNVALUE element");
1043 humberto       1.43 
1044 kumpf          1.60         throw XmlValidationError(parser.getLine(), mlParms);
1045 mike           1.2      }
1046                     }
1047                     
1048 kumpf          1.76 CIMGetInstanceResponseMessage*
1049                         CIMOperationResponseDecoder::_decodeGetInstanceResponse(
1050                             XmlParser& parser,
1051                             const String& messageId,
1052                             Boolean isEmptyImethodresponseTag)
1053 mike           1.2  {
1054                         XmlEntry entry;
1055 kumpf          1.12     CIMException cimException;
1056 mike           1.2  
1057 kumpf          1.60     if (isEmptyImethodresponseTag)
1058                         {
1059                             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
1060                                 "Expected open of $0 element", "IMETHODRESPONSE");
1061                             throw XmlValidationError(parser.getLine(), mlParms);
1062                         }
1063                         else if (XmlReader::getErrorElement(parser, cimException))
1064 mike           1.2      {
1065 kumpf          1.76         return new CIMGetInstanceResponseMessage(
1066 kumpf          1.60             messageId,
1067                                 cimException,
1068                                 QueueIdStack(),
1069 kumpf          1.76             CIMInstance());
1070 mike           1.2      }
1071 kumpf          1.37     else if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1072 mike           1.2      {
1073 kumpf          1.60         CIMInstance cimInstance;
1074 mike           1.2  
1075 kumpf          1.60         if ((entry.type == XmlEntry::EMPTY_TAG) ||
1076                                 !XmlReader::getInstanceElement(parser, cimInstance))
1077                             {
1078                                 MessageLoaderParms mlParms(
1079                                     "Client.CIMOperationResponseDecoder.EXPECTED_INSTANCE_ELEMENT",
1080                                     "expected INSTANCE element");
1081                                 throw XmlValidationError(parser.getLine(), mlParms);
1082                             }
1083 mike           1.2  
1084 kumpf          1.60         XmlReader::expectEndTag(parser, "IRETURNVALUE");
1085 mike           1.2  
1086 kumpf          1.76         return new CIMGetInstanceResponseMessage(
1087 kumpf          1.60             messageId,
1088                                 cimException,
1089                                 QueueIdStack(),
1090 kumpf          1.76             cimInstance);
1091 mike           1.2      }
1092                         else
1093                         {
1094 kumpf          1.76         MessageLoaderParms mlParms(
1095                                 "Client.CIMOperationResponseDecoder."
1096                                     "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
1097 kumpf          1.60             "expected ERROR or IRETURNVALUE element");
1098                             throw XmlValidationError(parser.getLine(), mlParms);
1099 mike           1.2      }
1100                     }
1101                     
1102 kumpf          1.76 CIMModifyInstanceResponseMessage*
1103                         CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
1104                             XmlParser& parser,
1105                             const String& messageId,
1106                             Boolean isEmptyImethodresponseTag)
1107 mike           1.2  {
1108                         XmlEntry entry;
1109 kumpf          1.12     CIMException cimException;
1110 mike           1.2  
1111 kumpf          1.60     if (!isEmptyImethodresponseTag)
1112 mike           1.2      {
1113 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1114                             {
1115 kumpf          1.76             return new CIMModifyInstanceResponseMessage(
1116 kumpf          1.60                 messageId,
1117                                     cimException,
1118 kumpf          1.76                 QueueIdStack());
1119 kumpf          1.60         }
1120                     
1121                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1122                             {
1123                                 if (entry.type != XmlEntry::EMPTY_TAG)
1124                                 {
1125                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1126                                 }
1127                             }
1128 mike           1.2      }
1129 kumpf          1.60 
1130 kumpf          1.76     return new CIMModifyInstanceResponseMessage(
1131 kumpf          1.60         messageId,
1132                             cimException,
1133 kumpf          1.76         QueueIdStack());
1134 mike           1.2  }
1135                     
1136 kumpf          1.76 CIMEnumerateInstanceNamesResponseMessage*
1137                         CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
1138                             XmlParser& parser,
1139                             const String& messageId,
1140                             Boolean isEmptyImethodresponseTag)
1141 mike           1.2  {
1142                         XmlEntry entry;
1143 kumpf          1.12     CIMException cimException;
1144 kumpf          1.60     Array<CIMObjectPath> instanceNames;
1145 mike           1.2  
1146 kumpf          1.60     if (!isEmptyImethodresponseTag)
1147 mike           1.2      {
1148 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1149                             {
1150 kumpf          1.76             return new CIMEnumerateInstanceNamesResponseMessage(
1151 kumpf          1.60                 messageId,
1152                                     cimException,
1153                                     QueueIdStack(),
1154 kumpf          1.76                 Array<CIMObjectPath>());
1155 kumpf          1.60         }
1156                     
1157                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1158                             {
1159                                 if (entry.type != XmlEntry::EMPTY_TAG)
1160                                 {
1161                                     String className;
1162                                     Array<CIMKeyBinding> keyBindings;
1163                     
1164                                     while (XmlReader::getInstanceNameElement(
1165                                         parser, className, keyBindings))
1166                                     {
1167                                         CIMObjectPath r(
1168                                             String::EMPTY,
1169                                             CIMNamespaceName(),
1170                                             className,
1171                                             keyBindings);
1172                                         instanceNames.append(r);
1173                                     }
1174                     
1175                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1176 kumpf          1.60             }
1177                             }
1178 mike           1.2      }
1179                     
1180 kumpf          1.76     return new CIMEnumerateInstanceNamesResponseMessage(
1181 kumpf          1.60         messageId,
1182                             cimException,
1183                             QueueIdStack(),
1184 kumpf          1.76         instanceNames);
1185 mike           1.2  }
1186                     
1187 kumpf          1.76 CIMEnumerateInstancesResponseMessage*
1188                         CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(
1189                             XmlParser& parser,
1190                             const String& messageId,
1191                             Boolean isEmptyImethodresponseTag)
1192 mike           1.2  {
1193                         XmlEntry entry;
1194 kumpf          1.12     CIMException cimException;
1195 kumpf          1.60     Array<CIMInstance> namedInstances;
1196 mike           1.2  
1197 kumpf          1.60     if (!isEmptyImethodresponseTag)
1198 mike           1.2      {
1199 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1200                             {
1201 kumpf          1.76             return new CIMEnumerateInstancesResponseMessage(
1202 kumpf          1.60                 messageId,
1203                                     cimException,
1204                                     QueueIdStack(),
1205 kumpf          1.76                 Array<CIMInstance>());
1206 kumpf          1.60         }
1207                     
1208                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1209                             {
1210                                 if (entry.type != XmlEntry::EMPTY_TAG)
1211                                 {
1212                                     CIMInstance namedInstance;
1213                     
1214                                     while (XmlReader::getNamedInstanceElement(
1215                                                parser, namedInstance))
1216                                     {
1217                                         namedInstances.append(namedInstance);
1218                                     }
1219                     
1220                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1221                                 }
1222                             }
1223 mike           1.2      }
1224                     
1225 kumpf          1.76     return new CIMEnumerateInstancesResponseMessage(
1226 kumpf          1.60         messageId,
1227                             cimException,
1228                             QueueIdStack(),
1229 kumpf          1.76         namedInstances);
1230 mike           1.2  }
1231                     
1232 kumpf          1.76 CIMDeleteInstanceResponseMessage*
1233                         CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
1234                             XmlParser& parser,
1235                             const String& messageId,
1236                             Boolean isEmptyImethodresponseTag)
1237 mike           1.2  {
1238                         XmlEntry entry;
1239 kumpf          1.12     CIMException cimException;
1240 mike           1.2  
1241 kumpf          1.60     if (!isEmptyImethodresponseTag)
1242 mike           1.2      {
1243 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1244                             {
1245 kumpf          1.76             return new CIMDeleteInstanceResponseMessage(
1246 kumpf          1.60                 messageId,
1247                                     cimException,
1248 kumpf          1.76                 QueueIdStack());
1249 kumpf          1.60         }
1250                     
1251                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1252                             {
1253                                 if (entry.type != XmlEntry::EMPTY_TAG)
1254                                 {
1255                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1256                                 }
1257                             }
1258 mike           1.2      }
1259 kumpf          1.60 
1260 kumpf          1.76     return new CIMDeleteInstanceResponseMessage(
1261 kumpf          1.60         messageId,
1262                             cimException,
1263 kumpf          1.76         QueueIdStack());
1264 mike           1.2  }
1265                     
1266 kumpf          1.76 CIMGetPropertyResponseMessage*
1267                         CIMOperationResponseDecoder::_decodeGetPropertyResponse(
1268                             XmlParser& parser,
1269                             const String& messageId,
1270                             Boolean isEmptyImethodresponseTag)
1271 mike           1.2  {
1272                         XmlEntry entry;
1273 kumpf          1.12     CIMException cimException;
1274 kumpf          1.60     CIMValue cimValue(CIMTYPE_STRING, false);
1275 mike           1.2  
1276 kumpf          1.60     if (!isEmptyImethodresponseTag)
1277 mike           1.2      {
1278 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1279                             {
1280 kumpf          1.76             return new CIMGetPropertyResponseMessage(
1281 kumpf          1.60                 messageId,
1282                                     cimException,
1283                                     QueueIdStack(),
1284 kumpf          1.76                 CIMValue());
1285 kumpf          1.60         }
1286 kumpf          1.14 
1287 kumpf          1.60         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1288                             {
1289                                 if (entry.type != XmlEntry::EMPTY_TAG)
1290                                 {
1291                                     if (!XmlReader::getPropertyValue(parser, cimValue))
1292                                     {
1293 kumpf          1.37                     // No value given; just return a null String value
1294 kumpf          1.60                 }
1295 kumpf          1.37 
1296 kumpf          1.60                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1297                                 }
1298                             }
1299                             else
1300                             {
1301 kumpf          1.14             // No value given; just return a null String value
1302 kumpf          1.60         }
1303                         }
1304 mike           1.2  
1305 kumpf          1.76     return new CIMGetPropertyResponseMessage(
1306 kumpf          1.60         messageId,
1307                             cimException,
1308                             QueueIdStack(),
1309 kumpf          1.76         cimValue);
1310 mike           1.2  }
1311                     
1312 kumpf          1.76 CIMSetPropertyResponseMessage*
1313                         CIMOperationResponseDecoder::_decodeSetPropertyResponse(
1314                             XmlParser& parser,
1315                             const String& messageId,
1316                             Boolean isEmptyImethodresponseTag)
1317 mike           1.2  {
1318                         XmlEntry entry;
1319 kumpf          1.12     CIMException cimException;
1320 mike           1.2  
1321 kumpf          1.60     if (!isEmptyImethodresponseTag)
1322 mike           1.2      {
1323 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1324                             {
1325 kumpf          1.76             return new CIMSetPropertyResponseMessage(
1326 kumpf          1.60                 messageId,
1327                                     cimException,
1328 kumpf          1.76                 QueueIdStack());
1329 kumpf          1.60         }
1330                     
1331                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1332                             {
1333                                 if (entry.type != XmlEntry::EMPTY_TAG)
1334                                 {
1335                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1336                                 }
1337                             }
1338 mike           1.2      }
1339 kumpf          1.60 
1340 kumpf          1.76     return new CIMSetPropertyResponseMessage(
1341 kumpf          1.60         messageId,
1342                             cimException,
1343 kumpf          1.76         QueueIdStack());
1344 mike           1.2  }
1345                     
1346 kumpf          1.76 CIMSetQualifierResponseMessage*
1347                         CIMOperationResponseDecoder::_decodeSetQualifierResponse(
1348                             XmlParser& parser,
1349                             const String& messageId,
1350                             Boolean isEmptyImethodresponseTag)
1351 mike           1.2  {
1352                         XmlEntry entry;
1353 kumpf          1.12     CIMException cimException;
1354 mike           1.2  
1355 kumpf          1.60     if (!isEmptyImethodresponseTag)
1356 mike           1.2      {
1357 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1358                             {
1359 kumpf          1.76             return new CIMSetQualifierResponseMessage(
1360 kumpf          1.60                 messageId,
1361                                     cimException,
1362 kumpf          1.76                 QueueIdStack());
1363 kumpf          1.60         }
1364                     
1365                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1366                             {
1367                                 if (entry.type != XmlEntry::EMPTY_TAG)
1368                                 {
1369                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1370                                 }
1371                             }
1372 mike           1.2      }
1373 kumpf          1.60 
1374 kumpf          1.76     return new CIMSetQualifierResponseMessage(
1375 kumpf          1.60         messageId,
1376                             cimException,
1377 kumpf          1.76         QueueIdStack());
1378 mike           1.2  }
1379                     
1380 kumpf          1.76 CIMGetQualifierResponseMessage*
1381                         CIMOperationResponseDecoder::_decodeGetQualifierResponse(
1382                             XmlParser& parser,
1383                             const String& messageId,
1384                             Boolean isEmptyImethodresponseTag)
1385 mike           1.2  {
1386                         XmlEntry entry;
1387 kumpf          1.12     CIMException cimException;
1388 mike           1.2  
1389 kumpf          1.60     if (isEmptyImethodresponseTag)
1390                         {
1391                             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
1392                                 "Expected open of $0 element", "IMETHODRESPONSE");
1393                             throw XmlValidationError(parser.getLine(), mlParms);
1394                         }
1395                         else if (XmlReader::getErrorElement(parser, cimException))
1396 mike           1.2      {
1397 kumpf          1.76         return new CIMGetQualifierResponseMessage(
1398 kumpf          1.60             messageId,
1399                                 cimException,
1400                                 QueueIdStack(),
1401 kumpf          1.76             CIMQualifierDecl());
1402 mike           1.2      }
1403                         else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
1404                         {
1405 kumpf          1.60         CIMQualifierDecl qualifierDecl;
1406                             XmlReader::getQualifierDeclElement(parser, qualifierDecl);
1407 mike           1.2  
1408 kumpf          1.60         XmlReader::expectEndTag(parser, "IRETURNVALUE");
1409 mike           1.2  
1410 kumpf          1.76         return new CIMGetQualifierResponseMessage(
1411 kumpf          1.60             messageId,
1412                                 cimException,
1413                                 QueueIdStack(),
1414 kumpf          1.76             qualifierDecl);
1415 mike           1.2      }
1416                         else
1417                         {
1418 kumpf          1.76         MessageLoaderParms mlParms(
1419                                 "Client.CIMOperationResponseDecoder."
1420                                     "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
1421                                 "expected ERROR or IRETURNVALUE element");
1422 kumpf          1.60         throw XmlValidationError(parser.getLine(), mlParms);
1423 mike           1.2      }
1424                     }
1425                     
1426 kumpf          1.76 CIMEnumerateQualifiersResponseMessage*
1427                         CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
1428                             XmlParser& parser,
1429                             const String& messageId,
1430                             Boolean isEmptyImethodresponseTag)
1431 mike           1.2  {
1432                         XmlEntry entry;
1433 kumpf          1.12     CIMException cimException;
1434 kumpf          1.60     Array<CIMQualifierDecl> qualifierDecls;
1435 mike           1.2  
1436 kumpf          1.60     if (!isEmptyImethodresponseTag)
1437 mike           1.2      {
1438 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1439                             {
1440 kumpf          1.76             return new CIMEnumerateQualifiersResponseMessage(
1441 kumpf          1.60                 messageId,
1442                                     cimException,
1443                                     QueueIdStack(),
1444 kumpf          1.76                 Array<CIMQualifierDecl>());
1445 kumpf          1.60         }
1446                     
1447                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1448                             {
1449                                 if (entry.type != XmlEntry::EMPTY_TAG)
1450                                 {
1451                                     CIMQualifierDecl qualifierDecl;
1452                     
1453                                     while (XmlReader::getQualifierDeclElement(
1454                                                parser, qualifierDecl))
1455                                     {
1456                                         qualifierDecls.append(qualifierDecl);
1457                                     }
1458                     
1459                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1460                                 }
1461                             }
1462 mike           1.2      }
1463                     
1464 kumpf          1.76     return new CIMEnumerateQualifiersResponseMessage(
1465 kumpf          1.60         messageId,
1466                             cimException,
1467                             QueueIdStack(),
1468 kumpf          1.76         qualifierDecls);
1469 mike           1.2  }
1470                     
1471 kumpf          1.76 CIMDeleteQualifierResponseMessage*
1472                         CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
1473                             XmlParser& parser,
1474                             const String& messageId,
1475                             Boolean isEmptyImethodresponseTag)
1476 mike           1.2  {
1477                         XmlEntry entry;
1478 kumpf          1.12     CIMException cimException;
1479 mike           1.2  
1480 kumpf          1.60     if (!isEmptyImethodresponseTag)
1481 mike           1.2      {
1482 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1483                             {
1484 kumpf          1.76             return new CIMDeleteQualifierResponseMessage(
1485 kumpf          1.60                 messageId,
1486                                     cimException,
1487 kumpf          1.76                 QueueIdStack());
1488 kumpf          1.60         }
1489                     
1490                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1491                             {
1492                                 if (entry.type != XmlEntry::EMPTY_TAG)
1493                                 {
1494                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1495                                 }
1496                             }
1497 mike           1.2      }
1498 kumpf          1.60 
1499 kumpf          1.76     return new CIMDeleteQualifierResponseMessage(
1500 kumpf          1.60         messageId,
1501                             cimException,
1502 kumpf          1.76         QueueIdStack());
1503 mike           1.2  }
1504                     
1505 kumpf          1.76 CIMReferenceNamesResponseMessage*
1506                         CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
1507                             XmlParser& parser,
1508                             const String& messageId,
1509                             Boolean isEmptyImethodresponseTag)
1510 mike           1.2  {
1511                         XmlEntry entry;
1512 kumpf          1.12     CIMException cimException;
1513 kumpf          1.60     Array<CIMObjectPath> objectPaths;
1514 mike           1.2  
1515 kumpf          1.60     if (!isEmptyImethodresponseTag)
1516 mike           1.2      {
1517 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1518                             {
1519 kumpf          1.76             return new CIMReferenceNamesResponseMessage(
1520 kumpf          1.60                 messageId,
1521                                     cimException,
1522                                     QueueIdStack(),
1523 kumpf          1.76                 Array<CIMObjectPath>());
1524 kumpf          1.60         }
1525                     
1526                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1527                             {
1528                                 if (entry.type != XmlEntry::EMPTY_TAG)
1529                                 {
1530                                     CIMObjectPath objectPath;
1531                     
1532                                     while (XmlReader::getObjectPathElement(parser, objectPath))
1533                                         objectPaths.append(objectPath);
1534                     
1535                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1536                                 }
1537                             }
1538 mike           1.2      }
1539                     
1540 kumpf          1.76     return new CIMReferenceNamesResponseMessage(
1541 kumpf          1.60         messageId,
1542                             cimException,
1543                             QueueIdStack(),
1544 kumpf          1.76         objectPaths);
1545 mike           1.2  }
1546                     
1547 kumpf          1.76 CIMReferencesResponseMessage*
1548                         CIMOperationResponseDecoder::_decodeReferencesResponse(
1549                             XmlParser& parser,
1550                             const String& messageId,
1551                             Boolean isEmptyImethodresponseTag)
1552 mike           1.2  {
1553                         XmlEntry entry;
1554 kumpf          1.12     CIMException cimException;
1555 kumpf          1.60     Array<CIMObject> objectWithPathArray;
1556 mike           1.2  
1557 kumpf          1.60     if (!isEmptyImethodresponseTag)
1558 mike           1.2      {
1559 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1560                             {
1561 kumpf          1.76             return new CIMReferencesResponseMessage(
1562 kumpf          1.60                 messageId,
1563                                     cimException,
1564                                     QueueIdStack(),
1565 kumpf          1.76                 Array<CIMObject>());
1566 kumpf          1.60         }
1567                     
1568                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1569                             {
1570                                 if (entry.type != XmlEntry::EMPTY_TAG)
1571                                 {
1572                                     CIMObject objectWithPath;
1573                     
1574                                     while (XmlReader::getValueObjectWithPathElement(
1575                                                parser, objectWithPath))
1576                                     {
1577                                         objectWithPathArray.append(objectWithPath);
1578                                     }
1579                     
1580                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1581                                 }
1582                             }
1583 mike           1.2      }
1584                     
1585 kumpf          1.76     return new CIMReferencesResponseMessage(
1586 kumpf          1.60         messageId,
1587                             cimException,
1588                             QueueIdStack(),
1589 kumpf          1.76         objectWithPathArray);
1590 mike           1.2  }
1591                     
1592 kumpf          1.76 CIMAssociatorNamesResponseMessage*
1593                         CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
1594                             XmlParser& parser,
1595                             const String& messageId,
1596                             Boolean isEmptyImethodresponseTag)
1597 mike           1.2  {
1598                         XmlEntry entry;
1599 kumpf          1.12     CIMException cimException;
1600 kumpf          1.60     Array<CIMObjectPath> objectPaths;
1601 mike           1.2  
1602 kumpf          1.60     if (!isEmptyImethodresponseTag)
1603 mike           1.2      {
1604 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1605                             {
1606 kumpf          1.76             return new CIMAssociatorNamesResponseMessage(
1607 kumpf          1.60                 messageId,
1608                                     cimException,
1609                                     QueueIdStack(),
1610 kumpf          1.76                 Array<CIMObjectPath>());
1611 kumpf          1.60         }
1612                     
1613                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1614                             {
1615                                 if (entry.type != XmlEntry::EMPTY_TAG)
1616                                 {
1617                                     CIMObjectPath objectPath;
1618                     
1619                                     while (XmlReader::getObjectPathElement(parser, objectPath))
1620                                         objectPaths.append(objectPath);
1621                     
1622                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1623                                 }
1624                             }
1625 mike           1.2      }
1626                     
1627 kumpf          1.76     return new CIMAssociatorNamesResponseMessage(
1628 kumpf          1.60         messageId,
1629                             cimException,
1630                             QueueIdStack(),
1631 kumpf          1.76         objectPaths);
1632 mike           1.2  }
1633                     
1634 kumpf          1.76 CIMAssociatorsResponseMessage*
1635                         CIMOperationResponseDecoder::_decodeAssociatorsResponse(
1636                             XmlParser& parser,
1637                             const String& messageId,
1638                             Boolean isEmptyImethodresponseTag)
1639 mike           1.2  {
1640                         XmlEntry entry;
1641 kumpf          1.12     CIMException cimException;
1642 kumpf          1.60     Array<CIMObject> objectWithPathArray;
1643 mike           1.2  
1644 kumpf          1.60     if (!isEmptyImethodresponseTag)
1645 mike           1.2      {
1646 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1647                             {
1648 kumpf          1.76             return new CIMAssociatorsResponseMessage(
1649 kumpf          1.60                 messageId,
1650                                     cimException,
1651                                     QueueIdStack(),
1652 kumpf          1.76                 Array<CIMObject>());
1653 kumpf          1.60         }
1654                     
1655                             if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1656                             {
1657                                 if (entry.type != XmlEntry::EMPTY_TAG)
1658                                 {
1659                                     CIMObject objectWithPath;
1660                     
1661                                     while (XmlReader::getValueObjectWithPathElement(
1662                                                parser, objectWithPath))
1663                                     {
1664                                         objectWithPathArray.append(objectWithPath);
1665                                     }
1666                     
1667                                     XmlReader::expectEndTag(parser, "IRETURNVALUE");
1668                                 }
1669                             }
1670 mike           1.2      }
1671                     
1672 kumpf          1.76     return new CIMAssociatorsResponseMessage(
1673 kumpf          1.60         messageId,
1674                             cimException,
1675                             QueueIdStack(),
1676 kumpf          1.76         objectWithPathArray);
1677 kumpf          1.10 }
1678                     
1679 kumpf          1.76 CIMExecQueryResponseMessage*
1680                         CIMOperationResponseDecoder::_decodeExecQueryResponse(
1681                             XmlParser& parser,
1682                             const String& messageId,
1683                             Boolean isEmptyImethodresponseTag)
1684 kumpf          1.10 {
1685                         XmlEntry entry;
1686 kumpf          1.12     CIMException cimException;
1687 kumpf          1.60     Array<CIMObject> objectWithPathArray;
1688 kumpf          1.10 
1689 kumpf          1.60     if (!isEmptyImethodresponseTag)
1690 kumpf          1.10     {
1691 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1692                             {
1693 kumpf          1.76             return new CIMExecQueryResponseMessage(
1694 kumpf          1.60                 messageId,
1695                                     cimException,
1696                                     QueueIdStack(),
1697 kumpf          1.76                 Array<CIMObject>());
1698 kumpf          1.60         }
1699 kumpf          1.10 
1700 kumpf          1.60         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
1701                             {
1702                                 if (entry.type != XmlEntry::EMPTY_TAG)
1703                                 {
1704 kumpf          1.37                 XmlReader::getObjectArray(parser, objectWithPathArray);
1705 kumpf          1.10 
1706 kumpf          1.60                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
1707                                 }
1708                             }
1709 mike           1.2      }
1710 kumpf          1.60 
1711 kumpf          1.76     return new CIMExecQueryResponseMessage(
1712 kumpf          1.60         messageId,
1713                             cimException,
1714                             QueueIdStack(),
1715 kumpf          1.76         objectWithPathArray);
1716 mike           1.2  }
1717                     
1718 kumpf          1.76 CIMInvokeMethodResponseMessage*
1719                         CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
1720                             XmlParser& parser,
1721                             const String& messageId,
1722                             const String& methodName,
1723                             Boolean isEmptyMethodresponseTag)
1724 mike           1.2  {
1725 kumpf          1.12     CIMException cimException;
1726 mike           1.2  
1727 kumpf          1.5      CIMParamValue paramValue;
1728                         Array<CIMParamValue> outParameters;
1729 kumpf          1.6      CIMValue returnValue;
1730 mike           1.2  
1731 kumpf          1.60     if (!isEmptyMethodresponseTag)
1732 mike           1.2      {
1733 kumpf          1.60         if (XmlReader::getErrorElement(parser, cimException))
1734                             {
1735 kumpf          1.76             return new CIMInvokeMethodResponseMessage(
1736 kumpf          1.60                 messageId,
1737                                     cimException,
1738                                     QueueIdStack(),
1739                                     returnValue,
1740                                     outParameters,
1741 kumpf          1.76                 methodName);
1742 kumpf          1.60         }
1743                     
1744 kumpf          1.4          Boolean isReturnValue = false;
1745                             Boolean isParamValue = false;
1746                             Boolean gotReturnValue = false;
1747                     
1748                             while ((isReturnValue =
1749 kumpf          1.6                      XmlReader::getReturnValueElement(parser, returnValue)) ||
1750 kumpf          1.5                 (isParamValue =
1751 kumpf          1.60                     XmlReader::getParamValueElement(parser, paramValue)))
1752 kumpf          1.4          {
1753                                 if (isReturnValue)
1754                                 {
1755                                     if (gotReturnValue)
1756                                     {
1757 kumpf          1.76                     MessageLoaderParms mlParms(
1758                                             "Client.CIMOperationResponseDecoder."
1759                                                 "EXPECTED_RETURNVALUE_ELEMENT",
1760 kumpf          1.60                         "unexpected RETURNVALUE element");
1761                                         throw XmlValidationError(parser.getLine(), mlParms);
1762 kumpf          1.4                  }
1763                                     gotReturnValue = true;
1764                                 }
1765                                 else    // isParamValue == true
1766                                 {
1767 kumpf          1.60                 outParameters.append(paramValue);
1768 kumpf          1.4              }
1769                     
1770                                 isReturnValue = false;
1771                                 isParamValue = false;
1772                             }
1773 kumpf          1.60     }
1774 kumpf          1.4  
1775 kumpf          1.76     return new CIMInvokeMethodResponseMessage(
1776 kumpf          1.60         messageId,
1777                             cimException,
1778                             QueueIdStack(),
1779                             returnValue,
1780                             outParameters,
1781 kumpf          1.76         methodName);
1782 mike           1.2  }
1783                     
1784                     PEGASUS_NAMESPACE_END

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2