lib/libUPnP/Platinum/Source/Core/PltHttpClientTask.cpp

   1 /*****************************************************************
   2 |
   3 |   Platinum - HTTP Client Tasks
   4 |
   5 | Copyright (c) 2004-2010, Plutinosoft, LLC.
   6 | All rights reserved.
   7 | http://www.plutinosoft.com
   8 |
   9 | This program is free software; you can redistribute it and/or
  10 | modify it under the terms of the GNU General Public License
  11 | as published by the Free Software Foundation; either version 2
  12 | of the License, or (at your option) any later version.
  13 |
  14 | OEMs, ISVs, VARs and other distributors that combine and
  15 | distribute commercially licensed software with Platinum software
  16 | and do not wish to distribute the source code for the commercially
  17 | licensed software under version 2, or (at your option) any later
  18 | version, of the GNU General Public License (the "GPL") must enter
  19 | into a commercial license agreement with Plutinosoft, LLC.
  20 | licensing@plutinosoft.com
  21 |
  22 | This program is distributed in the hope that it will be useful,
  23 | but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 | GNU General Public License for more details.
  26 |
  27 | You should have received a copy of the GNU General Public License
  28 | along with this program; see the file LICENSE.txt. If not, write to
  29 | the Free Software Foundation, Inc.,
  30 | 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  31 | http://www.gnu.org/licenses/gpl-2.0.html
  32 |
  33 ****************************************************************/
  34
  35 /*----------------------------------------------------------------------
  36 |   includes
  37 +---------------------------------------------------------------------*/
  38 #include "PltHttpClientTask.h"
  39 #include "PltConstants.h"
  40
  41 NPT_SET_LOCAL_LOGGER("platinum.core.http.clienttask")
  42
  43 /*----------------------------------------------------------------------
  44 |   PLT_HttpClientSocketTask::PLT_HttpClientSocketTask
  45 +---------------------------------------------------------------------*/
  46 PLT_HttpClientSocketTask::PLT_HttpClientSocketTask(NPT_HttpRequest* request /* = NULL */,
  47                                                    bool             wait_forever /* = false */) :
  48     m_WaitForever(wait_forever)
  49 {
  50     m_Client.SetUserAgent(*PLT_Constants::GetInstance().GetDefaultUserAgent());
  51     m_Client.SetTimeouts(60000, 60000, 60000);
  52     if (request) m_Requests.Push(request);
  53 }
  54
  55 /*----------------------------------------------------------------------
  56 |   PLT_HttpClientSocketTask::~PLT_HttpClientSocketTask
  57 +---------------------------------------------------------------------*/
  58 PLT_HttpClientSocketTask::~PLT_HttpClientSocketTask()
  59 {
  60     // delete any outstanding requests
  61     NPT_HttpRequest* request;
  62     while (NPT_SUCCEEDED(m_Requests.Pop(request, false))) {
  63         delete request;
  64     }
  65 }
  66
  67 /*----------------------------------------------------------------------
  68 |   PLT_HttpClientSocketTask::SetHttpClientConfig
  69 +---------------------------------------------------------------------*/
  70 NPT_Result
  71 PLT_HttpClientSocketTask::SetHttpClientConfig(const NPT_HttpClient::Config& config)
  72 {
  73     return m_Client.SetConfig(config);
  74 }
  75
  76 /*----------------------------------------------------------------------
  77 |   PLT_HttpClientSocketTask::AddRequest
  78 +---------------------------------------------------------------------*/
  79 NPT_Result
  80 PLT_HttpClientSocketTask::AddRequest(NPT_HttpRequest* request)
  81 {
  82     return m_Requests.Push(request);
  83 }
  84
  85 /*----------------------------------------------------------------------
  86 |   PLT_HttpClientSocketTask::GetNextRequest
  87 +---------------------------------------------------------------------*/
  88 NPT_Result
  89 PLT_HttpClientSocketTask::GetNextRequest(NPT_HttpRequest*& request, NPT_Timeout timeout_ms)
  90 {
  91     return m_Requests.Pop(request, timeout_ms);
  92 }
  93
  94 /*----------------------------------------------------------------------
  95 |   PLT_HttpClientSocketTask::DoAbort
  96 +---------------------------------------------------------------------*/
  97 void
  98 PLT_HttpClientSocketTask::DoAbort()
  99 {
 100     m_Client.Abort();
 101 }
 102
 103 /*----------------------------------------------------------------------
 104 |   PLT_HttpClientSocketTask::DoRun
 105 +---------------------------------------------------------------------*/
 106 void
 107 PLT_HttpClientSocketTask::DoRun()
 108 {
 109     NPT_HttpRequest*       request = NULL;
 110     NPT_HttpResponse*      response = NULL;
 111     NPT_HttpRequestContext context;
 112     NPT_Result             res;
 113     NPT_TimeStamp          watchdog;
 114
 115     NPT_System::GetCurrentTimeStamp(watchdog);
 116
 117     do {
 118         // pop next request or wait for one for 100ms
 119         while (NPT_SUCCEEDED(GetNextRequest(request, 100))) {
 120             response = NULL;
 121
 122             if (IsAborting(0)) goto abort;
 123
 124             // send request
 125             res = m_Client.SendRequest(*request, response, &context);
 126
 127             NPT_String prefix = NPT_String::Format("PLT_HttpClientSocketTask::DoRun (res = %d):", res);
 128             PLT_LOG_HTTP_RESPONSE(NPT_LOG_LEVEL_FINER, prefix, response);
 129
 130             // process response
 131             ProcessResponse(res, *request, context, response);
 132
 133             // cleanup
 134             delete response;
 135             response = NULL;
 136             delete request;
 137             request = NULL;
 138         }
 139
 140         // DLNA requires that we abort unanswered/unused sockets after 60 secs
 141         NPT_TimeStamp now;
 142         NPT_System::GetCurrentTimeStamp(now);
 143         if (now > watchdog + NPT_TimeInterval(60.)) {
 144             NPT_HttpConnectionManager::GetInstance()->Recycle(NULL);
 145             watchdog = now;
 146         }
 147
 148     } while (m_WaitForever && !IsAborting(0));
 149
 150 abort:
 151     if (request) delete request;
 152     if (response) delete response;
 153 }
 154
 155 /*----------------------------------------------------------------------
 156 |   PLT_HttpClientSocketTask::ProcessResponse
 157 +---------------------------------------------------------------------*/
 158 NPT_Result
 159 PLT_HttpClientSocketTask::ProcessResponse(NPT_Result                    res,
 160                                           const NPT_HttpRequest&        request,
 161                                           const NPT_HttpRequestContext& context,
 162                                           NPT_HttpResponse*             response)
 163 {
 164     NPT_COMPILER_UNUSED(request);
 165     NPT_COMPILER_UNUSED(context);
 166
 167     NPT_LOG_FINE_1("PLT_HttpClientSocketTask::ProcessResponse (result=%d)", res);
 168     NPT_CHECK_WARNING(res);
 169
 170     NPT_CHECK_POINTER_WARNING(response);
 171
 172     // check if there's a body to read
 173     NPT_HttpEntity* entity;
 174     NPT_InputStreamReference body;
 175     if (!(entity = response->GetEntity()) ||
 176         NPT_FAILED(entity->GetInputStream(body)) ||
 177         body.IsNull()) {
 178         return NPT_SUCCESS;
 179     }
 180
 181     // dump body into ether
 182     // (if no content-length specified, read until disconnected)
 183     NPT_NullOutputStream output;
 184     NPT_CHECK_SEVERE(NPT_StreamToStreamCopy(*body,
 185                                             output,
 186                                             0,
 187                                             entity->GetContentLength()));
 188
 189     return NPT_SUCCESS;
 190 }