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   // close libcurl
 127   curl_global_cleanup();
 128 }
 129
 130 void DllLibCurlGlobal::CheckIdle()
 131 {
 132   std::unique_lock<CCriticalSection> lock(m_critSection);
 133   /* 20 seconds idle time before closing handle */
 134   const unsigned int idletime = 30000;
 135
 136   VEC_CURLSESSIONS::iterator it = m_sessions.begin();
 137   while (it != m_sessions.end())
 138   {
 139     auto now = std::chrono::steady_clock::now();
 140     auto duration =
 141         std::chrono::duration_cast<std::chrono::milliseconds>(now - it->m_idletimestamp);
 142
 143     if (!it->m_busy && duration.count() > idletime)
 144     {
 145       CLog::Log(LOGDEBUG, "{} - Closing session to {}://{} (easy={}, multi={})", __FUNCTION__,
 146                 it->m_protocol, it->m_hostname, fmt::ptr(it->m_easy), fmt::ptr(it->m_multi));
 147
 148       if (it->m_multi && it->m_easy)
 149         multi_remove_handle(it->m_multi, it->m_easy);
 150       if (it->m_easy)
 151         easy_cleanup(it->m_easy);
 152       if (it->m_multi)
 153         multi_cleanup(it->m_multi);
 154
 155       it = m_sessions.erase(it);
 156       continue;
 157     }
 158     ++it;
 159   }
 160 }
 161
 162 void DllLibCurlGlobal::easy_acquire(const char* protocol,
 163                                     const char* hostname,
 164                                     CURL_HANDLE** easy_handle,
 165                                     CURLM** multi_handle)
 166 {
 167   assert(easy_handle != NULL);
 168
 169   std::unique_lock<CCriticalSection> lock(m_critSection);
 170
 171   for (auto& it : m_sessions)
 172   {
 173     if (!it.m_busy)
 174     {
 175       /* allow reuse of requester is trying to connect to same host */
 176       /* curl will take care of any differences in username/password */
 177       if (it.m_protocol.compare(protocol) == 0 && it.m_hostname.compare(hostname) == 0)
 178       {
 179         it.m_busy = true;
 180         if (easy_handle)
 181         {
 182           if (!it.m_easy)
 183             it.m_easy = easy_init();
 184
 185           *easy_handle = it.m_easy;
 186         }
 187
 188         if (multi_handle)
 189         {
 190           if (!it.m_multi)
 191             it.m_multi = multi_init();
 192
 193           *multi_handle = it.m_multi;
 194         }
 195
 196         return;
 197       }
 198     }
 199   }
 200
 201   SSession session = {};
 202   session.m_busy = true;
 203   session.m_protocol = protocol;
 204   session.m_hostname = hostname;
 205
 206   if (easy_handle)
 207   {
 208     session.m_easy = easy_init();
 209     *easy_handle = session.m_easy;
 210   }
 211
 212   if (multi_handle)
 213   {
 214     session.m_multi = multi_init();
 215     *multi_handle = session.m_multi;
 216   }
 217
 218   m_sessions.push_back(session);
 219
 220   CLog::Log(LOGDEBUG, "{} - Created session to {}://{}", __FUNCTION__, protocol, hostname);
 221 }
 222
 223 void DllLibCurlGlobal::easy_release(CURL_HANDLE** easy_handle, CURLM** multi_handle)
 224 {
 225   std::unique_lock<CCriticalSection> lock(m_critSection);
 226
 227   CURL_HANDLE* easy = NULL;
 228   CURLM* multi = NULL;
 229
 230   if (easy_handle)
 231   {
 232     easy = *easy_handle;
 233     *easy_handle = NULL;
 234   }
 235
 236   if (multi_handle)
 237   {
 238     multi = *multi_handle;
 239     *multi_handle = NULL;
 240   }
 241
 242   for (auto& it : m_sessions)
 243   {
 244     if (it.m_easy == easy && (multi == nullptr || it.m_multi == multi))
 245     {
 246       /* reset session so next caller doesn't reuse options, only connections */
 247       /* will reset verbose too so it won't print that it closed connections on cleanup*/
 248       easy_reset(easy);
 249       it.m_busy = false;
 250       it.m_idletimestamp = std::chrono::steady_clock::now();
 251       return;
 252     }
 253   }
 254 }
 255
 256 CURL_HANDLE* DllLibCurlGlobal::easy_duphandle(CURL_HANDLE* easy_handle)
 257 {
 258   std::unique_lock<CCriticalSection> lock(m_critSection);
 259
 260   for (const auto& it : m_sessions)
 261   {
 262     if (it.m_easy == easy_handle)
 263     {
 264       SSession session = it;
 265       session.m_easy = DllLibCurl::easy_duphandle(easy_handle);
 266       m_sessions.push_back(session);
 267       return session.m_easy;
 268     }
 269   }
 270   return DllLibCurl::easy_duphandle(easy_handle);
 271 }
 272
 273 void DllLibCurlGlobal::easy_duplicate(CURL_HANDLE* easy,
 274                                       const CURLM* multi,
 275                                       CURL_HANDLE** easy_out,
 276                                       CURLM** multi_out)
 277 {
 278   std::unique_lock<CCriticalSection> lock(m_critSection);
 279
 280   if (easy_out && easy)
 281     *easy_out = DllLibCurl::easy_duphandle(easy);
 282
 283   if (multi_out && multi)
 284     *multi_out = DllLibCurl::multi_init();
 285
 286   for (const auto& it : m_sessions)
 287   {
 288     if (it.m_easy == easy)
 289     {
 290       SSession session = it;
 291       if (easy_out && easy)
 292         session.m_easy = *easy_out;
 293       else
 294         session.m_easy = NULL;
 295
 296       if (multi_out && multi)
 297         session.m_multi = *multi_out;
 298       else
 299         session.m_multi = NULL;
 300
 301       m_sessions.push_back(session);
 302       return;
 303     }
 304   }
 305 }
 306 } // namespace XCURL