xbmc/filesystem/DllLibCurl.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "DllLibCurl.h"
  10
  11 #include "threads/SystemClock.h"
  12 #include "utils/log.h"
  13
  14 #include <assert.h>
  15 #include <mutex>
  16
  17 namespace XCURL
  18 {
  19 CURLcode DllLibCurl::global_init(long flags)
  20 {
  21   return curl_global_init(flags);
  22 }
  23
  24 void DllLibCurl::global_cleanup()
  25 {
  26   curl_global_cleanup();
  27 }
  28
  29 CURL_HANDLE* DllLibCurl::easy_init()
  30 {
  31   return curl_easy_init();
  32 }
  33
  34 CURLcode DllLibCurl::easy_perform(CURL_HANDLE* handle)
  35 {
  36   return curl_easy_perform(handle);
  37 }
  38
  39 CURLcode DllLibCurl::easy_pause(CURL_HANDLE* handle, int bitmask)
  40 {
  41   return curl_easy_pause(handle, bitmask);
  42 }
  43
  44 void DllLibCurl::easy_reset(CURL_HANDLE* handle)
  45 {
  46   curl_easy_reset(handle);
  47 }
  48
  49 void DllLibCurl::easy_cleanup(CURL_HANDLE* handle)
  50 {
  51   curl_easy_cleanup(handle);
  52 }
  53
  54 CURL_HANDLE* DllLibCurl::easy_duphandle(CURL_HANDLE* handle)
  55 {
  56   return curl_easy_duphandle(handle);
  57 }
  58
  59 CURLM* DllLibCurl::multi_init()
  60 {
  61   return curl_multi_init();
  62 }
  63
  64 CURLMcode DllLibCurl::multi_add_handle(CURLM* multi_handle, CURL_HANDLE* easy_handle)
  65 {
  66   return curl_multi_add_handle(multi_handle, easy_handle);
  67 }
  68
  69 CURLMcode DllLibCurl::multi_perform(CURLM* multi_handle, int* running_handles)
  70 {
  71   return curl_multi_perform(multi_handle, running_handles);
  72 }
  73
  74 CURLMcode DllLibCurl::multi_remove_handle(CURLM* multi_handle, CURL_HANDLE* easy_handle)
  75 {
  76   return curl_multi_remove_handle(multi_handle, easy_handle);
  77 }
  78
  79 CURLMcode DllLibCurl::multi_fdset(
  80     CURLM* multi_handle, fd_set* read_fd_set, fd_set* write_fd_set, fd_set* exc_fd_set, int* max_fd)
  81 {
  82   return curl_multi_fdset(multi_handle, read_fd_set, write_fd_set, exc_fd_set, max_fd);
  83 }
  84
  85 CURLMcode DllLibCurl::multi_timeout(CURLM* multi_handle, long* timeout)
  86 {
  87   return curl_multi_timeout(multi_handle, timeout);
  88 }
  89
  90 CURLMsg* DllLibCurl::multi_info_read(CURLM* multi_handle, int* msgs_in_queue)
  91 {
  92   return curl_multi_info_read(multi_handle, msgs_in_queue);
  93 }
  94
  95 CURLMcode DllLibCurl::multi_cleanup(CURLM* handle)
  96 {
  97   return curl_multi_cleanup(handle);
  98 }
  99
 100 curl_slist* DllLibCurl::slist_append(curl_slist* list, const char* to_append)
 101 {
 102   return curl_slist_append(list, to_append);
 103 }
 104
 105 void DllLibCurl::slist_free_all(curl_slist* list)
 106 {
 107   curl_slist_free_all(list);
 108 }
 109
 110 const char* DllLibCurl::easy_strerror(CURLcode code)
 111 {
 112   return curl_easy_strerror(code);
 113 }
 114
 115 DllLibCurlGlobal::DllLibCurlGlobal()
 116 {
 117   /* we handle this ourself */
 118   if (curl_global_init(CURL_GLOBAL_ALL))
 119   {
 120     CLog::Log(LOGERROR, "Error initializing libcurl");
 121   }
 122 }
 123
 124 DllLibCurlGlobal::~DllLibCurlGlobal()
 125 {
 126   for (auto& session : m_sessions)
 127   {
 128     if (session.m_multi && session.m_easy)
 129       multi_remove_handle(session.m_multi, session.m_easy);
 130     if (session.m_easy)
 131       easy_cleanup(session.m_easy);
 132     if (session.m_multi)
 133       multi_cleanup(session.m_multi);
 134   }
 135   // close libcurl
 136   curl_global_cleanup();
 137 }
 138
 139 void DllLibCurlGlobal::CheckIdle()
 140 {
 141   std::unique_lock<CCriticalSection> lock(m_critSection);
 142   /* 20 seconds idle time before closing handle */
 143   const unsigned int idletime = 30000;
 144
 145   VEC_CURLSESSIONS::iterator it = m_sessions.begin();
 146   while (it != m_sessions.end())
 147   {
 148     auto now = std::chrono::steady_clock::now();
 149     auto duration =
 150         std::chrono::duration_cast<std::chrono::milliseconds>(now - it->m_idletimestamp);
 151
 152     if (!it->m_busy && duration.count() > idletime)
 153     {
 154       CLog::Log(LOGDEBUG, "{} - Closing session to {}://{} (easy={}, multi={})", __FUNCTION__,
 155                 it->m_protocol, it->m_hostname, fmt::ptr(it->m_easy), fmt::ptr(it->m_multi));
 156
 157       if (it->m_multi && it->m_easy)
 158         multi_remove_handle(it->m_multi, it->m_easy);
 159       if (it->m_easy)
 160         easy_cleanup(it->m_easy);
 161       if (it->m_multi)
 162         multi_cleanup(it->m_multi);
 163
 164       it = m_sessions.erase(it);
 165       continue;
 166     }
 167     ++it;
 168   }
 169 }
 170
 171 void DllLibCurlGlobal::easy_acquire(const char* protocol,
 172                                     const char* hostname,
 173                                     CURL_HANDLE** easy_handle,
 174                                     CURLM** multi_handle)
 175 {
 176   assert(easy_handle != NULL);
 177
 178   std::unique_lock<CCriticalSection> lock(m_critSection);
 179
 180   for (auto& it : m_sessions)
 181   {
 182     if (!it.m_busy)
 183     {
 184       /* allow reuse of requester is trying to connect to same host */
 185       /* curl will take care of any differences in username/password */
 186       if (it.m_protocol.compare(protocol) == 0 && it.m_hostname.compare(hostname) == 0)
 187       {
 188         it.m_busy = true;
 189         if (easy_handle)
 190         {
 191           if (!it.m_easy)
 192             it.m_easy = easy_init();
 193
 194           *easy_handle = it.m_easy;
 195         }
 196
 197         if (multi_handle)
 198         {
 199           if (!it.m_multi)
 200             it.m_multi = multi_init();
 201
 202           *multi_handle = it.m_multi;
 203         }
 204
 205         return;
 206       }
 207     }
 208   }
 209
 210   SSession session = {};
 211   session.m_busy = true;
 212   session.m_protocol = protocol;
 213   session.m_hostname = hostname;
 214
 215   if (easy_handle)
 216   {
 217     session.m_easy = easy_init();
 218     *easy_handle = session.m_easy;
 219   }
 220
 221   if (multi_handle)
 222   {
 223     session.m_multi = multi_init();
 224     *multi_handle = session.m_multi;
 225   }
 226
 227   m_sessions.push_back(session);
 228
 229   CLog::Log(LOGDEBUG, "{} - Created session to {}://{}", __FUNCTION__, protocol, hostname);
 230 }
 231
 232 void DllLibCurlGlobal::easy_release(CURL_HANDLE** easy_handle, CURLM** multi_handle)
 233 {
 234   std::unique_lock<CCriticalSection> lock(m_critSection);
 235
 236   CURL_HANDLE* easy = NULL;
 237   CURLM* multi = NULL;
 238
 239   if (easy_handle)
 240   {
 241     easy = *easy_handle;
 242     *easy_handle = NULL;
 243   }
 244
 245   if (multi_handle)
 246   {
 247     multi = *multi_handle;
 248     *multi_handle = NULL;
 249   }
 250
 251   for (auto& it : m_sessions)
 252   {
 253     if (it.m_easy == easy && (multi == nullptr || it.m_multi == multi))
 254     {
 255       /* reset session so next caller doesn't reuse options, only connections */
 256       /* will reset verbose too so it won't print that it closed connections on cleanup*/
 257       easy_reset(easy);
 258       it.m_busy = false;
 259       it.m_idletimestamp = std::chrono::steady_clock::now();
 260       return;
 261     }
 262   }
 263 }
 264
 265 CURL_HANDLE* DllLibCurlGlobal::easy_duphandle(CURL_HANDLE* easy_handle)
 266 {
 267   std::unique_lock<CCriticalSection> lock(m_critSection);
 268
 269   for (const auto& it : m_sessions)
 270   {
 271     if (it.m_easy == easy_handle)
 272     {
 273       SSession session = it;
 274       session.m_easy = DllLibCurl::easy_duphandle(easy_handle);
 275       m_sessions.push_back(session);
 276       return session.m_easy;
 277     }
 278   }
 279   return DllLibCurl::easy_duphandle(easy_handle);
 280 }
 281
 282 void DllLibCurlGlobal::easy_duplicate(CURL_HANDLE* easy,
 283                                       const CURLM* multi,
 284                                       CURL_HANDLE** easy_out,
 285                                       CURLM** multi_out)
 286 {
 287   std::unique_lock<CCriticalSection> lock(m_critSection);
 288
 289   if (easy_out && easy)
 290     *easy_out = DllLibCurl::easy_duphandle(easy);
 291
 292   if (multi_out && multi)
 293     *multi_out = DllLibCurl::multi_init();
 294
 295   for (const auto& it : m_sessions)
 296   {
 297     if (it.m_easy == easy)
 298     {
 299       SSession session = it;
 300       if (easy_out && easy)
 301         session.m_easy = *easy_out;
 302       else
 303         session.m_easy = NULL;
 304
 305       if (multi_out && multi)
 306         session.m_multi = *multi_out;
 307       else
 308         session.m_multi = NULL;
 309
 310       m_sessions.push_back(session);
 311       return;
 312     }
 313   }
 314 }
 315 } // namespace XCURL