1 lawrence.luo 1.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 lawrence.luo 1.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                  
 33                  #include <Pegasus/Common/HTTPConnection.h>
 34                  #include <Pegasus/Common/Logger.h>
 35                  #include <Pegasus/Common/Tracer.h>
 36                  
 37                  #include <Pegasus/WebServer/WebServer.h>
 38                  
 39                  
 40                  PEGASUS_USING_STD;
 41                  
 42                  PEGASUS_NAMESPACE_BEGIN
 43 lawrence.luo 1.2 
 44                  WebServer::WebServer()
 45                      : MessageQueue("WebServer"),
 46                        _webProcessor(this)
 47                  {
 48                  
 49                  }
 50                  
 51                  
 52                  WebServer::~WebServer()
 53                  {
 54                  }
 55                  
 56                  void WebServer::enqueue(Message* message)
 57                  {
 58                      PEG_METHOD_ENTER(TRC_WEBSERVER,
 59                          "WebServer::enqueue()");
 60                      handleEnqueue(message);
 61                      PEG_METHOD_EXIT();
 62                  }
 63                  
 64 lawrence.luo 1.2 void WebServer::handleEnqueue()
 65                  {
 66                      PEG_METHOD_ENTER(TRC_WEBSERVER,
 67                          "WebServer::handleEnqueue()");
 68                  
 69                      Message* message = dequeue();
 70                      handleEnqueue(message);
 71                  
 72                      PEG_METHOD_EXIT();
 73                  }
 74                  
 75                  void WebServer::handleEnqueue(Message* message)
 76                  {
 77                      PEG_METHOD_ENTER(TRC_WEBSERVER, "WebServer::handleEnqueue()");
 78                  
 79                      if ( !message )
 80                      {
 81                          PEG_METHOD_EXIT();
 82                          return;
 83                      }
 84                  
 85 lawrence.luo 1.2     switch (message->getType())
 86                      {
 87                          case HTTP_MESSAGE:
 88                              handleHTTPMessage((HTTPMessage*)message);
 89                              break;
 90                  
 91                          //Handles only the HTTP_MESSAGE, So this is unrechable
 92                          default:
 93                              PEGASUS_UNREACHABLE( PEGASUS_ASSERT(0);)
 94                              break;
 95                      }
 96                  
 97                      delete message;
 98                      PEG_METHOD_EXIT();
 99                  }
100                  
101                  void WebServer::handleHTTPMessage(HTTPMessage* httpMessage)
102                  {
103                      PEG_METHOD_ENTER(TRC_WEBSERVER, "WebServer::handleHTTPMessage()");
104                  
105                      if (!httpMessage)
106 lawrence.luo 1.2     {
107                          PEG_METHOD_EXIT();
108                          return;
109                      }
110                  
111                      // Parse the HTTP message:
112                      String startLine;
113                      Uint32 contentLength;
114                      Array<HTTPHeader> headers;
115                  
116                      httpMessage->parse(startLine, headers, contentLength);
117                  
118                      // ex.: 'Accept: text/html,application/xhtml+xml,
119                      //       application/xml;q=0.9,*/*;q=0.8'
120                      const char* acceptMimeTypesHeader;
121                      Boolean acceptMimeTypesHeaderFound = HTTPMessage::lookupHeader(
122                              headers, "Accept", acceptMimeTypesHeader, false);
123                  
124                      //ex.: 'Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7'
125                      const char* charSetHeader;
126                      Boolean charSetHeaderFound = HTTPMessage::lookupHeader(
127 lawrence.luo 1.2         headers, "Accept-Charset", charSetHeader, false);
128                  
129                      //ex.: 'Accept-Encoding: gzip,deflate'
130                      //Not supported yet
131                      const char* encHeader = NULL;
132                      Boolean encHeaderFound = HTTPMessage::lookupHeader(
133                          headers, "Accept-Encoding", encHeader, false);
134                  
135                  
136                      // Parse the request line:
137                      String methodName;
138                      String requestUri;
139                      String httpVersion;
140                  
141                      HTTPMessage::parseRequestLine(
142                          startLine, methodName, requestUri, httpVersion);
143                  
144                      PEG_TRACE((TRC_WEBSERVER, Tracer::LEVEL4,
145                              "WebServer::handleHTTPMessage(HTTPMessage* httpMessage) - QueueID"
146                              " %d: methodName [%s], requestUri [%s], httpVersion [%s],"
147                              "mimeTypes [%s], charSets [%s], encoding [%s]",
148 lawrence.luo 1.2             httpMessage->queueId,
149                              (const char*)methodName.getCString(),
150                              (const char*)requestUri.getCString(),
151                              (const char*)httpVersion.getCString(),
152                              (acceptMimeTypesHeaderFound ? acceptMimeTypesHeader : "NOT FOUND"),
153                              (charSetHeaderFound ? charSetHeader : "NOT FOUND"),
154                              (encHeaderFound ? encHeader : "NOT FOUND")));
155                  
156                      WebRequest* webRequest = new WebRequest(httpMessage->queueId);
157                  
158                      // set method name
159                      if ("GET" == methodName)
160                      {
161                          webRequest->httpMethod = HTTP_METHOD_GET;
162                      }
163                      else if ("HEAD" == methodName)
164                      {
165                          webRequest->httpMethod = HTTP_METHOD_HEAD;
166                      }
167                  
168                      if (acceptMimeTypesHeaderFound)
169 lawrence.luo 1.2     {
170                          webRequest->mimeTypes = String(acceptMimeTypesHeader);
171                      }
172                  
173                      if (charSetHeaderFound)
174                      {
175                          webRequest->charSets = String(charSetHeader);
176                      }
177                  
178                      if (encHeaderFound)
179                      {
180                          webRequest->encodings = String(encHeader);
181                      }
182                  
183                      webRequest->requestURI = String(requestUri);
184                      webRequest->httpVersion = httpVersion;
185                  
186                      // Save userName and authType:
187                      webRequest->userName = httpMessage->authInfo->getAuthenticatedUser();
188                      webRequest->authType = httpMessage->authInfo->getAuthType();
189                      webRequest->ipAddress = httpMessage->ipAddress;
190 lawrence.luo 1.2     
191                      //for ex.: 'Accept-Language: de-de,de;q=0.8,en-us;q=0.5,en;q=0.3'
192                      webRequest->acceptLanguages = httpMessage->acceptLanguages;
193                  
194                      /*
195                       * TODO async processing in thread.
196                       * Take care of userid/authorization
197                       */
198                      _webProcessor.handleWebRequest(webRequest);
199                  
200                      PEG_METHOD_EXIT();
201                  }
202                  
203                  
204                  void WebServer::handleResponse(HTTPMessage* response)
205                  {
206                  
207                      PEG_METHOD_ENTER(TRC_WEBSERVER, "WebServer::handleResponse()");
208                  
209                      Uint32 queueId = response->queueId;
210                      MessageQueue* queue = MessageQueue::lookup(queueId);
211 lawrence.luo 1.2     AutoPtr<HTTPMessage> httpMessage(response);
212                  
213                      if (!queue)
214                      {
215                          PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
216                              "ERROR: non-existent queueId = %u, response not sent.", queueId));
217                          PEG_METHOD_EXIT();
218                          return;
219                      }
220                      PEGASUS_ASSERT(dynamic_cast<HTTPConnection*>(queue) != 0);
221                  
222                      httpMessage->dest = queue->getQueueId();
223                      queue->enqueue(httpMessage.release());
224                  
225                      PEG_METHOD_EXIT();
226                  }
227                  
228                  PEGASUS_NAMESPACE_END