src/addon/downloader.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2007 Christoph Sommer <christoph.sommer@2007.expires.deltadevelopment.de>
   3 //                2014 Ingo Ruhnke <grumbel@gmail.com>
   4 //
   5 //  This program is free software: you can redistribute it and/or modify
   6 //  it under the terms of the GNU General Public License as published by
   7 //  the Free Software Foundation, either version 3 of the License, or
   8 //  (at your option) any later version.
   9 //
  10 //  This program is distributed in the hope that it will be useful,
  11 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 //  GNU General Public License for more details.
  14 //
  15 //  You should have received a copy of the GNU General Public License
  16 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 #include "addon/downloader.hpp"
  19
  20 #include <algorithm>
  21 #include <memory>
  22 #include <physfs.h>
  23 #include <stdexcept>
  24
  25 #include "util/log.hpp"
  26 #include "version.h"
  27
  28 namespace {
  29
  30 size_t my_curl_string_append(void* ptr, size_t size, size_t nmemb, void* userdata)
  31 {
  32   std::string& s = *static_cast<std::string*>(userdata);
  33   std::string buf(static_cast<char*>(ptr), size * nmemb);
  34   s += buf;
  35   log_debug << "read " << size * nmemb << " bytes of data..." << std::endl;
  36   return size * nmemb;
  37 }
  38
  39 size_t my_curl_physfs_write(void* ptr, size_t size, size_t nmemb, void* userdata)
  40 {
  41   PHYSFS_file* f = static_cast<PHYSFS_file*>(userdata);
  42   PHYSFS_sint64 written = PHYSFS_write(f, ptr, size, nmemb);
  43   log_debug << "read " << size * nmemb << " bytes of data..." << std::endl;
  44   return size * written;
  45 }
  46
  47 } // namespace
  48
  49 class Transfer
  50 {
  51 private:
  52   Downloader& m_downloader;
  53   TransferId m_id;
  54
  55   std::string m_url;
  56   CURL* m_handle;
  57   std::array<char, CURL_ERROR_SIZE> m_error_buffer;
  58
  59   TransferStatusPtr m_status;
  60
  61 public:
  62   Transfer(Downloader& downloader, TransferId id, const std::string& url) :
  63     m_downloader(downloader),
  64     m_id(id),
  65     m_url(url),
  66     m_handle(curl_easy_init()),
  67     m_error_buffer(),
  68     m_status(new TransferStatus(id))
  69   {
  70     if (!m_handle)
  71     {
  72       throw std::runtime_error("curl_easy_init() failed");
  73     }
  74     else
  75     {
  76       curl_easy_setopt(m_handle, CURLOPT_URL, url.c_str());
  77       curl_easy_setopt(m_handle, CURLOPT_USERAGENT, "SuperTux/" PACKAGE_VERSION " libcURL");
  78
  79       curl_easy_setopt(m_handle, CURLOPT_WRITEDATA, this);
  80       curl_easy_setopt(m_handle, CURLOPT_WRITEFUNCTION,
  81                        [](void* ptr, size_t size, size_t nmemb, void* userdata) -> size_t
  82                        {
  83                          return static_cast<Transfer*>(userdata)
  84                            ->on_data(ptr, size, nmemb);
  85                        });
  86
  87       curl_easy_setopt(m_handle, CURLOPT_ERRORBUFFER, m_error_buffer.data());
  88       curl_easy_setopt(m_handle, CURLOPT_NOSIGNAL, 1);
  89       curl_easy_setopt(m_handle, CURLOPT_FAILONERROR, 1);
  90       curl_easy_setopt(m_handle, CURLOPT_FOLLOWLOCATION, 1);
  91
  92       curl_easy_setopt(m_handle, CURLOPT_NOPROGRESS, 0);
  93       curl_easy_setopt(m_handle, CURLOPT_XFERINFODATA, this);
  94       curl_easy_setopt(m_handle, CURLOPT_XFERINFOFUNCTION,
  95                        [](void* userdata,
  96                           curl_off_t dltotal, curl_off_t dlnow,
  97                           curl_off_t ultotal, curl_off_t ulnow)
  98                        {
  99                          return static_cast<Transfer*>(userdata)
 100                            ->on_progress(dltotal, dlnow,
 101                                          ultotal, ulnow);
 102                        });
 103     }
 104   }
 105
 106   ~Transfer()
 107   {
 108     curl_easy_cleanup(m_handle);
 109   }
 110
 111   TransferStatusPtr get_status() const
 112   {
 113     return m_status;
 114   }
 115
 116   TransferId get_id() const
 117   {
 118     return m_id;
 119   }
 120
 121   CURL* get_curl_handle() const
 122   {
 123     return m_handle;
 124   }
 125
 126   std::string get_url() const
 127   {
 128     return m_url;
 129   }
 130
 131   size_t on_data(void* ptr, size_t size, size_t nmemb)
 132   {
 133     return size * nmemb;;
 134   }
 135
 136   void on_progress(curl_off_t dltotal, curl_off_t dlnow,
 137                    curl_off_t ultotal, curl_off_t ulnow)
 138   {
 139     m_status->dltotal = dltotal;
 140     m_status->dlnow = dlnow;
 141
 142     m_status->ultotal = ultotal;
 143     m_status->ulnow = ulnow;
 144   }
 145
 146 private:
 147   Transfer(const Transfer&) = delete;
 148   Transfer& operator=(const Transfer&) = delete;
 149 };
 150
 151 Downloader::Downloader() :
 152   m_multi_handle(),
 153   m_transfers(),
 154   m_next_transfer_id(1)
 155 {
 156   curl_global_init(CURL_GLOBAL_ALL);
 157   m_multi_handle = curl_multi_init();
 158   if (!m_multi_handle)
 159   {
 160     throw std::runtime_error("curl_multi_init() failed");
 161   }
 162 }
 163
 164 Downloader::~Downloader()
 165 {
 166   for(auto& transfer : m_transfers)
 167   {
 168     curl_multi_remove_handle(m_multi_handle, transfer->get_curl_handle());
 169   }
 170   m_transfers.clear();
 171
 172   curl_multi_cleanup(m_multi_handle);
 173   curl_global_cleanup();
 174 }
 175
 176 void
 177 Downloader::download(const std::string& url,
 178                      size_t (*write_func)(void* ptr, size_t size, size_t nmemb, void* userdata),
 179                      void* userdata)
 180 {
 181   log_info << "Downloading " << url << std::endl;
 182
 183   char error_buffer[CURL_ERROR_SIZE+1];
 184
 185   CURL* curl_handle = curl_easy_init();
 186   curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str());
 187   curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "SuperTux/" PACKAGE_VERSION " libcURL");
 188   curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_func);
 189   curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, userdata);
 190   curl_easy_setopt(curl_handle, CURLOPT_ERRORBUFFER, error_buffer);
 191   curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1);
 192   curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1);
 193   curl_easy_setopt(curl_handle, CURLOPT_FAILONERROR, 1);
 194   curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1);
 195   CURLcode result = curl_easy_perform(curl_handle);
 196   curl_easy_cleanup(curl_handle);
 197
 198   if (result != CURLE_OK)
 199   {
 200     std::string why = error_buffer[0] ? error_buffer : "unhandled error";
 201     throw std::runtime_error(url + ": download failed: " + why);
 202   }
 203 }
 204
 205 std::string
 206 Downloader::download(const std::string& url)
 207 {
 208   std::string result;
 209   download(url, my_curl_string_append, &result);
 210   return result;
 211 }
 212
 213 void
 214 Downloader::download(const std::string& url, const std::string& filename)
 215 {
 216   std::unique_ptr<PHYSFS_file, int(*)(PHYSFS_File*)> fout(PHYSFS_openWrite(filename.c_str()),
 217                                                           PHYSFS_close);
 218   download(url, my_curl_physfs_write, fout.get());
 219 }
 220
 221 void
 222 Downloader::abort(TransferId id)
 223 {
 224   auto it = std::find_if(m_transfers.begin(), m_transfers.end(),
 225                          [&id](const std::unique_ptr<Transfer>& rhs)
 226                          {
 227                            return id == rhs->get_id();
 228                          });
 229   if (it == m_transfers.end())
 230   {
 231     log_warning << "transfer not found: " << id << std::endl;
 232   }
 233   else
 234   {
 235     curl_multi_remove_handle(m_multi_handle, (*it)->get_curl_handle());
 236     m_transfers.erase(it);
 237   }
 238 }
 239
 240 void
 241 Downloader::update()
 242 {
 243   // read data from the network
 244   CURLMcode ret;
 245   int running_handles;
 246   while((ret = curl_multi_perform(m_multi_handle, &running_handles)) == CURLM_CALL_MULTI_PERFORM)
 247   {
 248     log_debug << "updating" << std::endl;
 249   }
 250
 251   // check if any downloads got finished
 252   int msgs_in_queue;
 253   CURLMsg* msg;
 254   while ((msg = curl_multi_info_read(m_multi_handle, &msgs_in_queue)))
 255   {
 256     switch(msg->msg)
 257     {
 258       case CURLMSG_DONE:
 259         curl_multi_remove_handle(m_multi_handle, msg->easy_handle);
 260         //FIXME: finish_transfer(msg->easy_handle);
 261         break;
 262
 263       default:
 264         log_warning << "unhandled cURL message: " << msg->msg << std::endl;
 265         break;
 266     }
 267   }
 268 }
 269
 270 TransferStatusPtr
 271 Downloader::request_download(const std::string& url, const std::string& filename)
 272 {
 273   std::unique_ptr<Transfer> transfer(new Transfer(*this, m_next_transfer_id++, url));
 274   curl_multi_add_handle(m_multi_handle, transfer->get_curl_handle());
 275   m_transfers.push_back(std::move(transfer));
 276   return m_transfers.back()->get_status();
 277 }
 278
 279 /* EOF */