transmission/qt/Session.cc

1194 lines
32 KiB
C++
Raw Normal View History

// This file Copyright © 2009-2023 Mnemosyne LLC.
// It may be used under GPLv2 (SPDX: GPL-2.0-only), GPLv3 (SPDX: GPL-3.0-only),
// or any future license endorsed by Mnemosyne LLC.
// License text can be found in the licenses/ folder.
2009-04-09 18:55:47 +00:00
#include <algorithm>
#include <array>
2009-04-09 18:55:47 +00:00
#include <cassert>
#include <string_view>
2022-09-21 23:34:18 +00:00
#include <utility>
2009-04-09 18:55:47 +00:00
#include <QApplication>
#include <QByteArray>
#include <QClipboard>
2009-04-09 18:55:47 +00:00
#include <QCoreApplication>
#include <QDebug>
2009-04-09 18:55:47 +00:00
#include <QDesktopServices>
#include <QFile>
#include <QFileInfo>
2009-04-09 18:55:47 +00:00
#include <QMessageBox>
#include <QStyle>
#include <QTextStream>
#include <QtDebug>
2009-04-09 18:55:47 +00:00
#include <libtransmission/transmission.h>
2022-08-04 13:44:18 +00:00
#include <libtransmission/session-id.h>
2022-08-18 14:14:12 +00:00
#include <libtransmission/utils.h>
#include <libtransmission/variant.h>
2009-04-09 18:55:47 +00:00
#include "Session.h"
#include "AddData.h"
#include "CustomVariantType.h"
#include "Prefs.h"
#include "RpcQueue.h"
#include "SessionDialog.h"
#include "Torrent.h"
#include "Utils.h"
#include "VariantHelpers.h"
using ::trqt::variant_helpers::dictAdd;
using ::trqt::variant_helpers::dictFind;
using ::trqt::variant_helpers::getValue;
2009-04-09 18:55:47 +00:00
/***
****
***/
void Session::sessionSet(tr_quark const key, QVariant const& value)
2009-04-09 18:55:47 +00:00
{
tr_variant args;
tr_variantInitDict(&args, 1);
2023-02-10 17:58:43 +00:00
#if QT_VERSION >= QT_VERSION_CHECK(6, 2, 0)
switch (value.typeId())
#else
switch (static_cast<QMetaType::Type>(value.type()))
#endif
{
2023-02-10 17:58:43 +00:00
case QMetaType::Bool:
dictAdd(&args, key, value.toBool());
break;
2023-02-10 17:58:43 +00:00
case QMetaType::Int:
dictAdd(&args, key, value.toInt());
break;
2023-02-10 17:58:43 +00:00
case QMetaType::Double:
dictAdd(&args, key, value.toDouble());
break;
2023-02-10 17:58:43 +00:00
case QMetaType::QString:
dictAdd(&args, key, value.toString());
break;
default:
assert(false);
}
exec("session-set", &args);
}
void Session::portTest()
{
auto* q = new RpcQueue{};
q->add([this]() { return exec("port-test", nullptr); });
q->add(
[this](RpcResponse const& r)
{
bool is_open = false;
if (r.success)
{
auto const value = dictFind<bool>(r.args.get(), TR_KEY_port_is_open);
if (value)
{
is_open = *value;
}
}
emit portTested(is_open);
});
q->run();
}
void Session::copyMagnetLinkToClipboard(int torrent_id)
{
auto constexpr MagnetLinkKey = std::string_view{ "magnetLink" };
auto constexpr Fields = std::array<std::string_view, 1>{ MagnetLinkKey };
tr_variant args;
tr_variantInitDict(&args, 2);
dictAdd(&args, TR_KEY_ids, std::array<int, 1>{ torrent_id });
dictAdd(&args, TR_KEY_fields, Fields);
auto* q = new RpcQueue{};
q->add([this, &args]() { return exec(TR_KEY_torrent_get, &args); });
q->add(
[](RpcResponse const& r)
{
tr_variant* torrents = nullptr;
if (!tr_variantDictFindList(r.args.get(), TR_KEY_torrents, &torrents))
{
return;
}
tr_variant* const child = tr_variantListChild(torrents, 0);
if (child != nullptr)
{
auto const link = dictFind<QString>(child, TR_KEY_magnetLink);
if (link)
{
QApplication::clipboard()->setText(*link);
}
}
});
q->run();
}
void Session::updatePref(int key)
{
if (prefs_.isCore(key))
{
switch (key)
{
case Prefs::ALT_SPEED_LIMIT_DOWN:
case Prefs::ALT_SPEED_LIMIT_ENABLED:
case Prefs::ALT_SPEED_LIMIT_TIME_BEGIN:
case Prefs::ALT_SPEED_LIMIT_TIME_DAY:
case Prefs::ALT_SPEED_LIMIT_TIME_ENABLED:
case Prefs::ALT_SPEED_LIMIT_TIME_END:
case Prefs::ALT_SPEED_LIMIT_UP:
case Prefs::BLOCKLIST_DATE:
case Prefs::BLOCKLIST_ENABLED:
case Prefs::BLOCKLIST_URL:
2022-02-20 17:54:20 +00:00
case Prefs::DEFAULT_TRACKERS:
case Prefs::DHT_ENABLED:
case Prefs::DOWNLOAD_QUEUE_ENABLED:
case Prefs::DOWNLOAD_QUEUE_SIZE:
case Prefs::DSPEED:
case Prefs::DSPEED_ENABLED:
case Prefs::IDLE_LIMIT:
case Prefs::IDLE_LIMIT_ENABLED:
case Prefs::INCOMPLETE_DIR:
case Prefs::INCOMPLETE_DIR_ENABLED:
case Prefs::LPD_ENABLED:
case Prefs::PEER_LIMIT_GLOBAL:
case Prefs::PEER_LIMIT_TORRENT:
case Prefs::PEER_PORT:
case Prefs::PEER_PORT_RANDOM_ON_START:
case Prefs::QUEUE_STALLED_MINUTES:
case Prefs::PEX_ENABLED:
case Prefs::PORT_FORWARDING:
case Prefs::RENAME_PARTIAL_FILES:
case Prefs::SCRIPT_TORRENT_DONE_ENABLED:
case Prefs::SCRIPT_TORRENT_DONE_FILENAME:
case Prefs::SCRIPT_TORRENT_DONE_SEEDING_ENABLED:
case Prefs::SCRIPT_TORRENT_DONE_SEEDING_FILENAME:
case Prefs::START:
case Prefs::TRASH_ORIGINAL:
case Prefs::USPEED:
case Prefs::USPEED_ENABLED:
case Prefs::UTP_ENABLED:
sessionSet(prefs_.getKey(key), prefs_.variant(key));
break;
case Prefs::DOWNLOAD_DIR:
sessionSet(prefs_.getKey(key), prefs_.variant(key));
/* this will change the 'freespace' argument, so refresh */
refreshSessionInfo();
break;
case Prefs::RATIO:
sessionSet(TR_KEY_seedRatioLimit, prefs_.variant(key));
break;
case Prefs::RATIO_ENABLED:
sessionSet(TR_KEY_seedRatioLimited, prefs_.variant(key));
break;
case Prefs::ENCRYPTION:
switch (int const i = prefs_.variant(key).toInt(); i)
{
case 0:
sessionSet(prefs_.getKey(key), QStringLiteral("tolerated"));
break;
case 1:
sessionSet(prefs_.getKey(key), QStringLiteral("preferred"));
break;
case 2:
sessionSet(prefs_.getKey(key), QStringLiteral("required"));
break;
}
break;
case Prefs::RPC_AUTH_REQUIRED:
if (session_ != nullptr)
{
tr_sessionSetRPCPasswordEnabled(session_, prefs_.getBool(key));
}
break;
case Prefs::RPC_ENABLED:
if (session_ != nullptr)
{
tr_sessionSetRPCEnabled(session_, prefs_.getBool(key));
}
break;
case Prefs::RPC_PASSWORD:
if (session_ != nullptr)
{
tr_sessionSetRPCPassword(session_, prefs_.getString(key).toUtf8().constData());
}
break;
case Prefs::RPC_PORT:
if (session_ != nullptr)
{
tr_sessionSetRPCPort(session_, static_cast<uint16_t>(prefs_.getInt(key)));
}
break;
case Prefs::RPC_USERNAME:
if (session_ != nullptr)
{
tr_sessionSetRPCUsername(session_, prefs_.getString(key).toUtf8().constData());
}
break;
case Prefs::RPC_WHITELIST_ENABLED:
if (session_ != nullptr)
{
tr_sessionSetRPCWhitelistEnabled(session_, prefs_.getBool(key));
}
break;
case Prefs::RPC_WHITELIST:
if (session_ != nullptr)
{
tr_sessionSetRPCWhitelist(session_, prefs_.getString(key).toUtf8().constData());
}
break;
default:
qWarning() << "unhandled pref:" << key;
}
2009-04-09 18:55:47 +00:00
}
}
/***
****
***/
Session::Session(QString config_dir, Prefs& prefs)
: config_dir_{ std::move(config_dir) }
, prefs_{ prefs }
2009-04-09 18:55:47 +00:00
{
connect(&prefs_, &Prefs::changed, this, &Session::updatePref);
connect(&rpc_, &RpcClient::httpAuthenticationRequired, this, &Session::httpAuthenticationRequired);
connect(&rpc_, &RpcClient::dataReadProgress, this, &Session::dataReadProgress);
connect(&rpc_, &RpcClient::dataSendProgress, this, &Session::dataSendProgress);
connect(&rpc_, &RpcClient::networkResponse, this, &Session::networkResponse);
duplicates_timer_.setSingleShot(true);
connect(&duplicates_timer_, &QTimer::timeout, this, &Session::onDuplicatesTimer);
}
Session::~Session()
{
stop();
}
/***
****
***/
void Session::stop()
{
rpc_.stop();
if (session_ != nullptr)
2009-04-09 18:55:47 +00:00
{
tr_sessionClose(session_);
session_ = nullptr;
}
}
void Session::restart()
{
stop();
start();
}
void Session::start()
{
if (prefs_.get<bool>(Prefs::SESSION_IS_REMOTE))
{
QUrl url;
if (prefs_.get<bool>(Prefs::SESSION_REMOTE_HTTPS))
{
url.setScheme(QStringLiteral("https"));
}
else
{
url.setScheme(QStringLiteral("http"));
}
url.setHost(prefs_.get<QString>(Prefs::SESSION_REMOTE_HOST));
url.setPort(prefs_.get<int>(Prefs::SESSION_REMOTE_PORT));
url.setPath(QStringLiteral("/transmission/rpc"));
if (prefs_.get<bool>(Prefs::SESSION_REMOTE_AUTH))
{
url.setUserName(prefs_.get<QString>(Prefs::SESSION_REMOTE_USERNAME));
url.setPassword(prefs_.get<QString>(Prefs::SESSION_REMOTE_PASSWORD));
}
rpc_.start(url);
2009-04-09 18:55:47 +00:00
}
else
2009-04-09 18:55:47 +00:00
{
tr_variant settings;
tr_variantInitDict(&settings, 0);
tr_sessionLoadSettings(&settings, config_dir_.toUtf8().constData(), "qt");
session_ = tr_sessionInit(config_dir_.toUtf8().constData(), true, &settings);
tr_variantClear(&settings);
rpc_.start(session_);
auto* const ctor = tr_ctorNew(session_);
2022-08-18 14:14:12 +00:00
tr_sessionLoadTorrents(session_, ctor);
tr_ctorFree(ctor);
2009-04-09 18:55:47 +00:00
}
emit sourceChanged();
2009-04-09 18:55:47 +00:00
}
bool Session::isServer() const
2009-04-09 18:55:47 +00:00
{
return session_ != nullptr;
2009-04-09 18:55:47 +00:00
}
bool Session::isLocal() const
2009-04-09 18:55:47 +00:00
{
if (!session_id_.isEmpty())
{
return is_definitely_local_session_;
}
return rpc_.isLocal();
2009-04-09 18:55:47 +00:00
}
/***
****
***/
void Session::addOptionalIds(tr_variant* args_dict, torrent_ids_t const& torrent_ids) const
{
auto constexpr RecentlyActiveKey = std::string_view{ "recently-active" };
if (&torrent_ids == &RecentlyActiveIDs)
{
dictAdd(args_dict, TR_KEY_ids, RecentlyActiveKey);
}
else if (!std::empty(torrent_ids))
{
dictAdd(args_dict, TR_KEY_ids, torrent_ids);
}
}
Session::Tag Session::torrentSetImpl(tr_variant* args)
{
auto* const q = new RpcQueue{};
auto const tag = q->tag();
q->add([this, args]() { return rpc_.exec(TR_KEY_torrent_set, args); });
q->add([this, tag]() { emit sessionCalled(tag); });
q->setTolerateErrors();
q->run();
return tag;
}
Session::Tag Session::torrentSet(torrent_ids_t const& torrent_ids, tr_quark const key, double value)
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, key, value);
return torrentSetImpl(&args);
}
Session::Tag Session::torrentSet(torrent_ids_t const& torrent_ids, tr_quark const key, int value)
2009-04-09 18:55:47 +00:00
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, key, value);
return torrentSetImpl(&args);
2009-04-09 18:55:47 +00:00
}
Session::Tag Session::torrentSet(torrent_ids_t const& torrent_ids, tr_quark const key, bool value)
2009-04-09 18:55:47 +00:00
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, key, value);
return torrentSetImpl(&args);
2009-04-09 18:55:47 +00:00
}
Session::Tag Session::torrentSet(torrent_ids_t const& torrent_ids, tr_quark const key, QString const& value)
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, key, value);
return torrentSetImpl(&args);
}
Session::Tag Session::torrentSet(torrent_ids_t const& torrent_ids, tr_quark const key, QStringList const& value)
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, key, value);
return torrentSetImpl(&args);
}
Session::Tag Session::torrentSet(torrent_ids_t const& torrent_ids, tr_quark const key, QList<int> const& value)
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, key, value);
return torrentSetImpl(&args);
}
void Session::torrentSetLocation(torrent_ids_t const& torrent_ids, QString const& path, bool do_move)
{
tr_variant args;
tr_variantInitDict(&args, 3);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, TR_KEY_location, path);
dictAdd(&args, TR_KEY_move, do_move);
exec(TR_KEY_torrent_set_location, &args);
}
void Session::torrentRenamePath(torrent_ids_t const& torrent_ids, QString const& oldpath, QString const& newname)
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, torrent_ids);
dictAdd(&args, TR_KEY_path, oldpath);
dictAdd(&args, TR_KEY_name, newname);
auto* q = new RpcQueue{};
q->add(
[this, &args]() { return exec("torrent-rename-path", &args); },
fix: gcc warnings in libtransmission/ and utils/ (#843) * fix: __attribute__(__printf__) warnings * fix: implicit fallthrough warning * fixup! fix: implicit fallthrough warning * fix: disable warnings for 3rd party code Since we want to leave upstream code as-is * fixup! fix: disable warnings for 3rd party code * fixup! fix: disable warnings for 3rd party code * silence spurious alignment warning Xrefs Discussion: https://stackoverflow.com/a/35554349 Macro inspiration: https://pagure.io/SSSD/sssd/blob/90ac46f71068d131391492360a8553bdd005b5a7/f/src/util/util_safealign.h#_35 * fixup! fix: disable warnings for 3rd party code * fixup! fix: implicit fallthrough warning * make uncrustify happy * remove uncrustify-test.sh that's probably off-topic for this PR * fixup! fix: __attribute__(__printf__) warnings * Update libtransmission/CMakeLists.txt Co-Authored-By: ckerr <ckerr@github.com> * fixup! silence spurious alignment warning * use -w for DISABLE_WARNINGS in Clang * refactor: fix libtransmission deprecation warnings * fix: pthread_create's start_routine's return value This was defined as `void` on non-Windows but should have been `void*` * chore: uncrustify * fix: add DISABLE_WARNINGS option for SunPro Studio * fix "unused in lambda capture" warnings by clang++ * fix 'increases required alignment' warning Caused from storing int16_t's in a char array. * fix net.c 'increases required alignment' warning The code passes in a `struct sockaddr_storage*` which is a padded struct large enough for the necessary alignment. Unfortunately it was recast as a `struct sockaddr*` which has less padding and a smaller alignment. The warning occrred because of these differing alignments. * make building quieter so warnings are more visible * fixup! fix 'increases required alignment' warning * Fix -Wcast-function-type warnings in GTK+ app code https://gitlab.gnome.org/GNOME/gnome-terminal/issues/96 talks about both the issue and its solution. GCC 8's -Wcast-function-type, enabled by -Wextra, is problematic in glib applications because it's idiomatic there to recast function signatures, e.g. `g_slist_free(list, (GFunc)g_free, NULL);`. Disabling the warning with pragmas causes "unrecognized pragma" warnings on clang and older versions of gcc, and disabling the warning could miss actual bugs. GCC defines `void (*)(void)` as a special case that matches anything so we can silence warnings by double-casting through GCallback. In the previous example, the warning is silenced by changing the code to read `g_slist_free(list, (GFunc)(GCallback)g_free, NULL);`). * fixup! fix "unused in lambda capture" warnings by clang++ * fixup! fix "unused in lambda capture" warnings by clang++ * fix two more libtransmission compiler warnings * fix: in watchdir, use TR_ENABLE_ASSERTS not NDEBUG
2019-11-06 17:27:03 +00:00
[](RpcResponse const& r)
{
2022-11-15 16:25:12 +00:00
auto const path = dictFind<QString>(r.args.get(), TR_KEY_path).value_or(QStringLiteral("(unknown)"));
auto const name = dictFind<QString>(r.args.get(), TR_KEY_name).value_or(QStringLiteral("(unknown)"));
auto* d = new QMessageBox{
QMessageBox::Information,
tr("Error Renaming Path"),
tr(R"(<p><b>Unable to rename "%1" as "%2": %3.</b></p><p>Please correct the errors and try again.</p>)")
.arg(path)
.arg(name)
.arg(r.result),
QMessageBox::Close,
QApplication::activeWindow()
};
QObject::connect(d, &QMessageBox::rejected, d, &QMessageBox::deleteLater);
d->show();
});
q->add([this, torrent_ids](RpcResponse const& /*r*/) { refreshTorrents(torrent_ids, TorrentProperties::Rename); });
q->run();
}
std::vector<std::string_view> const& Session::getKeyNames(TorrentProperties props)
2009-04-09 18:55:47 +00:00
{
std::vector<std::string_view>& names = names_[props];
if (names.empty())
{
// unchanging fields needed by the main window
static auto constexpr MainInfoKeys = std::array<tr_quark, 8>{
TR_KEY_addedDate, //
TR_KEY_downloadDir, //
TR_KEY_file_count, //
TR_KEY_hashString, //
TR_KEY_name, //
TR_KEY_primary_mime_type, //
TR_KEY_totalSize, //
TR_KEY_trackers, //
};
// changing fields needed by the main window
static auto constexpr MainStatKeys = std::array<tr_quark, 25>{
TR_KEY_downloadedEver,
TR_KEY_editDate,
TR_KEY_error,
TR_KEY_errorString,
TR_KEY_eta,
TR_KEY_haveUnchecked,
TR_KEY_haveValid,
TR_KEY_isFinished,
TR_KEY_leftUntilDone,
TR_KEY_manualAnnounceTime,
TR_KEY_metadataPercentComplete,
TR_KEY_peersConnected,
TR_KEY_peersGettingFromUs,
TR_KEY_peersSendingToUs,
TR_KEY_percentDone,
TR_KEY_queuePosition,
TR_KEY_rateDownload,
TR_KEY_rateUpload,
TR_KEY_recheckProgress,
TR_KEY_seedRatioLimit,
TR_KEY_seedRatioMode,
TR_KEY_sizeWhenDone,
TR_KEY_status,
TR_KEY_uploadedEver,
TR_KEY_webseedsSendingToUs,
};
// unchanging fields needed by the details dialog
static auto constexpr DetailInfoKeys = std::array<tr_quark, 9>{
TR_KEY_comment, //
TR_KEY_creator, //
TR_KEY_dateCreated, //
TR_KEY_files, //
TR_KEY_isPrivate, //
TR_KEY_pieceCount, //
TR_KEY_pieceSize, //
TR_KEY_trackerList, //
TR_KEY_trackers, //
};
// changing fields needed by the details dialog
static auto constexpr DetailStatKeys = std::array<tr_quark, 18>{
TR_KEY_activityDate, //
TR_KEY_bandwidthPriority, //
TR_KEY_corruptEver, //
TR_KEY_desiredAvailable, //
TR_KEY_downloadedEver, //
TR_KEY_downloadLimit, //
TR_KEY_downloadLimited, //
TR_KEY_fileStats, //
TR_KEY_haveUnchecked, //
TR_KEY_honorsSessionLimits, //
TR_KEY_peer_limit, //
TR_KEY_peers, //
TR_KEY_seedIdleLimit, //
TR_KEY_seedIdleMode, //
TR_KEY_startDate, //
TR_KEY_trackerStats, //
TR_KEY_uploadLimit, //
TR_KEY_uploadLimited, //
};
// keys needed after renaming a torrent
static auto constexpr RenameKeys = std::array<tr_quark, 3>{
TR_KEY_fileStats,
TR_KEY_files,
TR_KEY_name,
};
auto const append = [&names](tr_quark key)
{
names.emplace_back(tr_quark_get_string_view(key));
};
switch (props)
{
case TorrentProperties::DetailInfo:
std::for_each(DetailInfoKeys.begin(), DetailInfoKeys.end(), append);
break;
case TorrentProperties::DetailStat:
std::for_each(DetailStatKeys.begin(), DetailStatKeys.end(), append);
break;
case TorrentProperties::MainAll:
std::for_each(MainInfoKeys.begin(), MainInfoKeys.end(), append);
std::for_each(MainStatKeys.begin(), MainStatKeys.end(), append);
break;
case TorrentProperties::MainInfo:
std::for_each(MainInfoKeys.begin(), MainInfoKeys.end(), append);
break;
case TorrentProperties::MainStats:
std::for_each(MainStatKeys.begin(), MainStatKeys.end(), append);
break;
case TorrentProperties::Rename:
std::for_each(RenameKeys.begin(), RenameKeys.end(), append);
break;
}
// must be in every torrent req
append(TR_KEY_id);
// sort and remove dupes
std::sort(names.begin(), names.end());
names.erase(std::unique(names.begin(), names.end()), names.end());
}
return names;
}
void Session::refreshTorrents(torrent_ids_t const& torrent_ids, TorrentProperties props)
{
auto constexpr Table = std::string_view{ "table" };
tr_variant args;
tr_variantInitDict(&args, 3);
dictAdd(&args, TR_KEY_format, Table);
dictAdd(&args, TR_KEY_fields, getKeyNames(props));
addOptionalIds(&args, torrent_ids);
auto* q = new RpcQueue{};
q->add([this, &args]() { return exec(TR_KEY_torrent_get, &args); });
bool const all_torrents = std::empty(torrent_ids);
q->add(
[this, all_torrents](RpcResponse const& r)
{
tr_variant* torrents = nullptr;
if (tr_variantDictFindList(r.args.get(), TR_KEY_torrents, &torrents))
{
emit torrentsUpdated(torrents, all_torrents);
}
if (tr_variantDictFindList(r.args.get(), TR_KEY_removed, &torrents))
{
emit torrentsRemoved(torrents);
}
});
q->run();
2009-04-09 18:55:47 +00:00
}
void Session::refreshDetailInfo(torrent_ids_t const& ids)
{
refreshTorrents(ids, TorrentProperties::DetailInfo);
}
void Session::refreshExtraStats(torrent_ids_t const& ids)
2009-04-09 18:55:47 +00:00
{
refreshTorrents(ids, TorrentProperties::DetailStat);
2009-04-09 18:55:47 +00:00
}
void Session::sendTorrentRequest(std::string_view request, torrent_ids_t const& torrent_ids)
2009-04-09 18:55:47 +00:00
{
tr_variant args;
tr_variantInitDict(&args, 1);
addOptionalIds(&args, torrent_ids);
2009-04-09 18:55:47 +00:00
auto* q = new RpcQueue{};
q->add([this, request, &args]() { return exec(request, &args); });
q->add([this, torrent_ids]() { refreshTorrents(torrent_ids, TorrentProperties::MainStats); });
q->run();
2009-04-09 18:55:47 +00:00
}
void Session::pauseTorrents(torrent_ids_t const& ids)
{
sendTorrentRequest("torrent-stop", ids);
}
void Session::startTorrents(torrent_ids_t const& ids)
{
sendTorrentRequest("torrent-start", ids);
}
void Session::startTorrentsNow(torrent_ids_t const& ids)
{
sendTorrentRequest("torrent-start-now", ids);
}
void Session::queueMoveTop(torrent_ids_t const& ids)
{
sendTorrentRequest("queue-move-top", ids);
}
void Session::queueMoveUp(torrent_ids_t const& ids)
{
sendTorrentRequest("queue-move-up", ids);
}
void Session::queueMoveDown(torrent_ids_t const& ids)
{
sendTorrentRequest("queue-move-down", ids);
}
void Session::queueMoveBottom(torrent_ids_t const& ids)
{
sendTorrentRequest("queue-move-bottom", ids);
}
2009-04-09 18:55:47 +00:00
void Session::refreshActiveTorrents()
2009-04-09 18:55:47 +00:00
{
// If this object is passed as "ids" (compared by address), then recently active torrents are queried.
refreshTorrents(RecentlyActiveIDs, TorrentProperties::MainStats);
2009-04-09 18:55:47 +00:00
}
void Session::refreshAllTorrents()
2009-04-09 18:55:47 +00:00
{
// if an empty ids object is used, all torrents are queried.
torrent_ids_t const ids = {};
refreshTorrents(ids, TorrentProperties::MainStats);
2009-04-09 18:55:47 +00:00
}
void Session::initTorrents(torrent_ids_t const& ids)
2009-04-09 18:55:47 +00:00
{
refreshTorrents(ids, TorrentProperties::MainAll);
2009-04-09 18:55:47 +00:00
}
void Session::refreshSessionStats()
2009-04-09 18:55:47 +00:00
{
auto* q = new RpcQueue{};
q->add([this]() { return exec("session-stats", nullptr); });
q->add([this](RpcResponse const& r) { updateStats(r.args.get()); });
q->run();
2009-04-09 18:55:47 +00:00
}
void Session::refreshSessionInfo()
2009-04-09 18:55:47 +00:00
{
auto* q = new RpcQueue{};
q->add([this]() { return exec("session-get", nullptr); });
q->add([this](RpcResponse const& r) { updateInfo(r.args.get()); });
q->run();
2009-04-09 18:55:47 +00:00
}
void Session::updateBlocklist()
2009-04-09 18:55:47 +00:00
{
auto* q = new RpcQueue{};
q->add([this]() { return exec("blocklist-update", nullptr); });
q->add(
[this](RpcResponse const& r)
{
if (auto const size = dictFind<int>(r.args.get(), TR_KEY_blocklist_size); size)
{
setBlocklistSize(*size);
}
});
q->run();
2009-04-09 18:55:47 +00:00
}
/***
****
***/
RpcResponseFuture Session::exec(tr_quark method, tr_variant* args)
2009-04-09 18:55:47 +00:00
{
return rpc_.exec(method, args);
2009-04-09 18:55:47 +00:00
}
RpcResponseFuture Session::exec(std::string_view method, tr_variant* args)
2009-04-09 18:55:47 +00:00
{
return rpc_.exec(method, args);
2009-04-09 18:55:47 +00:00
}
void Session::updateStats(tr_variant* args_dict, tr_session_stats* stats)
2009-04-09 18:55:47 +00:00
{
if (auto const value = dictFind<uint64_t>(args_dict, TR_KEY_uploadedBytes); value)
{
stats->uploadedBytes = *value;
}
if (auto const value = dictFind<uint64_t>(args_dict, TR_KEY_downloadedBytes); value)
{
stats->downloadedBytes = *value;
}
if (auto const value = dictFind<uint64_t>(args_dict, TR_KEY_filesAdded); value)
{
stats->filesAdded = *value;
}
if (auto const value = dictFind<uint64_t>(args_dict, TR_KEY_sessionCount); value)
{
stats->sessionCount = *value;
}
if (auto const value = dictFind<uint64_t>(args_dict, TR_KEY_secondsActive); value)
{
stats->secondsActive = *value;
}
stats->ratio = static_cast<float>(tr_getRatio(stats->uploadedBytes, stats->downloadedBytes));
2009-04-09 18:55:47 +00:00
}
void Session::updateStats(tr_variant* dict)
2009-04-09 18:55:47 +00:00
{
if (tr_variant* var = nullptr; tr_variantDictFindDict(dict, TR_KEY_current_stats, &var))
{
updateStats(var, &stats_);
}
2009-04-09 18:55:47 +00:00
if (tr_variant* var = nullptr; tr_variantDictFindDict(dict, TR_KEY_cumulative_stats, &var))
{
updateStats(var, &cumulative_stats_);
}
2009-04-09 18:55:47 +00:00
emit statsUpdated();
2009-04-09 18:55:47 +00:00
}
void Session::updateInfo(tr_variant* args_dict)
2009-04-09 18:55:47 +00:00
{
disconnect(&prefs_, &Prefs::changed, this, &Session::updatePref);
2009-04-09 18:55:47 +00:00
for (int i = Prefs::FIRST_CORE_PREF; i <= Prefs::LAST_CORE_PREF; ++i)
2009-04-09 18:55:47 +00:00
{
tr_variant const* b(tr_variantDictFind(args_dict, prefs_.getKey(i)));
2009-04-09 18:55:47 +00:00
if (b == nullptr)
{
continue;
}
2009-04-09 18:55:47 +00:00
if (i == Prefs::ENCRYPTION)
{
if (auto const str = getValue<QString>(b); str)
{
if (*str == QStringLiteral("required"))
{
prefs_.set(i, 2);
}
else if (*str == QStringLiteral("preferred"))
{
prefs_.set(i, 1);
}
else if (*str == QStringLiteral("tolerated"))
{
prefs_.set(i, 0);
}
}
continue;
}
switch (prefs_.type(i))
2009-04-09 18:55:47 +00:00
{
2023-02-10 17:58:43 +00:00
case QMetaType::Int:
if (auto const value = getValue<int>(b); value)
{
prefs_.set(i, *value);
2009-04-09 18:55:47 +00:00
}
break;
2023-02-10 17:58:43 +00:00
case QMetaType::Double:
if (auto const value = getValue<double>(b); value)
{
prefs_.set(i, *value);
2009-04-09 18:55:47 +00:00
}
break;
2023-02-10 17:58:43 +00:00
case QMetaType::Bool:
if (auto const value = getValue<bool>(b); value)
{
prefs_.set(i, *value);
2009-04-09 18:55:47 +00:00
}
break;
case CustomVariantType::FilterModeType:
case CustomVariantType::SortModeType:
2023-02-10 17:58:43 +00:00
case QMetaType::QString:
if (auto const value = getValue<QString>(b); value)
{
prefs_.set(i, *value);
2009-04-09 18:55:47 +00:00
}
break;
default:
break;
2009-04-09 18:55:47 +00:00
}
}
if (auto const b = dictFind<bool>(args_dict, TR_KEY_seedRatioLimited); b)
2009-04-09 18:55:47 +00:00
{
prefs_.set(Prefs::RATIO_ENABLED, *b);
2009-04-09 18:55:47 +00:00
}
if (auto const x = dictFind<double>(args_dict, TR_KEY_seedRatioLimit); x)
{
prefs_.set(Prefs::RATIO, *x);
}
2009-04-09 18:55:47 +00:00
/* Use the C API to get settings that, for security reasons, aren't supported by RPC */
if (session_ != nullptr)
{
prefs_.set(Prefs::RPC_ENABLED, tr_sessionIsRPCEnabled(session_));
prefs_.set(Prefs::RPC_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled(session_));
prefs_.set(Prefs::RPC_PASSWORD, QString::fromUtf8(tr_sessionGetRPCPassword(session_)));
prefs_.set(Prefs::RPC_PORT, tr_sessionGetRPCPort(session_));
prefs_.set(Prefs::RPC_USERNAME, QString::fromUtf8(tr_sessionGetRPCUsername(session_)));
prefs_.set(Prefs::RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled(session_));
prefs_.set(Prefs::RPC_WHITELIST, QString::fromUtf8(tr_sessionGetRPCWhitelist(session_)));
}
2009-04-09 18:55:47 +00:00
if (auto const size = dictFind<int>(args_dict, TR_KEY_blocklist_size); size && *size != blocklistSize())
{
setBlocklistSize(*size);
}
if (auto const str = dictFind<QString>(args_dict, TR_KEY_version); str)
{
session_version_ = *str;
}
if (auto const str = dictFind<QString>(args_dict, TR_KEY_session_id); str)
{
session_id_ = *str;
is_definitely_local_session_ = tr_session_id::is_local(session_id_.toUtf8().constData());
}
else
{
session_id_.clear();
}
connect(&prefs_, &Prefs::changed, this, &Session::updatePref);
2009-04-09 18:55:47 +00:00
emit sessionUpdated();
2009-04-09 18:55:47 +00:00
}
void Session::setBlocklistSize(int64_t i)
2009-04-09 18:55:47 +00:00
{
blocklist_size_ = i;
2009-04-09 18:55:47 +00:00
emit blocklistUpdated(i);
2009-04-09 18:55:47 +00:00
}
void Session::addTorrent(AddData add_me, tr_variant* args_dict, bool trash_original)
{
assert(tr_variantDictFind(args_dict, TR_KEY_filename) == nullptr);
assert(tr_variantDictFind(args_dict, TR_KEY_metainfo) == nullptr);
if (tr_variantDictFind(args_dict, TR_KEY_paused) == nullptr)
{
dictAdd(args_dict, TR_KEY_paused, !prefs_.getBool(Prefs::START));
}
switch (add_me.type)
{
case AddData::MAGNET:
dictAdd(args_dict, TR_KEY_filename, add_me.magnet);
break;
case AddData::URL:
dictAdd(args_dict, TR_KEY_filename, add_me.url.toString());
break;
case AddData::FILENAME:
[[fallthrough]];
case AddData::METAINFO:
dictAdd(args_dict, TR_KEY_metainfo, add_me.toBase64());
break;
default:
qWarning() << "Unhandled AddData type: " << add_me.type;
break;
}
auto* q = new RpcQueue{};
q->add(
[this, args_dict]() { return exec("torrent-add", args_dict); },
[add_me](RpcResponse const& r)
{
auto* d = new QMessageBox{ QMessageBox::Warning,
tr("Error Adding Torrent"),
QStringLiteral("<p><b>%1</b></p><p>%2</p>").arg(r.result).arg(add_me.readableName()),
QMessageBox::Close,
QApplication::activeWindow() };
QObject::connect(d, &QMessageBox::rejected, d, &QMessageBox::deleteLater);
d->show();
});
q->add(
[this, add_me, trash_original](RpcResponse const& r)
{
bool session_has_torrent = false;
if (tr_variant* dup = nullptr; tr_variantDictFindDict(r.args.get(), TR_KEY_torrent_added, &dup))
{
session_has_torrent = true;
}
else if (tr_variantDictFindDict(r.args.get(), TR_KEY_torrent_duplicate, &dup))
{
session_has_torrent = true;
auto const hash = dictFind<QString>(dup, TR_KEY_hashString);
if (hash)
{
duplicates_.try_emplace(add_me.readableShortName(), *hash);
duplicates_timer_.start(1000);
}
}
if (auto const& filename = add_me.filename;
session_has_torrent && !filename.isEmpty() && add_me.type == AddData::FILENAME)
{
auto file = QFile{ filename };
if (trash_original)
{
file.setPermissions(QFile::ReadOwner | QFile::WriteOwner);
file.remove();
}
else
{
file.rename(QStringLiteral("%1.added").arg(filename));
}
}
});
q->run();
}
void Session::onDuplicatesTimer()
{
decltype(duplicates_) duplicates;
duplicates.swap(duplicates_);
QStringList lines;
2022-01-24 00:53:35 +00:00
for (auto [dupe, original] : duplicates)
{
2022-01-24 00:53:35 +00:00
lines.push_back(tr("%1 (copy of %2)").arg(dupe).arg(original.left(7)));
}
if (!lines.empty())
{
lines.sort(Qt::CaseInsensitive);
auto const title = tr("Duplicate Torrent(s)", "", lines.size());
auto const detail = lines.join(QStringLiteral("\n"));
auto const detail_text = tr("Unable to add %n duplicate torrent(s)", "", lines.size());
auto const use_detail = lines.size() > 1;
auto const text = use_detail ? detail_text : detail;
auto* d = new QMessageBox{ QMessageBox::Warning, title, text, QMessageBox::Close, QApplication::activeWindow() };
if (use_detail)
{
d->setDetailedText(detail);
}
QObject::connect(d, &QMessageBox::rejected, d, &QMessageBox::deleteLater);
d->show();
}
}
void Session::addTorrent(AddData add_me)
{
tr_variant args;
tr_variantInitDict(&args, 3);
addTorrent(std::move(add_me), &args, prefs_.getBool(Prefs::TRASH_ORIGINAL));
}
void Session::addNewlyCreatedTorrent(QString const& filename, QString const& local_path)
2009-04-09 18:55:47 +00:00
{
QByteArray const b64 = AddData(filename).toBase64();
tr_variant args;
tr_variantInitDict(&args, 3);
dictAdd(&args, TR_KEY_download_dir, local_path);
dictAdd(&args, TR_KEY_paused, !prefs_.getBool(Prefs::START));
dictAdd(&args, TR_KEY_metainfo, b64);
exec("torrent-add", &args);
2009-04-09 18:55:47 +00:00
}
void Session::removeTorrents(torrent_ids_t const& ids, bool delete_files)
2009-04-09 18:55:47 +00:00
{
if (!ids.empty())
2009-04-09 18:55:47 +00:00
{
tr_variant args;
tr_variantInitDict(&args, 2);
addOptionalIds(&args, ids);
dictAdd(&args, TR_KEY_delete_local_data, delete_files);
exec("torrent-remove", &args);
2009-04-09 18:55:47 +00:00
}
}
void Session::verifyTorrents(torrent_ids_t const& ids)
2009-04-09 18:55:47 +00:00
{
if (!ids.empty())
2009-04-09 18:55:47 +00:00
{
tr_variant args;
tr_variantInitDict(&args, 1);
addOptionalIds(&args, ids);
exec("torrent-verify", &args);
2009-04-09 18:55:47 +00:00
}
}
void Session::reannounceTorrents(torrent_ids_t const& ids)
2009-04-09 18:55:47 +00:00
{
if (!ids.empty())
2009-04-09 18:55:47 +00:00
{
tr_variant args;
tr_variantInitDict(&args, 1);
addOptionalIds(&args, ids);
exec("torrent-reannounce", &args);
2009-04-09 18:55:47 +00:00
}
}
/***
****
***/
void Session::launchWebInterface() const
2009-04-09 18:55:47 +00:00
{
QUrl url;
if (session_ == nullptr) // remote session
{
url = rpc_.url();
url.setPath(QStringLiteral("/transmission/web/"));
}
else // local session
{
url.setScheme(QStringLiteral("http"));
url.setHost(QStringLiteral("localhost"));
url.setPort(prefs_.getInt(Prefs::RPC_PORT));
2009-04-09 18:55:47 +00:00
}
QDesktopServices::openUrl(url);
2009-04-09 18:55:47 +00:00
}