d4708/qBittorrent
1
0
Fork 0
mirror of https://github.com/d47081/qBittorrent.git synced 2025-03-13 05:41:17 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #10346 from glassez/download-manager

Browse Source 
Improve "Download manager"
This commit is contained in:
Vladimir Golovnev 2019-03-10 09:13:07 +03:00 committed by GitHub
commit 928ce940c9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 555 additions and 681 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/base/CMakeLists.txt
View File

@ -29,7 +29,6 @@ http/responsegenerator.h
http/server.h
http/types.h
net/dnsupdater.h
net/downloadhandler.h
net/downloadmanager.h
net/geoipmanager.h
net/portforwarder.h
@ -100,7 +99,6 @@ http/responsebuilder.cpp
http/responsegenerator.cpp
http/server.cpp
net/dnsupdater.cpp
net/downloadhandler.cpp
net/downloadmanager.cpp
net/geoipmanager.cpp
net/portforwarder.cpp

2
src/base/base.pri
View File

@ -34,7 +34,6 @@ HEADERS += \
$$PWD/indexrange.h \
$$PWD/logger.h \
$$PWD/net/dnsupdater.h \
$$PWD/net/downloadhandler.h \
$$PWD/net/downloadmanager.h \
$$PWD/net/geoipmanager.h \
$$PWD/net/portforwarder.h \
@ -103,7 +102,6 @@ SOURCES += \
$$PWD/iconprovider.cpp \
$$PWD/logger.cpp \
$$PWD/net/dnsupdater.cpp \
$$PWD/net/downloadhandler.cpp \
$$PWD/net/downloadmanager.cpp \
$$PWD/net/geoipmanager.cpp \
$$PWD/net/portforwarder.cpp \

38
src/base/bittorrent/session.cpp
View File

@ -67,7 +67,6 @@
#include "base/exceptions.h"
#include "base/global.h"
#include "base/logger.h"
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#include "base/net/portforwarder.h"
#include "base/net/proxyconfigurationmanager.h"
@ -1542,22 +1541,21 @@ void Session::processShareLimits()
}
}
void Session::handleDownloadFailed(const QString &url, const QString &reason)
{
emit downloadFromUrlFailed(url, reason);
}
void Session::handleRedirectedToMagnet(const QString &url, const QString &magnetUri)
{
addTorrent_impl(CreateTorrentParams(m_downloadedTorrents.take(url)), MagnetUri(magnetUri));
}
// Add to BitTorrent session the downloaded torrent file
void Session::handleDownloadFinished(const QString &url, const QByteArray &data)
void Session::handleDownloadFinished(const Net::DownloadResult &result)
{
emit downloadFromUrlFinished(url);
addTorrent_impl(CreateTorrentParams(m_downloadedTorrents.take(url))
, MagnetUri(), TorrentInfo::load(data));
switch (result.status) {
case Net::DownloadStatus::Success:
emit downloadFromUrlFinished(result.url);
addTorrent_impl(CreateTorrentParams(m_downloadedTorrents.take(result.url))
, MagnetUri(), TorrentInfo::load(result.data));
break;
case Net::DownloadStatus::RedirectedToMagnet:
addTorrent_impl(CreateTorrentParams(m_downloadedTorrents.take(result.url)), MagnetUri(result.magnet));
break;
default:
emit downloadFromUrlFailed(result.url, result.errorString);
}
}
// Return the torrent handle, given its hash
@ -1795,13 +1793,9 @@ bool Session::addTorrent(const QString &source, const AddTorrentParams &params)
if (Net::DownloadManager::hasSupportedScheme(source)) {
LogMsg(tr("Downloading '%1', please wait...", "e.g: Downloading 'xxx.torrent', please wait...").arg(source));
// Launch downloader
const Net::DownloadHandler *handler =
Net::DownloadManager::instance()->download(Net::DownloadRequest(source).limit(10485760 /* 10MB */).handleRedirectToMagnet(true));
connect(handler, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, this, &Session::handleDownloadFinished);
connect(handler, &Net::DownloadHandler::downloadFailed, this, &Session::handleDownloadFailed);
connect(handler, &Net::DownloadHandler::redirectedToMagnet, this, &Session::handleRedirectedToMagnet);
m_downloadedTorrents[handler->url()] = params;
Net::DownloadManager::instance()->download(Net::DownloadRequest(source).limit(10485760 /* 10MB */)
, this, &Session::handleDownloadFinished);
m_downloadedTorrents[source] = params;
return true;
}

9
src/base/bittorrent/session.h
View File

@ -118,6 +118,11 @@ enum TorrentExportFolder
Finished
};
namespace Net
{
struct DownloadResult;
}
namespace BitTorrent
{
class InfoHash;
@ -537,9 +542,7 @@ namespace BitTorrent
void generateResumeData(bool final = false);
void handleIPFilterParsed(int ruleCount);
void handleIPFilterError();
void handleDownloadFinished(const QString &url, const QByteArray &data);
void handleDownloadFailed(const QString &url, const QString &reason);
void handleRedirectedToMagnet(const QString &url, const QString &magnetUri);
void handleDownloadFinished(const Net::DownloadResult &result);
// Session reconfiguration triggers
void networkOnlineStateChanged(bool online);

47
src/base/net/dnsupdater.cpp
View File

@ -33,7 +33,6 @@
#include <QUrlQuery>
#include "base/logger.h"
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
using namespace Net;
@ -74,21 +73,22 @@ void DNSUpdater::checkPublicIP()
{
Q_ASSERT(m_state == OK);
DownloadHandler *handler = DownloadManager::instance()->download(
DownloadRequest("http://checkip.dyndns.org").userAgent("qBittorrent/" QBT_VERSION_2));
connect(handler, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, this, &DNSUpdater::ipRequestFinished);
connect(handler, &Net::DownloadHandler::downloadFailed, this, &DNSUpdater::ipRequestFailed);
DownloadManager::instance()->download(
DownloadRequest("http://checkip.dyndns.org").userAgent("qBittorrent/" QBT_VERSION_2)
, this, &DNSUpdater::ipRequestFinished);
m_lastIPCheckTime = QDateTime::currentDateTime();
}
void DNSUpdater::ipRequestFinished(const QString &url, const QByteArray &data)
void DNSUpdater::ipRequestFinished(const DownloadResult &result)
{
Q_UNUSED(url);
if (result.status != DownloadStatus::Success) {
qWarning() << "IP request failed:" << result.errorString;
return;
}
// Parse response
const QRegularExpressionMatch ipRegexMatch = QRegularExpression("Current IP Address:\\s+([^<]+)</body>").match(data);
const QRegularExpressionMatch ipRegexMatch = QRegularExpression("Current IP Address:\\s+([^<]+)</body>").match(result.data);
if (ipRegexMatch.hasMatch()) {
QString ipStr = ipRegexMatch.captured(1);
qDebug() << Q_FUNC_INFO << "Regular expression captured the following IP:" << ipStr;
@ -110,22 +110,14 @@ void DNSUpdater::ipRequestFinished(const QString &url, const QByteArray &data)
}
}
void DNSUpdater::ipRequestFailed(const QString &url, const QString &error)
{
Q_UNUSED(url);
qWarning() << "IP request failed:" << error;
}
void DNSUpdater::updateDNSService()
{
qDebug() << Q_FUNC_INFO;
m_lastIPCheckTime = QDateTime::currentDateTime();
DownloadHandler *handler = DownloadManager::instance()->download(
DownloadRequest(getUpdateUrl()).userAgent("qBittorrent/" QBT_VERSION_2));
connect(handler, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, this, &DNSUpdater::ipUpdateFinished);
connect(handler, &Net::DownloadHandler::downloadFailed, this, &DNSUpdater::ipUpdateFailed);
DownloadManager::instance()->download(
DownloadRequest(getUpdateUrl()).userAgent("qBittorrent/" QBT_VERSION_2)
, this, &DNSUpdater::ipUpdateFinished);
}
QString DNSUpdater::getUpdateUrl() const
@ -164,17 +156,12 @@ QString DNSUpdater::getUpdateUrl() const
return url.toString();
}
void DNSUpdater::ipUpdateFinished(const QString &url, const QByteArray &data)
void DNSUpdater::ipUpdateFinished(const DownloadResult &result)
{
Q_UNUSED(url);
// Parse reply
processIPUpdateReply(data);
}
void DNSUpdater::ipUpdateFailed(const QString &url, const QString &error)
{
Q_UNUSED(url);
qWarning() << "IP update failed:" << error;
if (result.status == DownloadStatus::Success)
processIPUpdateReply(result.data);
else
qWarning() << "IP update failed:" << result.errorString;
}
void DNSUpdater::processIPUpdateReply(const QString &reply)

8
src/base/net/dnsupdater.h
View File

@ -38,6 +38,8 @@
namespace Net
{
struct DownloadResult;
// Based on http://www.dyndns.com/developers/specs/
class DNSUpdater : public QObject
{
@ -54,11 +56,9 @@ namespace Net
private slots:
void checkPublicIP();
void ipRequestFinished(const QString &url, const QByteArray &data);
void ipRequestFailed(const QString &url, const QString &error);
void ipRequestFinished(const DownloadResult &result);
void updateDNSService();
void ipUpdateFinished(const QString &url, const QByteArray &data);
void ipUpdateFailed(const QString &url, const QString &error);
void ipUpdateFinished(const DownloadResult &result);
private:
enum State

255
src/base/net/downloadhandler.cpp
View File

@ -1,255 +0,0 @@
/*
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2015, 2018 Vladimir Golovnev <glassez@yandex.ru>
* Copyright (C) 2006 Christophe Dumez <chris@qbittorrent.org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* In addition, as a special exception, the copyright holders give permission to
* link this program with the OpenSSL project's "OpenSSL" library (or with
* modified versions of it that use the same license as the "OpenSSL" library),
* and distribute the linked executables. You must obey the GNU General Public
* License in all respects for all of the code used other than "OpenSSL". If you
* modify file(s), you may extend this exception to your version of the file(s),
* but you are not obligated to do so. If you do not wish to do so, delete this
* exception statement from your version.
*/
#include "downloadhandler.h"
#include <QCoreApplication>
#include <QDebug>
#include <QNetworkAccessManager>
#include <QNetworkCookie>
#include <QNetworkProxy>
#include <QNetworkRequest>
#include <QTemporaryFile>
#include <QUrl>
#include "base/utils/fs.h"
#include "base/utils/gzip.h"
#include "base/utils/misc.h"
namespace
{
const int MAX_REDIRECTIONS = 20; // the common value for web browsers
bool saveToFile(const QByteArray &replyData, QString &filePath)
{
QTemporaryFile tmpfile {Utils::Fs::tempPath() + "XXXXXX"};
tmpfile.setAutoRemove(false);
if (!tmpfile.open())
return false;
filePath = tmpfile.fileName();
tmpfile.write(replyData);
return true;
}
}
Net::DownloadHandler::DownloadHandler(QNetworkReply *reply, DownloadManager *manager, const DownloadRequest &downloadRequest)
: QObject(manager)
, m_reply(reply)
, m_manager(manager)
, m_downloadRequest(downloadRequest)
{
if (reply)
assignNetworkReply(reply);
}
Net::DownloadHandler::~DownloadHandler()
{
if (m_reply)
delete m_reply;
}
void Net::DownloadHandler::assignNetworkReply(QNetworkReply *reply)
{
Q_ASSERT(reply);
m_reply = reply;
m_reply->setParent(this);
if (m_downloadRequest.limit() > 0)
connect(m_reply, &QNetworkReply::downloadProgress, this, &Net::DownloadHandler::checkDownloadSize);
connect(m_reply, &QNetworkReply::finished, this, &Net::DownloadHandler::processFinishedDownload);
}
// Returns original url
QString Net::DownloadHandler::url() const
{
return m_downloadRequest.url();
}
void Net::DownloadHandler::processFinishedDownload()
{
const QString url = m_reply->url().toString();
qDebug("Download finished: %s", qUtf8Printable(url));
// Check if the request was successful
if (m_reply->error() != QNetworkReply::NoError) {
// Failure
qDebug("Download failure (%s), reason: %s", qUtf8Printable(url), qUtf8Printable(errorCodeToString(m_reply->error())));
emit downloadFailed(m_downloadRequest.url(), errorCodeToString(m_reply->error()));
this->deleteLater();
return;
}
// Check if the server ask us to redirect somewhere else
const QVariant redirection = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
if (redirection.isValid()) {
// We should redirect
handleRedirection(redirection.toUrl());
return;
}
// Success
const QByteArray replyData = (m_reply->rawHeader("Content-Encoding") == "gzip")
? Utils::Gzip::decompress(m_reply->readAll())
: m_reply->readAll();
if (m_downloadRequest.saveToFile()) {
QString filePath;
if (saveToFile(replyData, filePath))
emit downloadFinished(m_downloadRequest.url(), filePath);
else
emit downloadFailed(m_downloadRequest.url(), tr("I/O Error"));
}
else {
emit downloadFinished(m_downloadRequest.url(), replyData);
}
this->deleteLater();
}
void Net::DownloadHandler::checkDownloadSize(const qint64 bytesReceived, const qint64 bytesTotal)
{
QString msg = tr("The file size is %1. It exceeds the download limit of %2.");
if (bytesTotal > 0) {
// Total number of bytes is available
if (bytesTotal > m_downloadRequest.limit()) {
m_reply->abort();
emit downloadFailed(m_downloadRequest.url(), msg.arg(Utils::Misc::friendlyUnit(bytesTotal), Utils::Misc::friendlyUnit(m_downloadRequest.limit())));
}
else {
disconnect(m_reply, &QNetworkReply::downloadProgress, this, &Net::DownloadHandler::checkDownloadSize);
}
}
else if (bytesReceived > m_downloadRequest.limit()) {
m_reply->abort();
emit downloadFailed(m_downloadRequest.url(), msg.arg(Utils::Misc::friendlyUnit(bytesReceived), Utils::Misc::friendlyUnit(m_downloadRequest.limit())));
}
}
void Net::DownloadHandler::handleRedirection(const QUrl &newUrl)
{
if (m_redirectionCounter >= MAX_REDIRECTIONS) {
emit downloadFailed(url(), tr("Exceeded max redirections (%1)").arg(MAX_REDIRECTIONS));
this->deleteLater();
return;
}
// Resolve relative urls
const QUrl resolvedUrl = (newUrl.isRelative()) ? m_reply->url().resolved(newUrl) : newUrl;
const QString newUrlString = resolvedUrl.toString();
qDebug("Redirecting from %s to %s...", qUtf8Printable(m_reply->url().toString()), qUtf8Printable(newUrlString));
// Redirect to magnet workaround
if (newUrlString.startsWith("magnet:", Qt::CaseInsensitive)) {
qDebug("Magnet redirect detected.");
m_reply->abort();
if (m_downloadRequest.handleRedirectToMagnet())
emit redirectedToMagnet(m_downloadRequest.url(), newUrlString);
else
emit downloadFailed(m_downloadRequest.url(), tr("Unexpected redirect to magnet URI."));
this->deleteLater();
return;
}
DownloadHandler *redirected = m_manager->download(DownloadRequest(m_downloadRequest).url(newUrlString));
redirected->m_redirectionCounter = (m_redirectionCounter + 1);
connect(redirected, &DownloadHandler::destroyed, this, &DownloadHandler::deleteLater);
connect(redirected, &DownloadHandler::downloadFailed, this, [this](const QString &, const QString &reason)
{
emit downloadFailed(url(), reason);
});
connect(redirected, &DownloadHandler::redirectedToMagnet, this, [this](const QString &, const QString &magnetUri)
{
emit redirectedToMagnet(url(), magnetUri);
});
connect(redirected, static_cast<void (DownloadHandler::*)(const QString &, const QString &)>(&DownloadHandler::downloadFinished)
, this, [this](const QString &, const QString &fileName)
{
emit downloadFinished(url(), fileName);
});
connect(redirected, static_cast<void (DownloadHandler::*)(const QString &, const QByteArray &)>(&DownloadHandler::downloadFinished)
, this, [this](const QString &, const QByteArray &data)
{
emit downloadFinished(url(), data);
});
}
QString Net::DownloadHandler::errorCodeToString(const QNetworkReply::NetworkError status)
{
switch (status) {
case QNetworkReply::HostNotFoundError:
return tr("The remote host name was not found (invalid hostname)");
case QNetworkReply::OperationCanceledError:
return tr("The operation was canceled");
case QNetworkReply::RemoteHostClosedError:
return tr("The remote server closed the connection prematurely, before the entire reply was received and processed");
case QNetworkReply::TimeoutError:
return tr("The connection to the remote server timed out");
case QNetworkReply::SslHandshakeFailedError:
return tr("SSL/TLS handshake failed");
case QNetworkReply::ConnectionRefusedError:
return tr("The remote server refused the connection");
case QNetworkReply::ProxyConnectionRefusedError:
return tr("The connection to the proxy server was refused");
case QNetworkReply::ProxyConnectionClosedError:
return tr("The proxy server closed the connection prematurely");
case QNetworkReply::ProxyNotFoundError:
return tr("The proxy host name was not found");
case QNetworkReply::ProxyTimeoutError:
return tr("The connection to the proxy timed out or the proxy did not reply in time to the request sent");
case QNetworkReply::ProxyAuthenticationRequiredError:
return tr("The proxy requires authentication in order to honor the request but did not accept any credentials offered");
case QNetworkReply::ContentAccessDenied:
return tr("The access to the remote content was denied (401)");
case QNetworkReply::ContentOperationNotPermittedError:
return tr("The operation requested on the remote content is not permitted");
case QNetworkReply::ContentNotFoundError:
return tr("The remote content was not found at the server (404)");
case QNetworkReply::AuthenticationRequiredError:
return tr("The remote server requires authentication to serve the content but the credentials provided were not accepted");
case QNetworkReply::ProtocolUnknownError:
return tr("The Network Access API cannot honor the request because the protocol is not known");
case QNetworkReply::ProtocolInvalidOperationError:
return tr("The requested operation is invalid for this protocol");
case QNetworkReply::UnknownNetworkError:
return tr("An unknown network-related error was detected");
case QNetworkReply::UnknownProxyError:
return tr("An unknown proxy-related error was detected");
case QNetworkReply::UnknownContentError:
return tr("An unknown error related to the remote content was detected");
case QNetworkReply::ProtocolFailure:
return tr("A breakdown in protocol was detected");
default:
return tr("Unknown error");
}
}

81
src/base/net/downloadhandler.h
View File

@ -1,81 +0,0 @@
/*
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2015, 2018 Vladimir Golovnev <glassez@yandex.ru>
* Copyright (C) 2006 Christophe Dumez <chris@qbittorrent.org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* In addition, as a special exception, the copyright holders give permission to
* link this program with the OpenSSL project's "OpenSSL" library (or with
* modified versions of it that use the same license as the "OpenSSL" library),
* and distribute the linked executables. You must obey the GNU General Public
* License in all respects for all of the code used other than "OpenSSL". If you
* modify file(s), you may extend this exception to your version of the file(s),
* but you are not obligated to do so. If you do not wish to do so, delete this
* exception statement from your version.
*/
#ifndef NET_DOWNLOADHANDLER_H
#define NET_DOWNLOADHANDLER_H
#include <QNetworkReply>
#include <QObject>
#include "downloadmanager.h"
class QUrl;
namespace Net
{
class DownloadManager;
class DownloadHandler : public QObject
{
Q_OBJECT
Q_DISABLE_COPY(DownloadHandler)
friend class DownloadManager;
DownloadHandler(QNetworkReply *reply, DownloadManager *manager, const DownloadRequest &downloadRequest);
public:
~DownloadHandler() override;
QString url() const;
signals:
void downloadFinished(const QString &url, const QByteArray &data);
void downloadFinished(const QString &url, const QString &filePath);
void downloadFailed(const QString &url, const QString &reason);
void redirectedToMagnet(const QString &url, const QString &magnetUri);
private slots:
void processFinishedDownload();
void checkDownloadSize(qint64 bytesReceived, qint64 bytesTotal);
private:
void assignNetworkReply(QNetworkReply *reply);
void handleRedirection(const QUrl &newUrl);
static QString errorCodeToString(QNetworkReply::NetworkError status);
QNetworkReply *m_reply;
DownloadManager *m_manager;
const DownloadRequest m_downloadRequest;
short m_redirectionCounter = 0;
};
}
#endif // NET_DOWNLOADHANDLER_H

257
src/base/net/downloadmanager.cpp
View File

@ -39,12 +39,15 @@
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QSslError>
#include <QTemporaryFile>
#include <QUrl>
#include "base/global.h"
#include "base/logger.h"
#include "base/preferences.h"
#include "downloadhandler.h"
#include "base/utils/fs.h"
#include "base/utils/gzip.h"
#include "base/utils/misc.h"
#include "proxyconfigurationmanager.h"
// Spoof Firefox 38 user agent to avoid web server banning
@ -52,6 +55,8 @@ const char DEFAULT_USER_AGENT[] = "Mozilla/5.0 (X11; Linux i686; rv:38.0) Gecko/
namespace
{
const int MAX_REDIRECTIONS = 20; // the common value for web browsers
class NetworkCookieJar : public QNetworkCookieJar
{
public:
@ -108,6 +113,33 @@ namespace
}
};
class DownloadHandlerImpl : public Net::DownloadHandler
{
Q_DISABLE_COPY(DownloadHandlerImpl)
public:
explicit DownloadHandlerImpl(const Net::DownloadRequest &downloadRequest, QObject *parent);
~DownloadHandlerImpl() override;
QString url() const;
const Net::DownloadRequest downloadRequest() const;
void assignNetworkReply(QNetworkReply *reply);
private:
void processFinishedDownload();
void checkDownloadSize(qint64 bytesReceived, qint64 bytesTotal);
void handleRedirection(const QUrl &newUrl);
void setError(const QString &error);
void finish();
static QString errorCodeToString(QNetworkReply::NetworkError status);
QNetworkReply *m_reply = nullptr;
const Net::DownloadRequest m_downloadRequest;
Net::DownloadResult m_result;
};
QNetworkRequest createNetworkRequest(const Net::DownloadRequest &downloadRequest)
{
QNetworkRequest request {downloadRequest.url()};
@ -122,8 +154,25 @@ namespace
// Accept gzip
request.setRawHeader("Accept-Encoding", "gzip");
request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::UserVerifiedRedirectPolicy);
request.setMaximumRedirectsAllowed(MAX_REDIRECTIONS);
return request;
}
bool saveToFile(const QByteArray &replyData, QString &filePath)
{
QTemporaryFile tmpfile {Utils::Fs::tempPath() + "XXXXXX"};
tmpfile.setAutoRemove(false);
if (!tmpfile.open())
return false;
filePath = tmpfile.fileName();
tmpfile.write(replyData);
return true;
}
}
Net::DownloadManager *Net::DownloadManager::m_instance = nullptr;
@ -164,20 +213,24 @@ Net::DownloadHandler *Net::DownloadManager::download(const DownloadRequest &down
const QNetworkRequest request = createNetworkRequest(downloadRequest);
const ServiceID id = ServiceID::fromURL(request.url());
const bool isSequentialService = m_sequentialServices.contains(id);
auto downloadHandler = new DownloadHandlerImpl {downloadRequest, this};
connect(downloadHandler, &DownloadHandler::finished, downloadHandler, &QObject::deleteLater);
connect(downloadHandler, &QObject::destroyed, this, [this, id, downloadHandler]()
{
m_waitingJobs[id].removeOne(downloadHandler);
});
if (!isSequentialService || !m_busyServices.contains(id)) {
qDebug("Downloading %s...", qUtf8Printable(downloadRequest.url()));
if (isSequentialService)
m_busyServices.insert(id);
return new DownloadHandler {
m_networkManager.get(request), this, downloadRequest};
downloadHandler->assignNetworkReply(m_networkManager.get(request));
}
else {
m_waitingJobs[id].enqueue(downloadHandler);
}
auto *downloadHandler = new DownloadHandler {nullptr, this, downloadRequest};
connect(downloadHandler, &DownloadHandler::destroyed, this, [this, id, downloadHandler]()
{
m_waitingJobs[id].removeOne(downloadHandler);
});
m_waitingJobs[id].enqueue(downloadHandler);
return downloadHandler;
}
@ -262,9 +315,9 @@ void Net::DownloadManager::handleReplyFinished(const QNetworkReply *reply)
return;
}
DownloadHandler *handler = waitingJobsIter.value().dequeue();
qDebug("Downloading %s...", qUtf8Printable(handler->m_downloadRequest.url()));
handler->assignNetworkReply(m_networkManager.get(createNetworkRequest(handler->m_downloadRequest)));
auto handler = static_cast<DownloadHandlerImpl *>(waitingJobsIter.value().dequeue());
qDebug("Downloading %s...", qUtf8Printable(handler->url()));
handler->assignNetworkReply(m_networkManager.get(createNetworkRequest(handler->downloadRequest())));
handler->disconnect(this);
}
@ -328,17 +381,6 @@ Net::DownloadRequest &Net::DownloadRequest::saveToFile(const bool value)
return *this;
}
bool Net::DownloadRequest::handleRedirectToMagnet() const
{
return m_handleRedirectToMagnet;
}
Net::DownloadRequest &Net::DownloadRequest::handleRedirectToMagnet(const bool value)
{
m_handleRedirectToMagnet = value;
return *this;
}
Net::ServiceID Net::ServiceID::fromURL(const QUrl &url)
{
return {url.host(), url.port(80)};
@ -353,3 +395,172 @@ bool Net::operator==(const ServiceID &lhs, const ServiceID &rhs)
{
return ((lhs.hostName == rhs.hostName) && (lhs.port == rhs.port));
}
namespace
{
DownloadHandlerImpl::DownloadHandlerImpl(const Net::DownloadRequest &downloadRequest, QObject *parent)
: DownloadHandler {parent}
, m_downloadRequest {downloadRequest}
{
m_result.url = url();
m_result.status = Net::DownloadStatus::Success;
}
DownloadHandlerImpl::~DownloadHandlerImpl()
{
if (m_reply)
delete m_reply;
}
void DownloadHandlerImpl::assignNetworkReply(QNetworkReply *reply)
{
Q_ASSERT(reply);
m_reply = reply;
m_reply->setParent(this);
if (m_downloadRequest.limit() > 0)
connect(m_reply, &QNetworkReply::downloadProgress, this, &DownloadHandlerImpl::checkDownloadSize);
connect(m_reply, &QNetworkReply::finished, this, &DownloadHandlerImpl::processFinishedDownload);
connect(m_reply, &QNetworkReply::redirected, this, &DownloadHandlerImpl::handleRedirection);
}
// Returns original url
QString DownloadHandlerImpl::url() const
{
return m_downloadRequest.url();
}
const Net::DownloadRequest DownloadHandlerImpl::downloadRequest() const
{
return m_downloadRequest;
}
void DownloadHandlerImpl::processFinishedDownload()
{
const QString url = m_reply->url().toString();
qDebug("Download finished: %s", qUtf8Printable(url));
// Check if the request was successful
if (m_reply->error() != QNetworkReply::NoError) {
// Failure
qDebug("Download failure (%s), reason: %s", qUtf8Printable(url), qUtf8Printable(errorCodeToString(m_reply->error())));
setError(errorCodeToString(m_reply->error()));
finish();
return;
}
// Success
m_result.data = (m_reply->rawHeader("Content-Encoding") == "gzip")
? Utils::Gzip::decompress(m_reply->readAll())
: m_reply->readAll();
if (m_downloadRequest.saveToFile()) {
QString filePath;
if (saveToFile(m_result.data, filePath))
m_result.filePath = filePath;
else
setError(tr("I/O Error"));
}
finish();
}
void DownloadHandlerImpl::checkDownloadSize(const qint64 bytesReceived, const qint64 bytesTotal)
{
if ((bytesTotal > 0) && (bytesTotal <= m_downloadRequest.limit())) {
// Total number of bytes is available
disconnect(m_reply, &QNetworkReply::downloadProgress, this, &DownloadHandlerImpl::checkDownloadSize);
return;
}
if ((bytesTotal > m_downloadRequest.limit()) || (bytesReceived > m_downloadRequest.limit())) {
m_reply->abort();
setError(tr("The file size is %1. It exceeds the download limit of %2.")
.arg(Utils::Misc::friendlyUnit(bytesTotal)
, Utils::Misc::friendlyUnit(m_downloadRequest.limit())));
finish();
}
}
void DownloadHandlerImpl::handleRedirection(const QUrl &newUrl)
{
// Resolve relative urls
const QUrl resolvedUrl = newUrl.isRelative() ? m_reply->url().resolved(newUrl) : newUrl;
const QString newUrlString = resolvedUrl.toString();
qDebug("Redirecting from %s to %s...", qUtf8Printable(m_reply->url().toString()), qUtf8Printable(newUrlString));
// Redirect to magnet workaround
if (newUrlString.startsWith("magnet:", Qt::CaseInsensitive)) {
qDebug("Magnet redirect detected.");
m_result.status = Net::DownloadStatus::RedirectedToMagnet;
m_result.magnet = newUrlString;
m_result.errorString = tr("Redirected to magnet URI.");
finish();
return;
}
emit m_reply->redirectAllowed();
}
void DownloadHandlerImpl::setError(const QString &error)
{
m_result.errorString = error;
m_result.status = Net::DownloadStatus::Failed;
}
void DownloadHandlerImpl::finish()
{
emit finished(m_result);
}
QString DownloadHandlerImpl::errorCodeToString(const QNetworkReply::NetworkError status)
{
switch (status) {
case QNetworkReply::HostNotFoundError:
return tr("The remote host name was not found (invalid hostname)");
case QNetworkReply::OperationCanceledError:
return tr("The operation was canceled");
case QNetworkReply::RemoteHostClosedError:
return tr("The remote server closed the connection prematurely, before the entire reply was received and processed");
case QNetworkReply::TimeoutError:
return tr("The connection to the remote server timed out");
case QNetworkReply::SslHandshakeFailedError:
return tr("SSL/TLS handshake failed");
case QNetworkReply::ConnectionRefusedError:
return tr("The remote server refused the connection");
case QNetworkReply::ProxyConnectionRefusedError:
return tr("The connection to the proxy server was refused");
case QNetworkReply::ProxyConnectionClosedError:
return tr("The proxy server closed the connection prematurely");
case QNetworkReply::ProxyNotFoundError:
return tr("The proxy host name was not found");
case QNetworkReply::ProxyTimeoutError:
return tr("The connection to the proxy timed out or the proxy did not reply in time to the request sent");
case QNetworkReply::ProxyAuthenticationRequiredError:
return tr("The proxy requires authentication in order to honor the request but did not accept any credentials offered");
case QNetworkReply::ContentAccessDenied:
return tr("The access to the remote content was denied (401)");
case QNetworkReply::ContentOperationNotPermittedError:
return tr("The operation requested on the remote content is not permitted");
case QNetworkReply::ContentNotFoundError:
return tr("The remote content was not found at the server (404)");
case QNetworkReply::AuthenticationRequiredError:
return tr("The remote server requires authentication to serve the content but the credentials provided were not accepted");
case QNetworkReply::ProtocolUnknownError:
return tr("The Network Access API cannot honor the request because the protocol is not known");
case QNetworkReply::ProtocolInvalidOperationError:
return tr("The requested operation is invalid for this protocol");
case QNetworkReply::UnknownNetworkError:
return tr("An unknown network-related error was detected");
case QNetworkReply::UnknownProxyError:
return tr("An unknown proxy-related error was detected");
case QNetworkReply::UnknownContentError:
return tr("An unknown error related to the remote content was detected");
case QNetworkReply::ProtocolFailure:
return tr("A breakdown in protocol was detected");
default:
return tr("Unknown error");
}
}
}

58
src/base/net/downloadmanager.h
View File

@ -44,7 +44,23 @@ class QUrl;
namespace Net
{
class DownloadHandler;
struct ServiceID
{
QString hostName;
int port;
static ServiceID fromURL(const QUrl &url);
};
uint qHash(const ServiceID &serviceID, uint seed);
bool operator==(const ServiceID &lhs, const ServiceID &rhs);
enum class DownloadStatus
{
Success,
RedirectedToMagnet,
Failed
};
class DownloadRequest
{
@ -64,27 +80,34 @@ namespace Net
bool saveToFile() const;
DownloadRequest &saveToFile(bool value);
bool handleRedirectToMagnet() const;
DownloadRequest &handleRedirectToMagnet(bool value);
private:
QString m_url;
QString m_userAgent;
qint64 m_limit = 0;
bool m_saveToFile = false;
bool m_handleRedirectToMagnet = false;
};
struct ServiceID
struct DownloadResult
{
QString hostName;
int port;
static ServiceID fromURL(const QUrl &url);
QString url;
DownloadStatus status;
QString errorString;
QByteArray data;
QString filePath;
QString magnet;
};
uint qHash(const ServiceID &serviceID, uint seed);
bool operator==(const ServiceID &lhs, const ServiceID &rhs);
class DownloadHandler : public QObject
{
Q_OBJECT
Q_DISABLE_COPY(DownloadHandler)
public:
using QObject::QObject;
signals:
void finished(const DownloadResult &result);
};
class DownloadManager : public QObject
{
@ -96,7 +119,8 @@ namespace Net
static void freeInstance();
static DownloadManager *instance();
DownloadHandler *download(const DownloadRequest &downloadRequest);
template <typename Context, typename Func>
void download(const DownloadRequest &downloadRequest, Context context, Func slot);
void registerSequentialService(const ServiceID &serviceID);
@ -114,6 +138,7 @@ namespace Net
private:
explicit DownloadManager(QObject *parent = nullptr);
DownloadHandler *download(const DownloadRequest &downloadRequest);
void applyProxySettings();
void handleReplyFinished(const QNetworkReply *reply);
@ -124,6 +149,13 @@ namespace Net
QSet<ServiceID> m_busyServices;
QHash<ServiceID, QQueue<DownloadHandler *>> m_waitingJobs;
};
template <typename Context, typename Func>
void DownloadManager::download(const DownloadRequest &downloadRequest, Context context, Func slot)
{
const DownloadHandler *handler = download(downloadRequest);
connect(handler, &DownloadHandler::finished, context, slot);
}
}
#endif // NET_DOWNLOADMANAGER_H

38
src/base/net/geoipmanager.cpp
View File

@ -40,7 +40,6 @@
#include "base/profile.h"
#include "base/utils/fs.h"
#include "base/utils/gzip.h"
#include "downloadhandler.h"
#include "downloadmanager.h"
#include "private/geoipdatabase.h"
@ -118,10 +117,7 @@ void GeoIPManager::manageDatabaseUpdate()
void GeoIPManager::downloadDatabaseFile()
{
const DownloadHandler *handler = DownloadManager::instance()->download({DATABASE_URL});
connect(handler, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, this, &GeoIPManager::downloadFinished);
connect(handler, &Net::DownloadHandler::downloadFailed, this, &GeoIPManager::downloadFailed);
DownloadManager::instance()->download({DATABASE_URL}, this, &GeoIPManager::downloadFinished);
}
QString GeoIPManager::lookup(const QHostAddress &hostAddr) const
@ -413,14 +409,17 @@ void GeoIPManager::configure()
}
}
void GeoIPManager::downloadFinished(const QString &url, QByteArray data)
void GeoIPManager::downloadFinished(const DownloadResult &result)
{
Q_UNUSED(url);
if (result.status != DownloadStatus::Success) {
LogMsg(tr("Couldn't download GeoIP database file. Reason: %1").arg(result.errorString), Log::WARNING);
return;
}
bool ok = false;
data = Utils::Gzip::decompress(data, &ok);
const QByteArray data = Utils::Gzip::decompress(result.data, &ok);
if (!ok) {
Logger::instance()->addMessage(tr("Could not decompress GeoIP database file."), Log::WARNING);
LogMsg(tr("Could not decompress GeoIP database file."), Log::WARNING);
return;
}
@ -431,7 +430,7 @@ void GeoIPManager::downloadFinished(const QString &url, QByteArray data)
if (m_geoIPDatabase)
delete m_geoIPDatabase;
m_geoIPDatabase = geoIPDatabase;
Logger::instance()->addMessage(tr("GeoIP database loaded. Type: %1. Build time: %2.")
LogMsg(tr("GeoIP database loaded. Type: %1. Build time: %2.")
.arg(m_geoIPDatabase->type(), m_geoIPDatabase->buildEpoch().toString()),
Log::INFO);
const QString targetPath = Utils::Fs::expandPathAbs(
@ -439,25 +438,16 @@ void GeoIPManager::downloadFinished(const QString &url, QByteArray data)
if (!QDir(targetPath).exists())
QDir().mkpath(targetPath);
QFile targetFile(QString("%1/%2").arg(targetPath, GEOIP_FILENAME));
if (!targetFile.open(QFile::WriteOnly) || (targetFile.write(data) == -1)) {
Logger::instance()->addMessage(
tr("Couldn't save downloaded GeoIP database file."), Log::WARNING);
}
else {
Logger::instance()->addMessage(tr("Successfully updated GeoIP database."), Log::INFO);
}
if (!targetFile.open(QFile::WriteOnly) || (targetFile.write(data) == -1))
LogMsg(tr("Couldn't save downloaded GeoIP database file."), Log::WARNING);
else
LogMsg(tr("Successfully updated GeoIP database."), Log::INFO);
}
else {
delete geoIPDatabase;
}
}
else {
Logger::instance()->addMessage(tr("Couldn't load GeoIP database. Reason: %1").arg(error), Log::WARNING);
LogMsg(tr("Couldn't load GeoIP database. Reason: %1").arg(error), Log::WARNING);
}
}
void GeoIPManager::downloadFailed(const QString &url, const QString &reason)
{
Q_UNUSED(url);
Logger::instance()->addMessage(tr("Couldn't download GeoIP database file. Reason: %1").arg(reason), Log::WARNING);
}

8
src/base/net/geoipmanager.h
View File

@ -40,9 +40,12 @@ class GeoIPDatabase;
namespace Net
{
struct DownloadResult;
class GeoIPManager : public QObject
{
Q_OBJECT
Q_DISABLE_COPY(GeoIPManager)
public:
static void initInstance();
@ -55,12 +58,11 @@ namespace Net
private slots:
void configure();
void downloadFinished(const QString &url, QByteArray data);
void downloadFailed(const QString &url, const QString &reason);
void downloadFinished(const DownloadResult &result);
private:
GeoIPManager();
~GeoIPManager();
~GeoIPManager() override;
void loadDatabase();
void manageDatabaseUpdate();

51
src/base/rss/rss_feed.cpp
View File

@ -44,7 +44,6 @@
#include "../asyncfilestorage.h"
#include "../global.h"
#include "../logger.h"
#include "../net/downloadhandler.h"
#include "../net/downloadmanager.h"
#include "../profile.h"
#include "../utils/fs.h"
@ -130,11 +129,7 @@ void Feed::refresh()
// NOTE: Should we allow manually refreshing for disabled session?
Net::DownloadHandler *handler = Net::DownloadManager::instance()->download(m_url);
connect(handler
, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, this, &Feed::handleDownloadFinished);
connect(handler, &Net::DownloadHandler::downloadFailed, this, &Feed::handleDownloadFailed);
Net::DownloadManager::instance()->download(m_url, this, &Feed::handleDownloadFinished);
m_isLoading = true;
emit stateChanged(this);
@ -182,12 +177,12 @@ void Feed::handleMaxArticlesPerFeedChanged(const int n)
// We don't need store articles here
}
void Feed::handleIconDownloadFinished(const QString &url, const QString &filePath)
void Feed::handleIconDownloadFinished(const Net::DownloadResult &result)
{
Q_UNUSED(url);
m_iconPath = Utils::Fs::fromNativePath(filePath);
emit iconLoaded(this);
if (result.status == Net::DownloadStatus::Success) {
m_iconPath = Utils::Fs::fromNativePath(result.filePath);
emit iconLoaded(this);
}
}
bool Feed::hasError() const
@ -195,22 +190,22 @@ bool Feed::hasError() const
return m_hasError;
}
void Feed::handleDownloadFinished(const QString &url, const QByteArray &data)
void Feed::handleDownloadFinished(const Net::DownloadResult &result)
{
qDebug() << "Successfully downloaded RSS feed at" << url;
// Parse the download RSS
m_parser->parse(data);
}
if (result.status == Net::DownloadStatus::Success) {
qDebug() << "Successfully downloaded RSS feed at" << result.url;
// Parse the download RSS
m_parser->parse(result.data);
}
else {
m_isLoading = false;
m_hasError = true;
void Feed::handleDownloadFailed(const QString &url, const QString &error)
{
m_isLoading = false;
m_hasError = true;
LogMsg(tr("Failed to download RSS feed at '%1'. Reason: %2")
.arg(result.url, result.errorString), Log::WARNING);
LogMsg(tr("Failed to download RSS feed at '%1'. Reason: %2").arg(url, error)
, Log::WARNING);
emit stateChanged(this);
emit stateChanged(this);
}
}
void Feed::handleParsingFinished(const RSS::Private::ParsingResult &result)
@ -402,11 +397,9 @@ void Feed::downloadIcon()
// XXX: This works for most sites but it is not perfect
const QUrl url(m_url);
const auto iconUrl = QString("%1://%2/favicon.ico").arg(url.scheme(), url.host());
const Net::DownloadHandler *handler = Net::DownloadManager::instance()->download(
Net::DownloadRequest(iconUrl).saveToFile(true));
connect(handler
, static_cast<void (Net::DownloadHandler::*)(const QString &, const QString &)>(&Net::DownloadHandler::downloadFinished)
, this, &Feed::handleIconDownloadFinished);
Net::DownloadManager::instance()->download(
Net::DownloadRequest(iconUrl).saveToFile(true)
, this, &Feed::handleIconDownloadFinished);
}
int Feed::updateArticles(const QList<QVariantHash> &loadedArticles)

10
src/base/rss/rss_feed.h
View File

@ -39,6 +39,11 @@
class AsyncFileStorage;
namespace Net
{
struct DownloadResult;
}
namespace RSS
{
class Article;
@ -85,9 +90,8 @@ namespace RSS
private slots:
void handleSessionProcessingEnabledChanged(bool enabled);
void handleMaxArticlesPerFeedChanged(int n);
void handleIconDownloadFinished(const QString &url, const QString &filePath);
void handleDownloadFinished(const QString &url, const QByteArray &data);
void handleDownloadFailed(const QString &url, const QString &error);
void handleIconDownloadFinished(const Net::DownloadResult &result);
void handleDownloadFinished(const Net::DownloadResult &result);
void handleParsingFinished(const Private::ParsingResult &result);
void handleArticleRead(Article *article);

65
src/base/search/searchpluginmanager.cpp
View File

@ -43,7 +43,6 @@
#include "base/global.h"
#include "base/logger.h"
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#include "base/preferences.h"
#include "base/profile.h"
@ -199,10 +198,8 @@ void SearchPluginManager::installPlugin(const QString &source)
if (Net::DownloadManager::hasSupportedScheme(source)) {
using namespace Net;
DownloadHandler *handler = DownloadManager::instance()->download(DownloadRequest(source).saveToFile(true));
connect(handler, static_cast<void (DownloadHandler::*)(const QString &, const QString &)>(&DownloadHandler::downloadFinished)
, this, &SearchPluginManager::pluginDownloaded);
connect(handler, &DownloadHandler::downloadFailed, this, &SearchPluginManager::pluginDownloadFailed);
DownloadManager::instance()->download(DownloadRequest(source).saveToFile(true)
, this, &SearchPluginManager::pluginDownloadFinished);
}
else {
QString path = source;
@ -304,10 +301,8 @@ void SearchPluginManager::checkForUpdates()
{
// Download version file from update server
using namespace Net;
DownloadHandler *handler = DownloadManager::instance()->download({m_updateUrl + "versions.txt"});
connect(handler, static_cast<void (DownloadHandler::*)(const QString &, const QByteArray &)>(&DownloadHandler::downloadFinished)
, this, &SearchPluginManager::versionInfoDownloaded);
connect(handler, &DownloadHandler::downloadFailed, this, &SearchPluginManager::versionInfoDownloadFailed);
DownloadManager::instance()->download({m_updateUrl + "versions.txt"}
, this, &SearchPluginManager::versionInfoDownloadFinished);
}
SearchDownloadHandler *SearchPluginManager::downloadTorrent(const QString &siteUrl, const QString &url)
@ -364,36 +359,32 @@ QString SearchPluginManager::engineLocation()
return location;
}
void SearchPluginManager::versionInfoDownloaded(const QString &url, const QByteArray &data)
void SearchPluginManager::versionInfoDownloadFinished(const Net::DownloadResult &result)
{
Q_UNUSED(url)
parseVersionInfo(data);
}
void SearchPluginManager::versionInfoDownloadFailed(const QString &url, const QString &reason)
{
Q_UNUSED(url)
emit checkForUpdatesFailed(tr("Update server is temporarily unavailable. %1").arg(reason));
}
void SearchPluginManager::pluginDownloaded(const QString &url, QString filePath)
{
filePath = Utils::Fs::fromNativePath(filePath);
QString pluginName = Utils::Fs::fileName(url);
pluginName.chop(pluginName.size() - pluginName.lastIndexOf('.')); // Remove extension
installPlugin_impl(pluginName, filePath);
Utils::Fs::forceRemove(filePath);
}
void SearchPluginManager::pluginDownloadFailed(const QString &url, const QString &reason)
{
QString pluginName = url.split('/').last();
pluginName.replace(".py", "", Qt::CaseInsensitive);
if (pluginInfo(pluginName))
emit pluginUpdateFailed(pluginName, tr("Failed to download the plugin file. %1").arg(reason));
if (result.status == Net::DownloadStatus::Success)
parseVersionInfo(result.data);
else
emit pluginInstallationFailed(pluginName, tr("Failed to download the plugin file. %1").arg(reason));
emit checkForUpdatesFailed(tr("Update server is temporarily unavailable. %1").arg(result.errorString));
}
void SearchPluginManager::pluginDownloadFinished(const Net::DownloadResult &result)
{
if (result.status == Net::DownloadStatus::Success) {
const QString filePath = Utils::Fs::fromNativePath(result.filePath);
QString pluginName = Utils::Fs::fileName(result.url);
pluginName.chop(pluginName.size() - pluginName.lastIndexOf('.')); // Remove extension
installPlugin_impl(pluginName, filePath);
Utils::Fs::forceRemove(filePath);
}
else {
QString pluginName = result.url.split('/').last();
pluginName.replace(".py", "", Qt::CaseInsensitive);
if (pluginInfo(pluginName))
emit pluginUpdateFailed(pluginName, tr("Failed to download the plugin file. %1").arg(result.errorString));
else
emit pluginInstallationFailed(pluginName, tr("Failed to download the plugin file. %1").arg(result.errorString));
}
}
// Update nova.py search plugin if necessary

11
src/base/search/searchpluginmanager.h
View File

@ -38,6 +38,11 @@
using PluginVersion = Utils::Version<unsigned short, 2>;
Q_DECLARE_METATYPE(PluginVersion)
namespace Net
{
struct DownloadResult;
}
struct PluginInfo
{
QString name;
@ -104,10 +109,8 @@ private:
void installPlugin_impl(const QString &name, const QString &path);
bool isUpdateNeeded(const QString &pluginName, PluginVersion newVersion) const;
void versionInfoDownloaded(const QString &url, const QByteArray &data);
void versionInfoDownloadFailed(const QString &url, const QString &reason);
void pluginDownloaded(const QString &url, QString filePath);
void pluginDownloadFailed(const QString &url, const QString &reason);
void versionInfoDownloadFinished(const Net::DownloadResult &result);
void pluginDownloadFinished(const Net::DownloadResult &result);
static QString pluginPath(const QString &name);

67
src/gui/addnewtorrentdialog.cpp
View File

@ -43,7 +43,6 @@
#include "base/bittorrent/torrenthandle.h"
#include "base/bittorrent/torrentinfo.h"
#include "base/global.h"
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#include "base/preferences.h"
#include "base/settingsstorage.h"
@ -238,12 +237,9 @@ void AddNewTorrentDialog::show(const QString &source, const BitTorrent::AddTorre
if (Net::DownloadManager::hasSupportedScheme(source)) {
// Launch downloader
Net::DownloadHandler *handler = Net::DownloadManager::instance()->download(
Net::DownloadRequest(source).limit(10485760 /* 10MB */).handleRedirectToMagnet(true));
connect(handler, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, dlg, &AddNewTorrentDialog::handleDownloadFinished);
connect(handler, &Net::DownloadHandler::downloadFailed, dlg, &AddNewTorrentDialog::handleDownloadFailed);
connect(handler, &Net::DownloadHandler::redirectedToMagnet, dlg, &AddNewTorrentDialog::handleRedirectedToMagnet);
Net::DownloadManager::instance()->download(
Net::DownloadRequest(source).limit(10485760 /* 10MB */)
, dlg, &AddNewTorrentDialog::handleDownloadFinished);
return;
}
@ -762,39 +758,36 @@ void AddNewTorrentDialog::setupTreeview()
showAdvancedSettings(settings()->loadValue(KEY_EXPANDED, false).toBool());
}
void AddNewTorrentDialog::handleDownloadFailed(const QString &url, const QString &reason)
{
RaisedMessageBox::critical(this, tr("Download Error"),
QString("Cannot download '%1': %2").arg(url, reason));
this->deleteLater();
}
void AddNewTorrentDialog::handleRedirectedToMagnet(const QString &url, const QString &magnetUri)
{
Q_UNUSED(url)
if (loadMagnet(BitTorrent::MagnetUri(magnetUri)))
open();
else
this->deleteLater();
}
void AddNewTorrentDialog::handleDownloadFinished(const QString &url, const QByteArray &data)
void AddNewTorrentDialog::handleDownloadFinished(const Net::DownloadResult &result)
{
QString error;
m_torrentInfo = BitTorrent::TorrentInfo::load(data, &error);
if (!m_torrentInfo.isValid()) {
RaisedMessageBox::critical(this, tr("Invalid torrent"), tr("Failed to load from URL: %1.\nError: %2")
.arg(url, error));
return;
switch (result.status) {
case Net::DownloadStatus::Success:
m_torrentInfo = BitTorrent::TorrentInfo::load(result.data, &error);
if (!m_torrentInfo.isValid()) {
RaisedMessageBox::critical(this, tr("Invalid torrent"), tr("Failed to load from URL: %1.\nError: %2")
.arg(result.url, error));
return;
}
m_torrentGuard.reset(new TorrentFileGuard);
if (loadTorrentImpl())
open();
else
deleteLater();
break;
case Net::DownloadStatus::RedirectedToMagnet:
if (loadMagnet(BitTorrent::MagnetUri(result.magnet)))
open();
else
deleteLater();
break;
default:
RaisedMessageBox::critical(this, tr("Download Error"),
tr("Cannot download '%1': %2").arg(result.url, result.errorString));
deleteLater();
}
m_torrentGuard.reset(new TorrentFileGuard);
if (loadTorrentImpl())
open();
else
this->deleteLater();
}
void AddNewTorrentDialog::TMMChanged(int index)

12
src/gui/addnewtorrentdialog.h
View File

@ -43,6 +43,11 @@ namespace BitTorrent
class MagnetUri;
}
namespace Net
{
struct DownloadResult;
}
namespace Ui
{
class AddNewTorrentDialog;
@ -55,12 +60,13 @@ class TorrentFileGuard;
class AddNewTorrentDialog : public QDialog
{
Q_OBJECT
Q_DISABLE_COPY(AddNewTorrentDialog)
public:
static const int minPathHistoryLength = 0;
static const int maxPathHistoryLength = 99;
~AddNewTorrentDialog();
~AddNewTorrentDialog() override;
static bool isEnabled();
static void setEnabled(bool value);
@ -79,9 +85,7 @@ private slots:
void onSavePathChanged(const QString &newPath);
void renameSelectedFile();
void updateMetadata(const BitTorrent::TorrentInfo &info);
void handleDownloadFailed(const QString &url, const QString &reason);
void handleRedirectedToMagnet(const QString &url, const QString &magnetUri);
void handleDownloadFinished(const QString &url, const QByteArray &data);
void handleDownloadFinished(const Net::DownloadResult &result);
void TMMChanged(int index);
void categoryChanged(int index);
void doNotDeleteTorrentClicked(bool checked);

42
src/gui/mainwindow.cpp
View File

@ -97,7 +97,6 @@
#include "utils.h"
#ifdef Q_OS_WIN
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#endif
#ifdef Q_OS_MAC
@ -2013,28 +2012,33 @@ void MainWindow::installPython()
const QString installerURL = ((QSysInfo::windowsVersion() >= QSysInfo::WV_VISTA)
? "https://www.python.org/ftp/python/3.6.6/python-3.6.6.exe"
: "https://www.python.org/ftp/python/3.4.4/python-3.4.4.msi");
Net::DownloadHandler *handler = Net::DownloadManager::instance()->download(
Net::DownloadRequest(installerURL).saveToFile(true));
using Func = void (Net::DownloadHandler::*)(const QString &, const QString &);
connect(handler, static_cast<Func>(&Net::DownloadHandler::downloadFinished), this, &MainWindow::pythonDownloadSuccess);
connect(handler, static_cast<Func>(&Net::DownloadHandler::downloadFailed), this, &MainWindow::pythonDownloadFailure);
Net::DownloadManager::instance()->download(
Net::DownloadRequest(installerURL).saveToFile(true)
, this, &MainWindow::pythonDownloadFinished);
}
void MainWindow::pythonDownloadSuccess(const QString &url, const QString &filePath)
void MainWindow::pythonDownloadFinished(const Net::DownloadResult &result)
{
Q_UNUSED(url)
if (result.status != Net::DownloadStatus::Success) {
setCursor(QCursor(Qt::ArrowCursor));
QMessageBox::warning(
this, tr("Download error")
, tr("Python setup could not be downloaded, reason: %1.\nPlease install it manually.")
.arg(result.errorString));
return;
}
setCursor(QCursor(Qt::ArrowCursor));
QProcess installer;
qDebug("Launching Python installer in passive mode...");
if (QSysInfo::windowsVersion() >= QSysInfo::WV_VISTA) {
QFile::rename(filePath, filePath + ".exe");
installer.start('"' + Utils::Fs::toNativePath(filePath) + ".exe\" /passive");
QFile::rename(result.filePath, result.filePath + ".exe");
installer.start('"' + Utils::Fs::toNativePath(result.filePath) + ".exe\" /passive");
}
else {
QFile::rename(filePath, filePath + ".msi");
installer.start(Utils::Misc::windowsSystemPath() + "\\msiexec.exe /passive /i \"" + Utils::Fs::toNativePath(filePath) + ".msi\"");
QFile::rename(result.filePath, result.filePath + ".msi");
installer.start(Utils::Misc::windowsSystemPath() + "\\msiexec.exe /passive /i \"" + Utils::Fs::toNativePath(result.filePath) + ".msi\"");
}
// Wait for setup to complete
@ -2045,21 +2049,13 @@ void MainWindow::pythonDownloadSuccess(const QString &url, const QString &filePa
qDebug("Setup should be complete!");
// Delete temp file
if (QSysInfo::windowsVersion() >= QSysInfo::WV_VISTA)
Utils::Fs::forceRemove(filePath + ".exe");
Utils::Fs::forceRemove(result.filePath + ".exe");
else
Utils::Fs::forceRemove(filePath + ".msi");
Utils::Fs::forceRemove(result.filePath + ".msi");
// Reload search engine
if (Utils::ForeignApps::pythonInfo().isSupportedVersion()) {
m_ui->actionSearchWidget->setChecked(true);
displaySearchTab(true);
}
}
void MainWindow::pythonDownloadFailure(const QString &url, const QString &error)
{
Q_UNUSED(url)
setCursor(QCursor(Qt::ArrowCursor));
QMessageBox::warning(this, tr("Download error"), tr("Python setup could not be downloaded, reason: %1.\nPlease install it manually.").arg(error));
}
#endif // Q_OS_WIN

8
src/gui/mainwindow.h
View File

@ -62,6 +62,11 @@ namespace BitTorrent
class TorrentHandle;
}
namespace Net
{
struct DownloadResult;
}
namespace Ui
{
class MainWindow;
@ -135,8 +140,7 @@ private slots:
void toggleAlternativeSpeeds();
#ifdef Q_OS_WIN
void pythonDownloadSuccess(const QString &url, const QString &filePath);
void pythonDownloadFailure(const QString &url, const QString &error);
void pythonDownloadFinished(const Net::DownloadResult &result);
#endif
void addToolbarContextMenu();
void manageCookies();

29
src/gui/programupdater.cpp
View File

@ -35,7 +35,6 @@
#include <QSysInfo>
#include <QXmlStreamReader>
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#include "base/utils/fs.h"
@ -56,16 +55,20 @@ void ProgramUpdater::checkForUpdates()
{
// Don't change this User-Agent. In case our updater goes haywire,
// the filehost can identify it and contact us.
Net::DownloadHandler *handler = Net::DownloadManager::instance()->download(
Net::DownloadRequest(RSS_URL).userAgent("qBittorrent/" QBT_VERSION_2 " ProgramUpdater (www.qbittorrent.org)"));
connect(handler, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, this, &ProgramUpdater::rssDownloadFinished);
connect(handler, &Net::DownloadHandler::downloadFailed, this, &ProgramUpdater::rssDownloadFailed);
Net::DownloadManager::instance()->download(
Net::DownloadRequest(RSS_URL).userAgent("qBittorrent/" QBT_VERSION_2 " ProgramUpdater (www.qbittorrent.org)")
, this, &ProgramUpdater::rssDownloadFinished);
}
void ProgramUpdater::rssDownloadFinished(const QString &url, const QByteArray &data)
void ProgramUpdater::rssDownloadFinished(const Net::DownloadResult &result)
{
Q_UNUSED(url);
if (result.status != Net::DownloadStatus::Success) {
qDebug() << "Downloading the new qBittorrent updates RSS failed:" << result.errorString;
emit updateCheckFinished(false, QString(), m_invokedByUser);
return;
}
qDebug("Finished downloading the new qBittorrent updates RSS");
#ifdef Q_OS_MAC
@ -77,7 +80,7 @@ void ProgramUpdater::rssDownloadFinished(const QString &url, const QByteArray &d
#endif
QString version;
QXmlStreamReader xml(data);
QXmlStreamReader xml(result.data);
bool inItem = false;
QString updateLink;
QString type;
@ -118,14 +121,6 @@ void ProgramUpdater::rssDownloadFinished(const QString &url, const QByteArray &d
emit updateCheckFinished(!m_updateUrl.isEmpty(), version, m_invokedByUser);
}
void ProgramUpdater::rssDownloadFailed(const QString &url, const QString &error)
{
Q_UNUSED(url);
qDebug() << "Downloading the new qBittorrent updates RSS failed:" << error;
emit updateCheckFinished(false, QString(), m_invokedByUser);
}
void ProgramUpdater::updateProgram()
{
Q_ASSERT(!m_updateUrl.isEmpty());

9
src/gui/programupdater.h
View File

@ -32,9 +32,15 @@
#include <QObject>
#include <QUrl>
namespace Net
{
struct DownloadResult;
}
class ProgramUpdater : public QObject
{
Q_OBJECT
Q_DISABLE_COPY(ProgramUpdater)
public:
explicit ProgramUpdater(QObject *parent = nullptr, bool invokedByUser = false);
@ -46,8 +52,7 @@ signals:
void updateCheckFinished(bool updateAvailable, QString version, bool invokedByUser);
private slots:
void rssDownloadFinished(const QString &url, const QByteArray &data);
void rssDownloadFailed(const QString &url, const QString &error);
void rssDownloadFinished(const Net::DownloadResult &result);
private:
bool isVersionMoreRecent(const QString &remoteVersion) const;

30
src/gui/properties/trackersadditiondialog.cpp
View File

@ -35,7 +35,6 @@
#include "base/bittorrent/torrenthandle.h"
#include "base/bittorrent/trackerentry.h"
#include "base/global.h"
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#include "base/utils/fs.h"
#include "base/utils/misc.h"
@ -71,16 +70,25 @@ QStringList TrackersAdditionDialog::newTrackers() const
void TrackersAdditionDialog::on_uTorrentListButton_clicked()
{
m_ui->uTorrentListButton->setEnabled(false);
Net::DownloadHandler *handler = Net::DownloadManager::instance()->download(m_ui->lineEditListURL->text());
connect(handler, static_cast<void (Net::DownloadHandler::*)(const QString &, const QByteArray &)>(&Net::DownloadHandler::downloadFinished)
, this, &TrackersAdditionDialog::parseUTorrentList);
connect(handler, &Net::DownloadHandler::downloadFailed, this, &TrackersAdditionDialog::getTrackerError);
Net::DownloadManager::instance()->download(m_ui->lineEditListURL->text()
, this, &TrackersAdditionDialog::torrentListDownloadFinished);
// Just to show that it takes times
setCursor(Qt::WaitCursor);
}
void TrackersAdditionDialog::parseUTorrentList(const QString &, const QByteArray &data)
void TrackersAdditionDialog::torrentListDownloadFinished(const Net::DownloadResult &result)
{
if (result.status != Net::DownloadStatus::Success) {
// To restore the cursor ...
setCursor(Qt::ArrowCursor);
m_ui->uTorrentListButton->setEnabled(true);
QMessageBox::warning(
this, tr("Download error")
, tr("The trackers list could not be downloaded, reason: %1")
.arg(result.errorString), QMessageBox::Ok);
return;
}
// Load from torrent handle
QList<BitTorrent::TrackerEntry> existingTrackers = m_torrent->trackers();
// Load from current user list
@ -96,7 +104,7 @@ void TrackersAdditionDialog::parseUTorrentList(const QString &, const QByteArray
m_ui->textEditTrackersList->insertPlainText("\n");
int nb = 0;
QBuffer buffer;
buffer.setData(data);
buffer.setData(result.data);
buffer.open(QBuffer::ReadOnly);
while (!buffer.atEnd()) {
const QString line = buffer.readLine().trimmed();
@ -117,14 +125,6 @@ void TrackersAdditionDialog::parseUTorrentList(const QString &, const QByteArray
QMessageBox::information(this, tr("No change"), tr("No additional trackers were found."), QMessageBox::Ok);
}
void TrackersAdditionDialog::getTrackerError(const QString &, const QString &error)
{
// To restore the cursor ...
setCursor(Qt::ArrowCursor);
m_ui->uTorrentListButton->setEnabled(true);
QMessageBox::warning(this, tr("Download error"), tr("The trackers list could not be downloaded, reason: %1").arg(error), QMessageBox::Ok);
}
QStringList TrackersAdditionDialog::askForTrackers(QWidget *parent, BitTorrent::TorrentHandle *const torrent)
{
QStringList trackers;

8
src/gui/properties/trackersadditiondialog.h
View File

@ -39,6 +39,11 @@ namespace BitTorrent
class TorrentHandle;
}
namespace Net
{
struct DownloadResult;
}
namespace Ui
{
class TrackersAdditionDialog;
@ -57,8 +62,7 @@ public:
public slots:
void on_uTorrentListButton_clicked();
void parseUTorrentList(const QString &, const QByteArray &data);
void getTrackerError(const QString &, const QString &error);
void torrentListDownloadFinished(const Net::DownloadResult &result);
private:
Ui::TrackersAdditionDialog *m_ui;

27
src/gui/search/pluginselectdialog.cpp
View File

@ -40,7 +40,6 @@
#include <QTableView>
#include "base/global.h"
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#include "base/utils/fs.h"
#include "autoexpandabledialog.h"
@ -291,11 +290,9 @@ void PluginSelectDialog::addNewPlugin(const QString &pluginName)
else {
// Icon is missing, we must download it
using namespace Net;
DownloadHandler *handler = DownloadManager::instance()->download(
DownloadRequest(plugin->url + "/favicon.ico").saveToFile(true));
connect(handler, static_cast<void (DownloadHandler::*)(const QString &, const QString &)>(&DownloadHandler::downloadFinished)
, this, &PluginSelectDialog::iconDownloaded);
connect(handler, &DownloadHandler::downloadFailed, this, &PluginSelectDialog::iconDownloadFailed);
DownloadManager::instance()->download(
DownloadRequest(plugin->url + "/favicon.ico").saveToFile(true)
, this, &PluginSelectDialog::iconDownloadFinished);
}
item->setText(PLUGIN_VERSION, plugin->version);
}
@ -369,9 +366,14 @@ void PluginSelectDialog::askForLocalPlugin()
}
}
void PluginSelectDialog::iconDownloaded(const QString &url, QString filePath)
void PluginSelectDialog::iconDownloadFinished(const Net::DownloadResult &result)
{
filePath = Utils::Fs::fromNativePath(filePath);
if (result.status != Net::DownloadStatus::Success) {
qDebug("Could not download favicon: %s, reason: %s", qUtf8Printable(result.url), qUtf8Printable(result.errorString));
return;
}
const QString filePath = Utils::Fs::fromNativePath(result.filePath);
// Icon downloaded
QIcon icon(filePath);
@ -379,7 +381,7 @@ void PluginSelectDialog::iconDownloaded(const QString &url, QString filePath)
QList<QSize> sizes = icon.availableSizes();
bool invalid = (sizes.isEmpty() || icon.pixmap(sizes.first()).isNull());
if (!invalid) {
for (QTreeWidgetItem *item : asConst(findItemsWithUrl(url))) {
for (QTreeWidgetItem *item : asConst(findItemsWithUrl(result.url))) {
QString id = item->text(PLUGIN_ID);
PluginInfo *plugin = m_pluginManager->pluginInfo(id);
if (!plugin) continue;
@ -387,7 +389,7 @@ void PluginSelectDialog::iconDownloaded(const QString &url, QString filePath)
QString iconPath = QString("%1/%2.%3")
.arg(SearchPluginManager::pluginsLocation()
, id
, url.endsWith(".ico", Qt::CaseInsensitive) ? "ico" : "png");
, result.url.endsWith(".ico", Qt::CaseInsensitive) ? "ico" : "png");
if (QFile::copy(filePath, iconPath)) {
// This 2nd check is necessary. Some favicons (eg from piratebay)
// decode fine without an ext, but fail to do so when appending the ext
@ -409,11 +411,6 @@ void PluginSelectDialog::iconDownloaded(const QString &url, QString filePath)
Utils::Fs::forceRemove(filePath);
}
void PluginSelectDialog::iconDownloadFailed(const QString &url, const QString &reason)
{
qDebug("Could not download favicon: %s, reason: %s", qUtf8Printable(url), qUtf8Printable(reason));
}
void PluginSelectDialog::checkForUpdatesFinished(const QHash<QString, PluginVersion> &updateInfo)
{
finishAsyncOp();

11
src/gui/search/pluginselectdialog.h
View File

@ -38,6 +38,11 @@ class QDropEvent;
class QStringList;
class QTreeWidgetItem;
namespace Net
{
struct DownloadResult;
}
namespace Ui
{
class PluginSelectDialog;
@ -46,10 +51,11 @@ namespace Ui
class PluginSelectDialog : public QDialog
{
Q_OBJECT
Q_DISABLE_COPY(PluginSelectDialog)
public:
explicit PluginSelectDialog(SearchPluginManager *pluginManager, QWidget *parent = nullptr);
~PluginSelectDialog();
~PluginSelectDialog() override;
QList<QTreeWidgetItem*> findItemsWithUrl(const QString &url);
QTreeWidgetItem *findItemWithID(const QString &id);
@ -69,8 +75,7 @@ private slots:
void enableSelection(bool enable);
void askForLocalPlugin();
void askForPluginUrl();
void iconDownloaded(const QString &url, QString filePath);
void iconDownloadFailed(const QString &url, const QString &reason);
void iconDownloadFinished(const Net::DownloadResult &result);
void checkForUpdatesFinished(const QHash<QString, PluginVersion> &updateInfo);
void checkForUpdatesFailed(const QString &reason);

42
src/gui/transferlistfilterswidget.cpp
View File

@ -42,7 +42,6 @@
#include "base/bittorrent/trackerentry.h"
#include "base/global.h"
#include "base/logger.h"
#include "base/net/downloadhandler.h"
#include "base/net/downloadmanager.h"
#include "base/preferences.h"
#include "base/torrentfilter.h"
@ -406,49 +405,44 @@ void TrackerFiltersList::trackerWarning(const QString &hash, const QString &trac
void TrackerFiltersList::downloadFavicon(const QString &url)
{
if (!m_downloadTrackerFavicon) return;
Net::DownloadHandler *h = Net::DownloadManager::instance()->download(
Net::DownloadRequest(url).saveToFile(true));
using Func = void (Net::DownloadHandler::*)(const QString &, const QString &);
connect(h, static_cast<Func>(&Net::DownloadHandler::downloadFinished), this
, &TrackerFiltersList::handleFavicoDownload);
connect(h, static_cast<Func>(&Net::DownloadHandler::downloadFailed), this
, &TrackerFiltersList::handleFavicoFailure);
Net::DownloadManager::instance()->download(
Net::DownloadRequest(url).saveToFile(true)
, this, &TrackerFiltersList::handleFavicoDownloadFinished);
}
void TrackerFiltersList::handleFavicoDownload(const QString &url, const QString &filePath)
void TrackerFiltersList::handleFavicoDownloadFinished(const Net::DownloadResult &result)
{
const QString host = getHost(url);
if (result.status != Net::DownloadStatus::Success) {
if (result.url.endsWith(".ico", Qt::CaseInsensitive))
downloadFavicon(result.url.left(result.url.size() - 4) + ".png");
return;
}
const QString host = getHost(result.url);
if (!m_trackers.contains(host)) {
Utils::Fs::forceRemove(filePath);
Utils::Fs::forceRemove(result.filePath);
return;
}
QListWidgetItem *trackerItem = item(rowFromTracker(host));
if (!trackerItem) return;
QIcon icon(filePath);
QIcon icon(result.filePath);
//Detect a non-decodable icon
QList<QSize> sizes = icon.availableSizes();
bool invalid = (sizes.isEmpty() || icon.pixmap(sizes.first()).isNull());
if (invalid) {
if (url.endsWith(".ico", Qt::CaseInsensitive))
downloadFavicon(url.left(url.size() - 4) + ".png");
Utils::Fs::forceRemove(filePath);
if (result.url.endsWith(".ico", Qt::CaseInsensitive))
downloadFavicon(result.url.left(result.url.size() - 4) + ".png");
Utils::Fs::forceRemove(result.filePath);
}
else {
trackerItem->setData(Qt::DecorationRole, QVariant(QIcon(filePath)));
m_iconPaths.append(filePath);
trackerItem->setData(Qt::DecorationRole, QVariant(QIcon(result.filePath)));
m_iconPaths.append(result.filePath);
}
}
void TrackerFiltersList::handleFavicoFailure(const QString &url, const QString &error)
{
Q_UNUSED(error)
if (url.endsWith(".ico", Qt::CaseInsensitive))
downloadFavicon(url.left(url.size() - 4) + ".png");
}
void TrackerFiltersList::showMenu(QPoint)
{
QMenu menu(this);

11
src/gui/transferlistfilterswidget.h
View File

@ -42,9 +42,15 @@ namespace BitTorrent
class TrackerEntry;
}
namespace Net
{
struct DownloadResult;
}
class BaseFilterWidget : public QListWidget
{
Q_OBJECT
Q_DISABLE_COPY(BaseFilterWidget)
public:
BaseFilterWidget(QWidget *parent, TransferListWidget *transferList);
@ -68,6 +74,7 @@ private slots:
class StatusFilterWidget : public BaseFilterWidget
{
Q_OBJECT
Q_DISABLE_COPY(StatusFilterWidget)
public:
StatusFilterWidget(QWidget *parent, TransferListWidget *transferList);
@ -88,6 +95,7 @@ private:
class TrackerFiltersList : public BaseFilterWidget
{
Q_OBJECT
Q_DISABLE_COPY(TrackerFiltersList)
public:
TrackerFiltersList(QWidget *parent, TransferListWidget *transferList);
@ -105,8 +113,7 @@ public slots:
void trackerWarning(const QString &hash, const QString &tracker);
private slots:
void handleFavicoDownload(const QString &url, const QString &filePath);
void handleFavicoFailure(const QString &url, const QString &error);
void handleFavicoDownloadFinished(const Net::DownloadResult &result);
private:
// These 4 methods are virtual slots in the base class.