1 karl  1.1.2.2 //%LICENSE////////////////////////////////////////////////////////////////
  2               //
  3               // Licensed to The Open Group (TOG) under one or more contributor license
  4               // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
  5               // this work for additional information regarding copyright ownership.
  6               // Each contributor licenses this file to you under the OpenPegasus Open
  7               // Source License; you may not use this file except in compliance with the
  8               // License.
  9               //
 10               // Permission is hereby granted, free of charge, to any person obtaining a
 11               // copy of this software and associated documentation files (the "Software"),
 12               // to deal in the Software without restriction, including without limitation
 13               // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 14               // and/or sell copies of the Software, and to permit persons to whom the
 15               // Software is furnished to do so, subject to the following conditions:
 16               //
 17               // The above copyright notice and this permission notice shall be included
 18               // in all copies or substantial portions of the Software.
 19               //
 20               // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 21               // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 22 karl  1.1.2.2 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 23               // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 24               // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 25               // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 26               // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 27               //
 28               //////////////////////////////////////////////////////////////////////////
 29               //
 30               //%/////////////////////////////////////////////////////////////////////////////
 31               
 32               #include <Pegasus/Common/System.h>
 33               #include <Pegasus/Common/HTTPMessage.h>
 34               #include <Pegasus/Common/CIMMessage.h>
 35               #include <Pegasus/Common/Exception.h>
 36               #include "WSMANExportResponseDecoder.h"
 37               #include <Pegasus/Common/MessageLoader.h>
 38               #include <Pegasus/Client/CIMClientException.h>
 39               #include <Pegasus/ExportClient/HTTPExportResponseDecoder.h>
 40               
 41               PEGASUS_USING_STD;
 42               
 43 karl  1.1.2.2 PEGASUS_NAMESPACE_BEGIN
 44               
 45               WSMANExportResponseDecoder::WSMANExportResponseDecoder(
 46                   MessageQueue* outputQueue,
 47                   MessageQueue* encoderQueue,
 48                   ClientAuthenticator* authenticator)
 49                   :MessageQueue(PEGASUS_QUEUENAME_EXPORTRESPDECODER),
 50                   _outputQueue(outputQueue),
 51                   _encoderQueue(encoderQueue),
 52                   _authenticator(authenticator)
 53               {
 54                   PEG_METHOD_ENTER(TRC_EXPORT_CLIENT,
 55                       "WSMANExportResponseDecoder::WSMANExportResponseDecoder()");
 56                   PEG_METHOD_EXIT();
 57               }
 58               
 59               WSMANExportResponseDecoder::~WSMANExportResponseDecoder()
 60               {
 61                   PEG_METHOD_ENTER(TRC_EXPORT_CLIENT,
 62                       "WSMANExportResponseDecoder::~WSMANExportResponseDecoder()");
 63                   _outputQueue.release();
 64 karl  1.1.2.2     _encoderQueue.release();
 65                   _authenticator.release();
 66                   PEG_METHOD_EXIT();
 67               }
 68               
 69               void WSMANExportResponseDecoder::setEncoderQueue(MessageQueue* encoderQueue)
 70               {
 71                   PEG_METHOD_ENTER(TRC_EXPORT_CLIENT,
 72                       "WSMANExportResponseDecoder::setEncoderQueue()");
 73                   _encoderQueue.release();
 74                   _encoderQueue.reset(encoderQueue);
 75                   PEG_METHOD_EXIT();
 76               }
 77               
 78               void WSMANExportResponseDecoder::handleEnqueue()
 79               {
 80                   PEG_METHOD_ENTER(TRC_EXPORT_CLIENT,
 81                       "WSMANExportResponseDecoder::handleEnqueue()");
 82                   Message* message = dequeue();
 83                   PEGASUS_ASSERT(message != 0);
 84                   switch (message->getType())
 85 karl  1.1.2.2     {
 86                       case HTTP_MESSAGE:
 87                       {
 88                           HTTPMessage* httpMessage = (HTTPMessage*)message;
 89                           _handleHTTPMessage(httpMessage);
 90                           break;
 91                       }
 92                       default:
 93                           PEGASUS_ASSERT(0);
 94                           break;
 95                   }
 96               
 97                   delete message;
 98                   PEG_METHOD_EXIT();
 99               }
100               
101               void WSMANExportResponseDecoder::_handleHTTPMessage(HTTPMessage* httpMessage)
102               {
103                   PEG_METHOD_ENTER(TRC_EXPORT_CLIENT,
104                       "WSMANExportResponseDecoder::_handleHTTPMessage()");
105               
106 karl  1.1.2.2     //  Parse the HTTP WSMAN Export response message
107                   ClientExceptionMessage* exceptionMessage;
108                   char* content;
109                   Array<HTTPHeader> headers;
110                   Uint32 contentLength;
111                   Uint32 statusCode;
112                   String reasonPhrase;
113                   Boolean cimReconnect;
114                   Boolean valid;
115                   HTTPExportResponseDecoder::parseHTTPHeaders(httpMessage, exceptionMessage,
116                       headers, contentLength, statusCode, reasonPhrase, cimReconnect, valid);
117               
118                   //  Return exception on any parse errors from the HTTP export response
119                   //  message
120                   if (!valid)
121                   {
122                       _outputQueue->enqueue(exceptionMessage);
123                       PEG_METHOD_EXIT();
124                       return;
125                   }
126               
127 karl  1.1.2.2     try
128                   {
129                       if (_authenticator->checkResponseHeaderForChallenge(headers))
130                       {
131                           //
132                           // Get the original request, put that in the encoder's queue for
133                           // re-sending with authentication challenge response.
134                           //
135               
136                           Message* reqMessage = _authenticator->releaseRequestMessage();
137               
138                           if (cimReconnect == true)
139                           {
140                               reqMessage->setCloseConnect(cimReconnect);
141                               _outputQueue->enqueue(reqMessage);
142                           }
143                           else
144                           {
145                               _encoderQueue->enqueue(reqMessage);
146                           }
147               
148 karl  1.1.2.2             PEG_METHOD_EXIT();
149                           return;
150                       }
151                       else
152                       {
153                           //
154                           // Received a valid/error response from the server.
155                           // We do not need the original request message anymore, hence
156                           // delete the request message by getting the handle from the
157                           // ClientAuthenticator.
158                           //
159                           Message* reqMessage = _authenticator->releaseRequestMessage();
160                           delete reqMessage;
161                       }
162                   }
163                   catch(InvalidAuthHeader& e)
164                   {
165                       AutoPtr<CIMClientMalformedHTTPException> malformedHTTPException(
166                           new CIMClientMalformedHTTPException(e.getMessage()));
167                       AutoPtr<ClientExceptionMessage> response(
168                           new ClientExceptionMessage(malformedHTTPException.get()));
169 karl  1.1.2.2 
170                       malformedHTTPException.release();
171               
172                       response->setCloseConnect(cimReconnect);
173                       _outputQueue->enqueue(response.release());
174                       PEG_METHOD_EXIT();
175                       return;
176                   }
177               
178                   //  Validate the HTTP headers in the export response message
179                   HTTPExportResponseDecoder::validateHTTPHeaders(httpMessage, headers,
180                       contentLength, statusCode, cimReconnect, reasonPhrase, content,
181                       exceptionMessage, valid, true);
182               
183                   //  Return exception on any errors in the HTTP headers in the export
184                   //  response message
185                   if (!valid)
186                   {
187                       _outputQueue->enqueue(exceptionMessage);
188                       PEG_METHOD_EXIT();
189                       return;
190 karl  1.1.2.2     }
191               
192                   //  Decode the export response message
193                   Message* responseMessage;
194                   HTTPExportResponseDecoder::decodeWSMANExportResponse(
195                       content,
196                       cimReconnect,
197                       responseMessage,
198                       _contentLanguages,
199                       _request);
200                   _outputQueue->enqueue(responseMessage);
201               
202                   PEG_METHOD_EXIT();
203               }
204               void WSMANExportResponseDecoder:: setContentLanguages(
205                   const ContentLanguageList & contentLanguages)
206               {
207                   _contentLanguages=contentLanguages;
208               }
209               void WSMANExportResponseDecoder::setWsmRequest(WsmRequest* request)
210               {
211 karl  1.1.2.2     _request = request;
212               }
213               
214               PEGASUS_NAMESPACE_END