src/base/net/downloadmanager.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015, 2018  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "downloadmanager.h"
  31
  32 #include <algorithm>
  33
  34 #include <QDateTime>
  35 #include <QDebug>
  36 #include <QNetworkAccessManager>
  37 #include <QNetworkCookie>
  38 #include <QNetworkCookieJar>
  39 #include <QNetworkProxy>
  40 #include <QNetworkReply>
  41 #include <QNetworkRequest>
  42 #include <QSslError>
  43 #include <QUrl>
  44
  45 #include "base/global.h"
  46 #include "base/logger.h"
  47 #include "base/preferences.h"
  48 #include "downloadhandlerimpl.h"
  49 #include "proxyconfigurationmanager.h"
  50
  51 namespace
  52 {
  53     // Disguise as Firefox to avoid web server banning
  54     const char DEFAULT_USER_AGENT[] = "Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0";
  55 }
  56
  57 class Net::DownloadManager::NetworkCookieJar final : public QNetworkCookieJar
  58 {
  59 public:
  60     explicit NetworkCookieJar(QObject *parent = nullptr)
  61         : QNetworkCookieJar(parent)
  62     {
  63         const QDateTime now = QDateTime::currentDateTime();
  64         QList<QNetworkCookie> cookies = Preferences::instance()->getNetworkCookies();
  65         for (const QNetworkCookie &cookie : asConst(Preferences::instance()->getNetworkCookies()))
  66         {
  67             if (cookie.isSessionCookie() || (cookie.expirationDate() <= now))
  68                 cookies.removeAll(cookie);
  69         }
  70
  71         setAllCookies(cookies);
  72     }
  73
  74     ~NetworkCookieJar() override
  75     {
  76         const QDateTime now = QDateTime::currentDateTime();
  77         QList<QNetworkCookie> cookies = allCookies();
  78         for (const QNetworkCookie &cookie : asConst(allCookies()))
  79         {
  80             if (cookie.isSessionCookie() || (cookie.expirationDate() <= now))
  81                 cookies.removeAll(cookie);
  82         }
  83
  84         Preferences::instance()->setNetworkCookies(cookies);
  85     }
  86
  87     using QNetworkCookieJar::allCookies;
  88     using QNetworkCookieJar::setAllCookies;
  89
  90     QList<QNetworkCookie> cookiesForUrl(const QUrl &url) const override
  91     {
  92         const QDateTime now = QDateTime::currentDateTime();
  93         QList<QNetworkCookie> cookies = QNetworkCookieJar::cookiesForUrl(url);
  94         for (const QNetworkCookie &cookie : asConst(QNetworkCookieJar::cookiesForUrl(url)))
  95         {
  96             if (!cookie.isSessionCookie() && (cookie.expirationDate() <= now))
  97                 cookies.removeAll(cookie);
  98         }
  99
 100         return cookies;
 101     }
 102
 103     bool setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url) override
 104     {
 105         const QDateTime now = QDateTime::currentDateTime();
 106         QList<QNetworkCookie> cookies = cookieList;
 107         for (const QNetworkCookie &cookie : cookieList)
 108         {
 109             if (!cookie.isSessionCookie() && (cookie.expirationDate() <= now))
 110                 cookies.removeAll(cookie);
 111         }
 112
 113         return QNetworkCookieJar::setCookiesFromUrl(cookies, url);
 114     }
 115 };
 116
 117 Net::DownloadManager *Net::DownloadManager::m_instance = nullptr;
 118
 119 Net::DownloadManager::DownloadManager(QObject *parent)
 120     : QObject(parent)
 121     , m_networkCookieJar {new NetworkCookieJar(this)}
 122     , m_networkManager {new QNetworkAccessManager(this)}
 123 {
 124     m_networkManager->setCookieJar(m_networkCookieJar);
 125     connect(m_networkManager, &QNetworkAccessManager::sslErrors, this
 126             , [](QNetworkReply *reply, const QList<QSslError> &errors)
 127     {
 128         QStringList errorList;
 129         for (const QSslError &error : errors)
 130             errorList += error.errorString();
 131         LogMsg(tr("Ignoring SSL error, URL: \"%1\", errors: \"%2\"").arg(reply->url().toString(), errorList.join(u". ")), Log::WARNING);
 132
 133         // Ignore all SSL errors
 134         reply->ignoreSslErrors();
 135     });
 136
 137     connect(ProxyConfigurationManager::instance(), &ProxyConfigurationManager::proxyConfigurationChanged
 138             , this, &DownloadManager::applyProxySettings);
 139     connect(Preferences::instance(), &Preferences::changed, this, &DownloadManager::applyProxySettings);
 140     applyProxySettings();
 141 }
 142
 143 void Net::DownloadManager::initInstance()
 144 {
 145     if (!m_instance)
 146         m_instance = new DownloadManager;
 147 }
 148
 149 void Net::DownloadManager::freeInstance()
 150 {
 151     delete m_instance;
 152     m_instance = nullptr;
 153 }
 154
 155 Net::DownloadManager *Net::DownloadManager::instance()
 156 {
 157     return m_instance;
 158 }
 159
 160 Net::DownloadHandler *Net::DownloadManager::download(const DownloadRequest &downloadRequest, const bool useProxy)
 161 {
 162     // Process download request
 163     const ServiceID id = ServiceID::fromURL(downloadRequest.url());
 164     const bool isSequentialService = m_sequentialServices.contains(id);
 165
 166     auto *downloadHandler = new DownloadHandlerImpl(this, downloadRequest, useProxy);
 167     connect(downloadHandler, &DownloadHandler::finished, downloadHandler, &QObject::deleteLater);
 168     connect(downloadHandler, &QObject::destroyed, this, [this, id, downloadHandler]()
 169     {
 170         m_waitingJobs[id].removeOne(downloadHandler);
 171     });
 172
 173     if (isSequentialService && m_busyServices.contains(id))
 174     {
 175         m_waitingJobs[id].enqueue(downloadHandler);
 176     }
 177     else
 178     {
 179         qDebug("Downloading %s...", qUtf8Printable(downloadRequest.url()));
 180         if (isSequentialService)
 181             m_busyServices.insert(id);
 182         processRequest(downloadHandler);
 183     }
 184
 185     return downloadHandler;
 186 }
 187
 188 void Net::DownloadManager::registerSequentialService(const Net::ServiceID &serviceID)
 189 {
 190     m_sequentialServices.insert(serviceID);
 191 }
 192
 193 QList<QNetworkCookie> Net::DownloadManager::cookiesForUrl(const QUrl &url) const
 194 {
 195     return m_networkCookieJar->cookiesForUrl(url);
 196 }
 197
 198 bool Net::DownloadManager::setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url)
 199 {
 200     return m_networkCookieJar->setCookiesFromUrl(cookieList, url);
 201 }
 202
 203 QList<QNetworkCookie> Net::DownloadManager::allCookies() const
 204 {
 205     return m_networkCookieJar->allCookies();
 206 }
 207
 208 void Net::DownloadManager::setAllCookies(const QList<QNetworkCookie> &cookieList)
 209 {
 210     m_networkCookieJar->setAllCookies(cookieList);
 211 }
 212
 213 bool Net::DownloadManager::deleteCookie(const QNetworkCookie &cookie)
 214 {
 215     return m_networkCookieJar->deleteCookie(cookie);
 216 }
 217
 218 bool Net::DownloadManager::hasSupportedScheme(const QString &url)
 219 {
 220     const QStringList schemes = QNetworkAccessManager().supportedSchemes();
 221     return std::any_of(schemes.cbegin(), schemes.cend(), [&url](const QString &scheme)
 222     {
 223         return url.startsWith((scheme + u':'), Qt::CaseInsensitive);
 224     });
 225 }
 226
 227 void Net::DownloadManager::applyProxySettings()
 228 {
 229     const auto *proxyManager = ProxyConfigurationManager::instance();
 230     const ProxyConfiguration proxyConfig = proxyManager->proxyConfiguration();
 231
 232     m_proxy = QNetworkProxy(QNetworkProxy::NoProxy);
 233
 234     if ((proxyConfig.type == Net::ProxyType::None) || (proxyConfig.type == ProxyType::SOCKS4))
 235         return;
 236
 237     // Proxy enabled
 238     if (proxyConfig.type == ProxyType::SOCKS5)
 239     {
 240         qDebug() << Q_FUNC_INFO << "using SOCKS proxy";
 241         m_proxy.setType(QNetworkProxy::Socks5Proxy);
 242     }
 243     else
 244     {
 245         qDebug() << Q_FUNC_INFO << "using HTTP proxy";
 246         m_proxy.setType(QNetworkProxy::HttpProxy);
 247     }
 248
 249     m_proxy.setHostName(proxyConfig.ip);
 250     m_proxy.setPort(proxyConfig.port);
 251
 252     // Authentication?
 253     if (proxyConfig.authEnabled)
 254     {
 255         qDebug("Proxy requires authentication, authenticating...");
 256         m_proxy.setUser(proxyConfig.username);
 257         m_proxy.setPassword(proxyConfig.password);
 258     }
 259
 260     if (proxyConfig.hostnameLookupEnabled)
 261         m_proxy.setCapabilities(m_proxy.capabilities() | QNetworkProxy::HostNameLookupCapability);
 262     else
 263         m_proxy.setCapabilities(m_proxy.capabilities() & ~QNetworkProxy::HostNameLookupCapability);
 264 }
 265
 266 void Net::DownloadManager::handleDownloadFinished(DownloadHandlerImpl *finishedHandler)
 267 {
 268     const ServiceID id = ServiceID::fromURL(finishedHandler->url());
 269     const auto waitingJobsIter = m_waitingJobs.find(id);
 270     if ((waitingJobsIter == m_waitingJobs.end()) || waitingJobsIter.value().isEmpty())
 271     {
 272         // No more waiting jobs for given ServiceID
 273         m_busyServices.remove(id);
 274         return;
 275     }
 276
 277     auto *handler = waitingJobsIter.value().dequeue();
 278     qDebug("Downloading %s...", qUtf8Printable(handler->url()));
 279     processRequest(handler);
 280     handler->disconnect(this);
 281 }
 282
 283 void Net::DownloadManager::processRequest(DownloadHandlerImpl *downloadHandler)
 284 {
 285     m_networkManager->setProxy((downloadHandler->useProxy() == true) ? m_proxy : QNetworkProxy(QNetworkProxy::NoProxy));
 286
 287     const DownloadRequest downloadRequest = downloadHandler->downloadRequest();
 288     QNetworkRequest request {downloadRequest.url()};
 289
 290     if (downloadRequest.userAgent().isEmpty())
 291         request.setRawHeader("User-Agent", DEFAULT_USER_AGENT);
 292     else
 293         request.setRawHeader("User-Agent", downloadRequest.userAgent().toUtf8());
 294
 295     // Spoof HTTP Referer to allow adding torrent link from Torcache/KickAssTorrents
 296     request.setRawHeader("Referer", request.url().toEncoded().data());
 297 #ifdef QT_NO_COMPRESS
 298     // The macro "QT_NO_COMPRESS" defined in QT will disable the zlib related features
 299     // and reply data auto-decompression in QT will also be disabled. But we can support
 300     // gzip encoding and manually decompress the reply data.
 301     request.setRawHeader("Accept-Encoding", "gzip");
 302 #endif
 303     // Qt doesn't support Magnet protocol so we need to handle redirections manually
 304     request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::ManualRedirectPolicy);
 305
 306     QNetworkReply *reply = m_networkManager->get(request);
 307     connect(reply, &QNetworkReply::finished, this, [this, downloadHandler]
 308     {
 309         handleDownloadFinished(downloadHandler);
 310     });
 311     downloadHandler->assignNetworkReply(reply);
 312 }
 313
 314 Net::DownloadRequest::DownloadRequest(const QString &url)
 315     : m_url {url}
 316 {
 317 }
 318
 319 QString Net::DownloadRequest::url() const
 320 {
 321     return m_url;
 322 }
 323
 324 Net::DownloadRequest &Net::DownloadRequest::url(const QString &value)
 325 {
 326     m_url = value;
 327     return *this;
 328 }
 329
 330 QString Net::DownloadRequest::userAgent() const
 331 {
 332     return m_userAgent;
 333 }
 334
 335 Net::DownloadRequest &Net::DownloadRequest::userAgent(const QString &value)
 336 {
 337     m_userAgent = value;
 338     return *this;
 339 }
 340
 341 qint64 Net::DownloadRequest::limit() const
 342 {
 343     return m_limit;
 344 }
 345
 346 Net::DownloadRequest &Net::DownloadRequest::limit(const qint64 value)
 347 {
 348     m_limit = value;
 349     return *this;
 350 }
 351
 352 bool Net::DownloadRequest::saveToFile() const
 353 {
 354     return m_saveToFile;
 355 }
 356
 357 Net::DownloadRequest &Net::DownloadRequest::saveToFile(const bool value)
 358 {
 359     m_saveToFile = value;
 360     return *this;
 361 }
 362
 363 Path Net::DownloadRequest::destFileName() const
 364 {
 365     return m_destFileName;
 366 }
 367
 368 Net::DownloadRequest &Net::DownloadRequest::destFileName(const Path &value)
 369 {
 370     m_destFileName = value;
 371     return *this;
 372 }
 373
 374 Net::ServiceID Net::ServiceID::fromURL(const QUrl &url)
 375 {
 376     return {url.host(), url.port(80)};
 377 }
 378
 379 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
 380 std::size_t Net::qHash(const ServiceID &serviceID, const std::size_t seed)
 381 {
 382     return qHashMulti(seed, serviceID.hostName, serviceID.port);
 383 }
 384 #else
 385 uint Net::qHash(const ServiceID &serviceID, const uint seed)
 386 {
 387     return ::qHash(serviceID.hostName, seed) ^ ::qHash(serviceID.port);
 388 }
 389 #endif
 390
 391 bool Net::operator==(const ServiceID &lhs, const ServiceID &rhs)
 392 {
 393     return ((lhs.hostName == rhs.hostName) && (lhs.port == rhs.port));
 394 }