#include <session.h>

Inheritance diagram for BitTorrent::Session:

Collaboration diagram for BitTorrent::Session:

[legend]

Classes
struct	MoveStorageJob

struct	RemovingTorrentData

Signals
void	allTorrentsFinished ()

void	categoryAdded (const QString &categoryName)

void	categoryRemoved (const QString &categoryName)

void	downloadFromUrlFailed (const QString &url, const QString &reason)

void	downloadFromUrlFinished (const QString &url)

void	fullDiskError (Torrent *torrent, const QString &msg)

void	IPFilterParsed (bool error, int ruleCount)

void	loadTorrentFailed (const QString &error)

void	metadataDownloaded (const TorrentInfo &info)

void	recursiveTorrentDownloadPossible (Torrent *torrent)

void	speedLimitModeChanged (bool alternative)

void	statsUpdated ()

void	subcategoriesSupportChanged ()

void	tagAdded (const QString &tag)

void	tagRemoved (const QString &tag)

void	torrentAboutToBeRemoved (Torrent *torrent)

void	torrentAdded (Torrent *torrent)

void	torrentCategoryChanged (Torrent *torrent, const QString &oldCategory)

void	torrentFinished (Torrent *torrent)

void	torrentFinishedChecking (Torrent *torrent)

void	torrentLoaded (Torrent *torrent)

void	torrentMetadataReceived (Torrent *torrent)

void	torrentPaused (Torrent *torrent)

void	torrentResumed (Torrent *torrent)

void	torrentSavePathChanged (Torrent *torrent)

void	torrentSavingModeChanged (Torrent *torrent)

void	torrentsUpdated (const QVector< Torrent * > &torrents)

void	torrentTagAdded (Torrent *torrent, const QString &tag)

void	torrentTagRemoved (Torrent *torrent, const QString &tag)

void	trackerError (Torrent *torrent, const QString &tracker)

void	trackerlessStateChanged (Torrent *torrent, bool trackerless)

void	trackersAdded (Torrent *torrent, const QVector< TrackerEntry > &trackers)

void	trackersChanged (Torrent *torrent)

void	trackersRemoved (Torrent *torrent, const QVector< TrackerEntry > &trackers)

void	trackerSuccess (Torrent *torrent, const QString &tracker)

void	trackerWarning (Torrent *torrent, const QString &tracker)

Public Member Functions
QString	savePath () const

void	setSavePath (const QString &path)

QString	downloadPath () const

void	setDownloadPath (const QString &path)

bool	isDownloadPathEnabled () const

void	setDownloadPathEnabled (bool enabled)

QStringList	categories () const

CategoryOptions	categoryOptions (const QString &categoryName) const

QString	categorySavePath (const QString &categoryName) const

QString	categoryDownloadPath (const QString &categoryName) const

bool	addCategory (const QString &name, const CategoryOptions &options={})

bool	editCategory (const QString &name, const CategoryOptions &options)

bool	removeCategory (const QString &name)

bool	isSubcategoriesEnabled () const

void	setSubcategoriesEnabled (bool value)

QSet< QString >	tags () const

bool	hasTag (const QString &tag) const

bool	addTag (const QString &tag)

bool	removeTag (const QString &tag)

bool	isAutoTMMDisabledByDefault () const

void	setAutoTMMDisabledByDefault (bool value)

bool	isDisableAutoTMMWhenCategoryChanged () const

void	setDisableAutoTMMWhenCategoryChanged (bool value)

bool	isDisableAutoTMMWhenDefaultSavePathChanged () const

void	setDisableAutoTMMWhenDefaultSavePathChanged (bool value)

bool	isDisableAutoTMMWhenCategorySavePathChanged () const

void	setDisableAutoTMMWhenCategorySavePathChanged (bool value)

qreal	globalMaxRatio () const

void	setGlobalMaxRatio (qreal ratio)

int	globalMaxSeedingMinutes () const

void	setGlobalMaxSeedingMinutes (int minutes)

bool	isDHTEnabled () const

void	setDHTEnabled (bool enabled)

bool	isLSDEnabled () const

void	setLSDEnabled (bool enabled)

bool	isPeXEnabled () const

void	setPeXEnabled (bool enabled)

bool	isAddTorrentPaused () const

void	setAddTorrentPaused (bool value)

TorrentContentLayout	torrentContentLayout () const

void	setTorrentContentLayout (TorrentContentLayout value)

bool	isTrackerEnabled () const

void	setTrackerEnabled (bool enabled)

bool	isAppendExtensionEnabled () const

void	setAppendExtensionEnabled (bool enabled)

int	refreshInterval () const

void	setRefreshInterval (int value)

bool	isPreallocationEnabled () const

void	setPreallocationEnabled (bool enabled)

QString	torrentExportDirectory () const

void	setTorrentExportDirectory (QString path)

QString	finishedTorrentExportDirectory () const

void	setFinishedTorrentExportDirectory (QString path)

int	globalDownloadSpeedLimit () const

void	setGlobalDownloadSpeedLimit (int limit)

int	globalUploadSpeedLimit () const

void	setGlobalUploadSpeedLimit (int limit)

int	altGlobalDownloadSpeedLimit () const

void	setAltGlobalDownloadSpeedLimit (int limit)

int	altGlobalUploadSpeedLimit () const

void	setAltGlobalUploadSpeedLimit (int limit)

int	downloadSpeedLimit () const

void	setDownloadSpeedLimit (int limit)

int	uploadSpeedLimit () const

void	setUploadSpeedLimit (int limit)

bool	isAltGlobalSpeedLimitEnabled () const

void	setAltGlobalSpeedLimitEnabled (bool enabled)

bool	isBandwidthSchedulerEnabled () const

void	setBandwidthSchedulerEnabled (bool enabled)

int	saveResumeDataInterval () const

void	setSaveResumeDataInterval (int value)

int	port () const

void	setPort (int port)

QString	networkInterface () const

void	setNetworkInterface (const QString &iface)

QString	networkInterfaceName () const

void	setNetworkInterfaceName (const QString &name)

QString	networkInterfaceAddress () const

void	setNetworkInterfaceAddress (const QString &address)

int	encryption () const

void	setEncryption (int state)

bool	isProxyPeerConnectionsEnabled () const

void	setProxyPeerConnectionsEnabled (bool enabled)

ChokingAlgorithm	chokingAlgorithm () const

void	setChokingAlgorithm (ChokingAlgorithm mode)

SeedChokingAlgorithm	seedChokingAlgorithm () const

void	setSeedChokingAlgorithm (SeedChokingAlgorithm mode)

bool	isAddTrackersEnabled () const

void	setAddTrackersEnabled (bool enabled)

QString	additionalTrackers () const

void	setAdditionalTrackers (const QString &trackers)

bool	isIPFilteringEnabled () const

void	setIPFilteringEnabled (bool enabled)

QString	IPFilterFile () const

void	setIPFilterFile (QString path)

bool	announceToAllTrackers () const

void	setAnnounceToAllTrackers (bool val)

bool	announceToAllTiers () const

void	setAnnounceToAllTiers (bool val)

int	peerTurnover () const

void	setPeerTurnover (int num)

int	peerTurnoverCutoff () const

void	setPeerTurnoverCutoff (int num)

int	peerTurnoverInterval () const

void	setPeerTurnoverInterval (int num)

int	asyncIOThreads () const

void	setAsyncIOThreads (int num)

int	hashingThreads () const

void	setHashingThreads (int num)

int	filePoolSize () const

void	setFilePoolSize (int size)

int	checkingMemUsage () const

void	setCheckingMemUsage (int size)

int	diskCacheSize () const

void	setDiskCacheSize (int size)

int	diskCacheTTL () const

void	setDiskCacheTTL (int ttl)

bool	useOSCache () const

void	setUseOSCache (bool use)

bool	isCoalesceReadWriteEnabled () const

void	setCoalesceReadWriteEnabled (bool enabled)

bool	usePieceExtentAffinity () const

void	setPieceExtentAffinity (bool enabled)

bool	isSuggestModeEnabled () const

void	setSuggestMode (bool mode)

int	sendBufferWatermark () const

void	setSendBufferWatermark (int value)

int	sendBufferLowWatermark () const

void	setSendBufferLowWatermark (int value)

int	sendBufferWatermarkFactor () const

void	setSendBufferWatermarkFactor (int value)

int	connectionSpeed () const

void	setConnectionSpeed (int value)

int	socketBacklogSize () const

void	setSocketBacklogSize (int value)

bool	isAnonymousModeEnabled () const

void	setAnonymousModeEnabled (bool enabled)

bool	isQueueingSystemEnabled () const

void	setQueueingSystemEnabled (bool enabled)

bool	ignoreSlowTorrentsForQueueing () const

void	setIgnoreSlowTorrentsForQueueing (bool ignore)

int	downloadRateForSlowTorrents () const

void	setDownloadRateForSlowTorrents (int rateInKibiBytes)

int	uploadRateForSlowTorrents () const

void	setUploadRateForSlowTorrents (int rateInKibiBytes)

int	slowTorrentsInactivityTimer () const

void	setSlowTorrentsInactivityTimer (int timeInSeconds)

int	outgoingPortsMin () const

void	setOutgoingPortsMin (int min)

int	outgoingPortsMax () const

void	setOutgoingPortsMax (int max)

int	UPnPLeaseDuration () const

void	setUPnPLeaseDuration (int duration)

int	peerToS () const

void	setPeerToS (int value)

bool	ignoreLimitsOnLAN () const

void	setIgnoreLimitsOnLAN (bool ignore)

bool	includeOverheadInLimits () const

void	setIncludeOverheadInLimits (bool include)

QString	announceIP () const

void	setAnnounceIP (const QString &ip)

int	maxConcurrentHTTPAnnounces () const

void	setMaxConcurrentHTTPAnnounces (int value)

bool	isReannounceWhenAddressChangedEnabled () const

void	setReannounceWhenAddressChangedEnabled (bool enabled)

void	reannounceToAllTrackers () const

int	stopTrackerTimeout () const

void	setStopTrackerTimeout (int value)

int	maxConnections () const

void	setMaxConnections (int max)

int	maxConnectionsPerTorrent () const

void	setMaxConnectionsPerTorrent (int max)

int	maxUploads () const

void	setMaxUploads (int max)

int	maxUploadsPerTorrent () const

void	setMaxUploadsPerTorrent (int max)

int	maxActiveDownloads () const

void	setMaxActiveDownloads (int max)

int	maxActiveUploads () const

void	setMaxActiveUploads (int max)

int	maxActiveTorrents () const

void	setMaxActiveTorrents (int max)

BTProtocol	btProtocol () const

void	setBTProtocol (BTProtocol protocol)

bool	isUTPRateLimited () const

void	setUTPRateLimited (bool limited)

MixedModeAlgorithm	utpMixedMode () const

void	setUtpMixedMode (MixedModeAlgorithm mode)

bool	isIDNSupportEnabled () const

void	setIDNSupportEnabled (bool enabled)

bool	multiConnectionsPerIpEnabled () const

void	setMultiConnectionsPerIpEnabled (bool enabled)

bool	validateHTTPSTrackerCertificate () const

void	setValidateHTTPSTrackerCertificate (bool enabled)

bool	isSSRFMitigationEnabled () const

void	setSSRFMitigationEnabled (bool enabled)

bool	blockPeersOnPrivilegedPorts () const

void	setBlockPeersOnPrivilegedPorts (bool enabled)

bool	isTrackerFilteringEnabled () const

void	setTrackerFilteringEnabled (bool enabled)

QStringList	bannedIPs () const

void	setBannedIPs (const QStringList &newList)

ResumeDataStorageType	resumeDataStorageType () const

void	setResumeDataStorageType (ResumeDataStorageType type)

void	startUpTorrents ()

Torrent *	findTorrent (const TorrentID &id) const

QVector< Torrent * >	torrents () const

bool	hasActiveTorrents () const

bool	hasUnfinishedTorrents () const

bool	hasRunningSeed () const

const SessionStatus &	status () const

const CacheStatus &	cacheStatus () const

quint64	getAlltimeDL () const

quint64	getAlltimeUL () const

bool	isListening () const

MaxRatioAction	maxRatioAction () const

void	setMaxRatioAction (MaxRatioAction act)

void	banIP (const QString &ip)

bool	isKnownTorrent (const TorrentID &id) const

bool	addTorrent (const QString &source, const AddTorrentParams &params=AddTorrentParams())

bool	addTorrent (const MagnetUri &magnetUri, const AddTorrentParams &params=AddTorrentParams())

bool	addTorrent (const TorrentInfo &torrentInfo, const AddTorrentParams &params=AddTorrentParams())

bool	deleteTorrent (const TorrentID &id, DeleteOption deleteOption=DeleteTorrent)

bool	downloadMetadata (const MagnetUri &magnetUri)

bool	cancelDownloadMetadata (const TorrentID &id)

void	recursiveTorrentDownload (const TorrentID &id)

void	increaseTorrentsQueuePos (const QVector< TorrentID > &ids)

void	decreaseTorrentsQueuePos (const QVector< TorrentID > &ids)

void	topTorrentsQueuePos (const QVector< TorrentID > &ids)

void	bottomTorrentsQueuePos (const QVector< TorrentID > &ids)

void	handleTorrentNeedSaveResumeData (const TorrentImpl *torrent)

void	handleTorrentSaveResumeDataRequested (const TorrentImpl *torrent)

void	handleTorrentShareLimitChanged (TorrentImpl *const torrent)

void	handleTorrentNameChanged (TorrentImpl *const torrent)

void	handleTorrentSavePathChanged (TorrentImpl *const torrent)

void	handleTorrentCategoryChanged (TorrentImpl *const torrent, const QString &oldCategory)

void	handleTorrentTagAdded (TorrentImpl *const torrent, const QString &tag)

void	handleTorrentTagRemoved (TorrentImpl *const torrent, const QString &tag)

void	handleTorrentSavingModeChanged (TorrentImpl *const torrent)

void	handleTorrentMetadataReceived (TorrentImpl *const torrent)

void	handleTorrentPaused (TorrentImpl *const torrent)

void	handleTorrentResumed (TorrentImpl *const torrent)

void	handleTorrentChecked (TorrentImpl *const torrent)

void	handleTorrentFinished (TorrentImpl *const torrent)

void	handleTorrentTrackersAdded (TorrentImpl *const torrent, const QVector< TrackerEntry > &newTrackers)

void	handleTorrentTrackersRemoved (TorrentImpl *const torrent, const QVector< TrackerEntry > &deletedTrackers)

void	handleTorrentTrackersChanged (TorrentImpl *const torrent)

void	handleTorrentUrlSeedsAdded (TorrentImpl *const torrent, const QVector< QUrl > &newUrlSeeds)

void	handleTorrentUrlSeedsRemoved (TorrentImpl *const torrent, const QVector< QUrl > &urlSeeds)

void	handleTorrentResumeDataReady (TorrentImpl *const torrent, const LoadTorrentParams &data)

void	handleTorrentTrackerReply (TorrentImpl *const torrent, const QString &trackerUrl)

void	handleTorrentTrackerWarning (TorrentImpl *const torrent, const QString &trackerUrl)

void	handleTorrentTrackerError (TorrentImpl *const torrent, const QString &trackerUrl)

bool	addMoveTorrentStorageJob (TorrentImpl *torrent, const QString &newPath, MoveStorageMode mode)

void	findIncompleteFiles (const TorrentInfo &torrentInfo, const QString &savePath, const QString &downloadPath, const QStringList &filePaths={}) const

Static Public Member Functions
static void	initInstance ()

static void	freeInstance ()

static Session *	instance ()

static bool	isValidCategoryName (const QString &name)

static QStringList	expandCategory (const QString &category)

static bool	isValidTag (const QString &tag)

Private Slots
void	configureDeferred ()

void	readAlerts ()

void	enqueueRefresh ()

void	processShareLimits ()

void	generateResumeData ()

void	handleIPFilterParsed (int ruleCount)

void	handleIPFilterError ()

void	handleDownloadFinished (const Net::DownloadResult &result)

void	fileSearchFinished (const TorrentID &id, const QString &savePath, const QStringList &fileNames)

Private Member Functions
	Session (QObject *parent=nullptr)

	~Session ()

bool	hasPerTorrentRatioLimit () const

bool	hasPerTorrentSeedingTimeLimit () const

Q_INVOKABLE void	configure ()

void	configureComponents ()

void	initializeNativeSession ()

void	loadLTSettings (lt::settings_pack &settingsPack)

void	configureNetworkInterfaces (lt::settings_pack &settingsPack)

void	configurePeerClasses ()

void	adjustLimits (lt::settings_pack &settingsPack) const

void	applyBandwidthLimits (lt::settings_pack &settingsPack) const

void	initMetrics ()

void	adjustLimits ()

void	applyBandwidthLimits ()

void	processBannedIPs (lt::ip_filter &filter)

QStringList	getListeningIPs () const

void	configureListeningInterface ()

void	enableTracker (bool enable)

void	enableBandwidthScheduler ()

void	populateAdditionalTrackers ()

void	enableIPFilter ()

void	disableIPFilter ()

bool	loadTorrent (LoadTorrentParams params)

LoadTorrentParams	initLoadTorrentParams (const AddTorrentParams &addTorrentParams)

bool	addTorrent_impl (const std::variant< MagnetUri, TorrentInfo > &source, const AddTorrentParams &addTorrentParams)

void	updateSeedingLimitTimer ()

void	exportTorrentFile (const TorrentInfo &torrentInfo, const QString &folderPath, const QString &baseName)

void	handleAlert (const lt::alert *a)

void	dispatchTorrentAlert (const lt::alert *a)

void	handleAddTorrentAlert (const lt::add_torrent_alert *p)

void	handleStateUpdateAlert (const lt::state_update_alert *p)

void	handleMetadataReceivedAlert (const lt::metadata_received_alert *p)

void	handleFileErrorAlert (const lt::file_error_alert *p)

void	handleTorrentRemovedAlert (const lt::torrent_removed_alert *p)

void	handleTorrentDeletedAlert (const lt::torrent_deleted_alert *p)

void	handleTorrentDeleteFailedAlert (const lt::torrent_delete_failed_alert *p)

void	handlePortmapWarningAlert (const lt::portmap_error_alert *p)

void	handlePortmapAlert (const lt::portmap_alert *p)

void	handlePeerBlockedAlert (const lt::peer_blocked_alert *p)

void	handlePeerBanAlert (const lt::peer_ban_alert *p)

void	handleUrlSeedAlert (const lt::url_seed_alert *p)

void	handleListenSucceededAlert (const lt::listen_succeeded_alert *p)

void	handleListenFailedAlert (const lt::listen_failed_alert *p)

void	handleExternalIPAlert (const lt::external_ip_alert *p)

void	handleSessionStatsAlert (const lt::session_stats_alert *p)

void	handleAlertsDroppedAlert (const lt::alerts_dropped_alert *p) const

void	handleStorageMovedAlert (const lt::storage_moved_alert *p)

void	handleStorageMovedFailedAlert (const lt::storage_moved_failed_alert *p)

void	handleSocks5Alert (const lt::socks5_alert *p) const

void	createTorrent (const lt::torrent_handle &nativeHandle)

void	saveResumeData ()

void	saveTorrentsQueue () const

void	removeTorrentsQueue () const

std::vector< lt::alert * >	getPendingAlerts (lt::time_duration time=lt::time_duration::zero()) const

void	moveTorrentStorage (const MoveStorageJob &job) const

void	handleMoveTorrentStorageJobFinished ()

void	loadCategories ()

void	storeCategories () const

void	upgradeCategories ()

Private Attributes
lt::session *	m_nativeSession = nullptr

bool	m_deferredConfigureScheduled = false

bool	m_IPFilteringConfigured = false

bool	m_listenInterfaceConfigured = false

CachedSettingValue< bool >	m_isDHTEnabled

CachedSettingValue< bool >	m_isLSDEnabled

CachedSettingValue< bool >	m_isPeXEnabled

CachedSettingValue< bool >	m_isIPFilteringEnabled

CachedSettingValue< bool >	m_isTrackerFilteringEnabled

CachedSettingValue< QString >	m_IPFilterFile

CachedSettingValue< bool >	m_announceToAllTrackers

CachedSettingValue< bool >	m_announceToAllTiers

CachedSettingValue< int >	m_asyncIOThreads

CachedSettingValue< int >	m_hashingThreads

CachedSettingValue< int >	m_filePoolSize

CachedSettingValue< int >	m_checkingMemUsage

CachedSettingValue< int >	m_diskCacheSize

CachedSettingValue< int >	m_diskCacheTTL

CachedSettingValue< bool >	m_useOSCache

CachedSettingValue< bool >	m_coalesceReadWriteEnabled

CachedSettingValue< bool >	m_usePieceExtentAffinity

CachedSettingValue< bool >	m_isSuggestMode

CachedSettingValue< int >	m_sendBufferWatermark

CachedSettingValue< int >	m_sendBufferLowWatermark

CachedSettingValue< int >	m_sendBufferWatermarkFactor

CachedSettingValue< int >	m_connectionSpeed

CachedSettingValue< int >	m_socketBacklogSize

CachedSettingValue< bool >	m_isAnonymousModeEnabled

CachedSettingValue< bool >	m_isQueueingEnabled

CachedSettingValue< int >	m_maxActiveDownloads

CachedSettingValue< int >	m_maxActiveUploads

CachedSettingValue< int >	m_maxActiveTorrents

CachedSettingValue< bool >	m_ignoreSlowTorrentsForQueueing

CachedSettingValue< int >	m_downloadRateForSlowTorrents

CachedSettingValue< int >	m_uploadRateForSlowTorrents

CachedSettingValue< int >	m_slowTorrentsInactivityTimer

CachedSettingValue< int >	m_outgoingPortsMin

CachedSettingValue< int >	m_outgoingPortsMax

CachedSettingValue< int >	m_UPnPLeaseDuration

CachedSettingValue< int >	m_peerToS

CachedSettingValue< bool >	m_ignoreLimitsOnLAN

CachedSettingValue< bool >	m_includeOverheadInLimits

CachedSettingValue< QString >	m_announceIP

CachedSettingValue< int >	m_maxConcurrentHTTPAnnounces

CachedSettingValue< bool >	m_isReannounceWhenAddressChangedEnabled

CachedSettingValue< int >	m_stopTrackerTimeout

CachedSettingValue< int >	m_maxConnections

CachedSettingValue< int >	m_maxUploads

CachedSettingValue< int >	m_maxConnectionsPerTorrent

CachedSettingValue< int >	m_maxUploadsPerTorrent

CachedSettingValue< BTProtocol >	m_btProtocol

CachedSettingValue< bool >	m_isUTPRateLimited

CachedSettingValue< MixedModeAlgorithm >	m_utpMixedMode

CachedSettingValue< bool >	m_IDNSupportEnabled

CachedSettingValue< bool >	m_multiConnectionsPerIpEnabled

CachedSettingValue< bool >	m_validateHTTPSTrackerCertificate

CachedSettingValue< bool >	m_SSRFMitigationEnabled

CachedSettingValue< bool >	m_blockPeersOnPrivilegedPorts

CachedSettingValue< bool >	m_isAddTrackersEnabled

CachedSettingValue< QString >	m_additionalTrackers

CachedSettingValue< qreal >	m_globalMaxRatio

CachedSettingValue< int >	m_globalMaxSeedingMinutes

CachedSettingValue< bool >	m_isAddTorrentPaused

CachedSettingValue< TorrentContentLayout >	m_torrentContentLayout

CachedSettingValue< bool >	m_isAppendExtensionEnabled

CachedSettingValue< int >	m_refreshInterval

CachedSettingValue< bool >	m_isPreallocationEnabled

CachedSettingValue< QString >	m_torrentExportDirectory

CachedSettingValue< QString >	m_finishedTorrentExportDirectory

CachedSettingValue< int >	m_globalDownloadSpeedLimit

CachedSettingValue< int >	m_globalUploadSpeedLimit

CachedSettingValue< int >	m_altGlobalDownloadSpeedLimit

CachedSettingValue< int >	m_altGlobalUploadSpeedLimit

CachedSettingValue< bool >	m_isAltGlobalSpeedLimitEnabled

CachedSettingValue< bool >	m_isBandwidthSchedulerEnabled

CachedSettingValue< int >	m_saveResumeDataInterval

CachedSettingValue< int >	m_port

CachedSettingValue< QString >	m_networkInterface

CachedSettingValue< QString >	m_networkInterfaceName

CachedSettingValue< QString >	m_networkInterfaceAddress

CachedSettingValue< int >	m_encryption

CachedSettingValue< bool >	m_isProxyPeerConnectionsEnabled

CachedSettingValue< ChokingAlgorithm >	m_chokingAlgorithm

CachedSettingValue< SeedChokingAlgorithm >	m_seedChokingAlgorithm

CachedSettingValue< QStringList >	m_storedTags

CachedSettingValue< int >	m_maxRatioAction

CachedSettingValue< QString >	m_savePath

CachedSettingValue< QString >	m_downloadPath

CachedSettingValue< bool >	m_isSubcategoriesEnabled

CachedSettingValue< bool >	m_isDownloadPathEnabled

CachedSettingValue< bool >	m_isAutoTMMDisabledByDefault

CachedSettingValue< bool >	m_isDisableAutoTMMWhenCategoryChanged

CachedSettingValue< bool >	m_isDisableAutoTMMWhenDefaultSavePathChanged

CachedSettingValue< bool >	m_isDisableAutoTMMWhenCategorySavePathChanged

CachedSettingValue< bool >	m_isTrackerEnabled

CachedSettingValue< int >	m_peerTurnover

CachedSettingValue< int >	m_peerTurnoverCutoff

CachedSettingValue< int >	m_peerTurnoverInterval

CachedSettingValue< QStringList >	m_bannedIPs

CachedSettingValue< ResumeDataStorageType >	m_resumeDataStorageType

const bool	m_wasPexEnabled = m_isPeXEnabled

int	m_numResumeData = 0

int	m_extraLimit = 0

QVector< TrackerEntry >	m_additionalTrackerList

bool	m_refreshEnqueued = false

QTimer *	m_seedingLimitTimer = nullptr

QTimer *	m_resumeDataTimer = nullptr

Statistics *	m_statistics = nullptr

QPointer< FilterParserThread >	m_filterParser

QPointer< BandwidthScheduler >	m_bwScheduler

QPointer< Tracker >	m_tracker

QThread *	m_ioThread = nullptr

ResumeDataStorage *	m_resumeDataStorage = nullptr

FileSearcher *	m_fileSearcher = nullptr

QSet< TorrentID >	m_downloadedMetadata

QHash< TorrentID, TorrentImpl * >	m_torrents

QHash< TorrentID, LoadTorrentParams >	m_loadingTorrents

QHash< QString, AddTorrentParams >	m_downloadedTorrents

QHash< TorrentID, RemovingTorrentData >	m_removingTorrents

QSet< TorrentID >	m_needSaveResumeDataTorrents

QMap< QString, CategoryOptions >	m_categories

QSet< QString >	m_tags

QSet< TorrentID >	m_recentErroredTorrents

QTimer *	m_recentErroredTorrentsTimer = nullptr

SessionMetricIndices	m_metricIndices

lt::time_point	m_statsLastTimestamp = lt::clock_type::now()

SessionStatus	m_status

CacheStatus	m_cacheStatus

QList< MoveStorageJob >	m_moveStorageQueue

QString	m_lastExternalIP

bool	m_needUpgradeDownloadPath = false

Static Private Attributes
static Session *	m_instance = nullptr

Detailed Description

Definition at line 205 of file session.h.

Constructor & Destructor Documentation

◆ Session()

Session::Session ( QObject * parent = nullptr )

explicitprivate

Definition at line 305 of file session.cpp.

     : QObject(parent)
     , m_isDHTEnabled(BITTORRENT_SESSION_KEY("DHTEnabled"), true)
     , m_isLSDEnabled(BITTORRENT_SESSION_KEY("LSDEnabled"), true)
     , m_isPeXEnabled(BITTORRENT_SESSION_KEY("PeXEnabled"), true)
     , m_isIPFilteringEnabled(BITTORRENT_SESSION_KEY("IPFilteringEnabled"), false)
     , m_isTrackerFilteringEnabled(BITTORRENT_SESSION_KEY("TrackerFilteringEnabled"), false)
     , m_IPFilterFile(BITTORRENT_SESSION_KEY("IPFilter"))
     , m_announceToAllTrackers(BITTORRENT_SESSION_KEY("AnnounceToAllTrackers"), false)
     , m_announceToAllTiers(BITTORRENT_SESSION_KEY("AnnounceToAllTiers"), true)
     , m_asyncIOThreads(BITTORRENT_SESSION_KEY("AsyncIOThreadsCount"), 10)
     , m_hashingThreads(BITTORRENT_SESSION_KEY("HashingThreadsCount"), 2)
     , m_filePoolSize(BITTORRENT_SESSION_KEY("FilePoolSize"), 5000)
     , m_checkingMemUsage(BITTORRENT_SESSION_KEY("CheckingMemUsageSize"), 32)
     , m_diskCacheSize(BITTORRENT_SESSION_KEY("DiskCacheSize"), -1)
     , m_diskCacheTTL(BITTORRENT_SESSION_KEY("DiskCacheTTL"), 60)
     , m_useOSCache(BITTORRENT_SESSION_KEY("UseOSCache"), true)
 #ifdef Q_OS_WIN
     , m_coalesceReadWriteEnabled(BITTORRENT_SESSION_KEY("CoalesceReadWrite"), true)
 #else
     , m_coalesceReadWriteEnabled(BITTORRENT_SESSION_KEY("CoalesceReadWrite"), false)
 #endif
     , m_usePieceExtentAffinity(BITTORRENT_SESSION_KEY("PieceExtentAffinity"), false)
     , m_isSuggestMode(BITTORRENT_SESSION_KEY("SuggestMode"), false)
     , m_sendBufferWatermark(BITTORRENT_SESSION_KEY("SendBufferWatermark"), 500)
     , m_sendBufferLowWatermark(BITTORRENT_SESSION_KEY("SendBufferLowWatermark"), 10)
     , m_sendBufferWatermarkFactor(BITTORRENT_SESSION_KEY("SendBufferWatermarkFactor"), 50)
     , m_connectionSpeed(BITTORRENT_SESSION_KEY("ConnectionSpeed"), 30)
     , m_socketBacklogSize(BITTORRENT_SESSION_KEY("SocketBacklogSize"), 30)
     , m_isAnonymousModeEnabled(BITTORRENT_SESSION_KEY("AnonymousModeEnabled"), false)
     , m_isQueueingEnabled(BITTORRENT_SESSION_KEY("QueueingSystemEnabled"), false)
     , m_maxActiveDownloads(BITTORRENT_SESSION_KEY("MaxActiveDownloads"), 3, lowerLimited(-1))
     , m_maxActiveUploads(BITTORRENT_SESSION_KEY("MaxActiveUploads"), 3, lowerLimited(-1))
     , m_maxActiveTorrents(BITTORRENT_SESSION_KEY("MaxActiveTorrents"), 5, lowerLimited(-1))
     , m_ignoreSlowTorrentsForQueueing(BITTORRENT_SESSION_KEY("IgnoreSlowTorrentsForQueueing"), false)
     , m_downloadRateForSlowTorrents(BITTORRENT_SESSION_KEY("SlowTorrentsDownloadRate"), 2)
     , m_uploadRateForSlowTorrents(BITTORRENT_SESSION_KEY("SlowTorrentsUploadRate"), 2)
     , m_slowTorrentsInactivityTimer(BITTORRENT_SESSION_KEY("SlowTorrentsInactivityTimer"), 60)
     , m_outgoingPortsMin(BITTORRENT_SESSION_KEY("OutgoingPortsMin"), 0)
     , m_outgoingPortsMax(BITTORRENT_SESSION_KEY("OutgoingPortsMax"), 0)
     , m_UPnPLeaseDuration(BITTORRENT_SESSION_KEY("UPnPLeaseDuration"), 0)
     , m_peerToS(BITTORRENT_SESSION_KEY("PeerToS"), 0x20)
     , m_ignoreLimitsOnLAN(BITTORRENT_SESSION_KEY("IgnoreLimitsOnLAN"), false)
     , m_includeOverheadInLimits(BITTORRENT_SESSION_KEY("IncludeOverheadInLimits"), false)
     , m_announceIP(BITTORRENT_SESSION_KEY("AnnounceIP"))
     , m_maxConcurrentHTTPAnnounces(BITTORRENT_SESSION_KEY("MaxConcurrentHTTPAnnounces"), 50)
     , m_isReannounceWhenAddressChangedEnabled(BITTORRENT_SESSION_KEY("ReannounceWhenAddressChanged"), false)
     , m_stopTrackerTimeout(BITTORRENT_SESSION_KEY("StopTrackerTimeout"), 5)
     , m_maxConnections(BITTORRENT_SESSION_KEY("MaxConnections"), 500, lowerLimited(0, -1))
     , m_maxUploads(BITTORRENT_SESSION_KEY("MaxUploads"), 20, lowerLimited(0, -1))
     , m_maxConnectionsPerTorrent(BITTORRENT_SESSION_KEY("MaxConnectionsPerTorrent"), 100, lowerLimited(0, -1))
     , m_maxUploadsPerTorrent(BITTORRENT_SESSION_KEY("MaxUploadsPerTorrent"), 4, lowerLimited(0, -1))
     , m_btProtocol(BITTORRENT_SESSION_KEY("BTProtocol"), BTProtocol::Both
         , clampValue(BTProtocol::Both, BTProtocol::UTP))
     , m_isUTPRateLimited(BITTORRENT_SESSION_KEY("uTPRateLimited"), true)
     , m_utpMixedMode(BITTORRENT_SESSION_KEY("uTPMixedMode"), MixedModeAlgorithm::TCP
         , clampValue(MixedModeAlgorithm::TCP, MixedModeAlgorithm::Proportional))
     , m_IDNSupportEnabled(BITTORRENT_SESSION_KEY("IDNSupportEnabled"), false)
     , m_multiConnectionsPerIpEnabled(BITTORRENT_SESSION_KEY("MultiConnectionsPerIp"), false)
     , m_validateHTTPSTrackerCertificate(BITTORRENT_SESSION_KEY("ValidateHTTPSTrackerCertificate"), true)
     , m_SSRFMitigationEnabled(BITTORRENT_SESSION_KEY("SSRFMitigation"), true)
     , m_blockPeersOnPrivilegedPorts(BITTORRENT_SESSION_KEY("BlockPeersOnPrivilegedPorts"), false)
     , m_isAddTrackersEnabled(BITTORRENT_SESSION_KEY("AddTrackersEnabled"), false)
     , m_additionalTrackers(BITTORRENT_SESSION_KEY("AdditionalTrackers"))
     , m_globalMaxRatio(BITTORRENT_SESSION_KEY("GlobalMaxRatio"), -1, [](qreal r) { return r < 0 ? -1. : r;})
     , m_globalMaxSeedingMinutes(BITTORRENT_SESSION_KEY("GlobalMaxSeedingMinutes"), -1, lowerLimited(-1))
     , m_isAddTorrentPaused(BITTORRENT_SESSION_KEY("AddTorrentPaused"), false)
     , m_torrentContentLayout(BITTORRENT_SESSION_KEY("TorrentContentLayout"), TorrentContentLayout::Original)
     , m_isAppendExtensionEnabled(BITTORRENT_SESSION_KEY("AddExtensionToIncompleteFiles"), false)
     , m_refreshInterval(BITTORRENT_SESSION_KEY("RefreshInterval"), 1500)
     , m_isPreallocationEnabled(BITTORRENT_SESSION_KEY("Preallocation"), false)
     , m_torrentExportDirectory(BITTORRENT_SESSION_KEY("TorrentExportDirectory"))
     , m_finishedTorrentExportDirectory(BITTORRENT_SESSION_KEY("FinishedTorrentExportDirectory"))
     , m_globalDownloadSpeedLimit(BITTORRENT_SESSION_KEY("GlobalDLSpeedLimit"), 0, lowerLimited(0))
     , m_globalUploadSpeedLimit(BITTORRENT_SESSION_KEY("GlobalUPSpeedLimit"), 0, lowerLimited(0))
     , m_altGlobalDownloadSpeedLimit(BITTORRENT_SESSION_KEY("AlternativeGlobalDLSpeedLimit"), 10, lowerLimited(0))
     , m_altGlobalUploadSpeedLimit(BITTORRENT_SESSION_KEY("AlternativeGlobalUPSpeedLimit"), 10, lowerLimited(0))
     , m_isAltGlobalSpeedLimitEnabled(BITTORRENT_SESSION_KEY("UseAlternativeGlobalSpeedLimit"), false)
     , m_isBandwidthSchedulerEnabled(BITTORRENT_SESSION_KEY("BandwidthSchedulerEnabled"), false)
     , m_saveResumeDataInterval(BITTORRENT_SESSION_KEY("SaveResumeDataInterval"), 60)
     , m_port(BITTORRENT_SESSION_KEY("Port"), -1)
     , m_networkInterface(BITTORRENT_SESSION_KEY("Interface"))
     , m_networkInterfaceName(BITTORRENT_SESSION_KEY("InterfaceName"))
     , m_networkInterfaceAddress(BITTORRENT_SESSION_KEY("InterfaceAddress"))
     , m_encryption(BITTORRENT_SESSION_KEY("Encryption"), 0)
     , m_isProxyPeerConnectionsEnabled(BITTORRENT_SESSION_KEY("ProxyPeerConnections"), false)
     , m_chokingAlgorithm(BITTORRENT_SESSION_KEY("ChokingAlgorithm"), ChokingAlgorithm::FixedSlots
         , clampValue(ChokingAlgorithm::FixedSlots, ChokingAlgorithm::RateBased))
     , m_seedChokingAlgorithm(BITTORRENT_SESSION_KEY("SeedChokingAlgorithm"), SeedChokingAlgorithm::FastestUpload
         , clampValue(SeedChokingAlgorithm::RoundRobin, SeedChokingAlgorithm::AntiLeech))
     , m_storedTags(BITTORRENT_SESSION_KEY("Tags"))
     , m_maxRatioAction(BITTORRENT_SESSION_KEY("MaxRatioAction"), Pause)
     , m_savePath(BITTORRENT_SESSION_KEY("DefaultSavePath"), specialFolderLocation(SpecialFolder::Downloads), Utils::Fs::toUniformPath)
     , m_downloadPath(BITTORRENT_SESSION_KEY("TempPath"), specialFolderLocation(SpecialFolder::Downloads) + QLatin1String("/temp"), Utils::Fs::toUniformPath)
     , m_isSubcategoriesEnabled(BITTORRENT_SESSION_KEY("SubcategoriesEnabled"), false)
     , m_isDownloadPathEnabled(BITTORRENT_SESSION_KEY("TempPathEnabled"), false)
     , m_isAutoTMMDisabledByDefault(BITTORRENT_SESSION_KEY("DisableAutoTMMByDefault"), true)
     , m_isDisableAutoTMMWhenCategoryChanged(BITTORRENT_SESSION_KEY("DisableAutoTMMTriggers/CategoryChanged"), false)
     , m_isDisableAutoTMMWhenDefaultSavePathChanged(BITTORRENT_SESSION_KEY("DisableAutoTMMTriggers/DefaultSavePathChanged"), true)
     , m_isDisableAutoTMMWhenCategorySavePathChanged(BITTORRENT_SESSION_KEY("DisableAutoTMMTriggers/CategorySavePathChanged"), true)
     , m_isTrackerEnabled(BITTORRENT_KEY("TrackerEnabled"), false)
     , m_peerTurnover(BITTORRENT_SESSION_KEY("PeerTurnover"), 4)
     , m_peerTurnoverCutoff(BITTORRENT_SESSION_KEY("PeerTurnoverCutOff"), 90)
     , m_peerTurnoverInterval(BITTORRENT_SESSION_KEY("PeerTurnoverInterval"), 300)
     , m_bannedIPs("State/BannedIPs"
                   , QStringList()
                   , [](const QStringList &value)
                         {
                             QStringList tmp = value;
                             tmp.sort();
                             return tmp;
                         }
                  )
     , m_resumeDataStorageType(BITTORRENT_SESSION_KEY("ResumeDataStorageType"), ResumeDataStorageType::Legacy)
 #if defined(Q_OS_WIN)
     , m_OSMemoryPriority(BITTORRENT_KEY("OSMemoryPriority"), OSMemoryPriority::BelowNormal)
 #endif
     , m_seedingLimitTimer {new QTimer {this}}
     , m_resumeDataTimer {new QTimer {this}}
     , m_statistics {new Statistics {this}}
     , m_ioThread {new QThread {this}}
     , m_recentErroredTorrentsTimer {new QTimer {this}}
 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
     , m_networkManager {new QNetworkConfigurationManager {this}}
 #endif
 {
     if (port() < 0)
         m_port = Utils::Random::rand(1024, 65535);
  
     m_recentErroredTorrentsTimer->setSingleShot(true);
     m_recentErroredTorrentsTimer->setInterval(1000);
     connect(m_recentErroredTorrentsTimer, &QTimer::timeout
         , this, [this]() { m_recentErroredTorrents.clear(); });
  
     m_seedingLimitTimer->setInterval(10000);
     connect(m_seedingLimitTimer, &QTimer::timeout, this, &Session::processShareLimits);
  
     initializeNativeSession();
     configureComponents();
  
     if (isBandwidthSchedulerEnabled())
         enableBandwidthScheduler();
  
     loadCategories();
     if (isSubcategoriesEnabled())
     {
         // if subcategories support changed manually
         m_categories = expandCategories(m_categories);
     }
  
     const QStringList storedTags = m_storedTags.get();
     m_tags = {storedTags.cbegin(), storedTags.cend()};
  
     enqueueRefresh();
     updateSeedingLimitTimer();
     populateAdditionalTrackers();
  
     enableTracker(isTrackerEnabled());
  
     connect(Net::ProxyConfigurationManager::instance()
         , &Net::ProxyConfigurationManager::proxyConfigurationChanged
         , this, &Session::configureDeferred);
  
 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
     // Network configuration monitor
     connect(m_networkManager, &QNetworkConfigurationManager::onlineStateChanged, this, &Session::networkOnlineStateChanged);
     connect(m_networkManager, &QNetworkConfigurationManager::configurationAdded, this, &Session::networkConfigurationChange);
     connect(m_networkManager, &QNetworkConfigurationManager::configurationRemoved, this, &Session::networkConfigurationChange);
     connect(m_networkManager, &QNetworkConfigurationManager::configurationChanged, this, &Session::networkConfigurationChange);
 #endif
  
     m_fileSearcher = new FileSearcher;
     m_fileSearcher->moveToThread(m_ioThread);
     connect(m_ioThread, &QThread::finished, m_fileSearcher, &QObject::deleteLater);
     connect(m_fileSearcher, &FileSearcher::searchFinished, this, &Session::fileSearchFinished);
  
     m_ioThread->start();
  
     // Regular saving of fastresume data
     connect(m_resumeDataTimer, &QTimer::timeout, this, [this]() { generateResumeData(); });
     const int saveInterval = saveResumeDataInterval();
     if (saveInterval > 0)
     {
         m_resumeDataTimer->setInterval(saveInterval * 60 * 1000);
         m_resumeDataTimer->start();
     }
  
     // initialize PortForwarder instance
     new PortForwarderImpl {m_nativeSession};
  
     initMetrics();
 }

Referenced by initInstance().

Here is the caller graph for this function:

◆ ~Session()

Session::~Session ( )

private

Definition at line 965 of file session.cpp.

 {
     // Do some BT related saving
     saveResumeData();
  
     // We must delete FilterParserThread
     // before we delete lt::session
     delete m_filterParser;
  
     // We must delete PortForwarderImpl before
     // we delete lt::session
     delete Net::PortForwarder::instance();
  
     qDebug("Deleting the session");
     delete m_nativeSession;
  
     m_ioThread->quit();
     m_ioThread->wait();
 }

References Net::PortForwarder::instance(), m_filterParser, m_ioThread, m_nativeSession, and saveResumeData().

Here is the call graph for this function:

Member Function Documentation

◆ addCategory()

bool Session::addCategory	(	const QString &	name,
		const CategoryOptions &	options = `{}`
	)

Definition at line 701 of file session.cpp.

 {
     if (name.isEmpty())
         return false;
  
     if (!isValidCategoryName(name) || m_categories.contains(name))
         return false;
  
     if (isSubcategoriesEnabled())
     {
         for (const QString &parent : asConst(expandCategory(name)))
         {
             if ((parent != name) && !m_categories.contains(parent))
             {
                 m_categories[parent] = {};
                 emit categoryAdded(parent);
             }
         }
     }
  
     m_categories[name] = options;
     storeCategories();
     emit categoryAdded(name);
  
     return true;
 }

References asConst(), categoryAdded(), expandCategory(), isSubcategoriesEnabled(), isValidCategoryName(), m_categories, and storeCategories().

Referenced by initLoadTorrentParams().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ additionalTrackers()

QString Session::additionalTrackers ( ) const

Definition at line 2904 of file session.cpp.

 {
     return m_additionalTrackers;
 }

References m_additionalTrackers.

Referenced by populateAdditionalTrackers(), and setAdditionalTrackers().

Here is the caller graph for this function:

◆ addMoveTorrentStorageJob()

bool Session::addMoveTorrentStorageJob	(	TorrentImpl *	torrent,
		const QString &	newPath,
		MoveStorageMode	mode
	)

Definition at line 4027 of file session.cpp.

 {
     Q_ASSERT(torrent);
  
     const lt::torrent_handle torrentHandle = torrent->nativeHandle();
     const QString currentLocation = Utils::Fs::toNativePath(torrent->actualStorageLocation());
  
     if (m_moveStorageQueue.size() > 1)
     {
         const auto iter = std::find_if(m_moveStorageQueue.begin() + 1, m_moveStorageQueue.end()
                                  , [&torrentHandle](const MoveStorageJob &job)
         {
             return job.torrentHandle == torrentHandle;
         });
  
         if (iter != m_moveStorageQueue.end())
         {
             // remove existing inactive job
             m_moveStorageQueue.erase(iter);
             LogMsg(tr("Cancelled moving \"%1\" from \"%2\" to \"%3\".").arg(torrent->name(), currentLocation, iter->path));
         }
     }
  
     if (!m_moveStorageQueue.isEmpty() && (m_moveStorageQueue.first().torrentHandle == torrentHandle))
     {
         // if there is active job for this torrent prevent creating meaningless
         // job that will move torrent to the same location as current one
         if (QDir {m_moveStorageQueue.first().path} == QDir {newPath})
         {
             LogMsg(tr("Couldn't enqueue move of \"%1\" to \"%2\". Torrent is currently moving to the same destination location.")
                    .arg(torrent->name(), newPath));
             return false;
         }
     }
     else
     {
         if (QDir {currentLocation} == QDir {newPath})
         {
             LogMsg(tr("Couldn't enqueue move of \"%1\" from \"%2\" to \"%3\". Both paths point to the same location.")
                    .arg(torrent->name(), currentLocation, newPath));
             return false;
         }
     }
  
     const MoveStorageJob moveStorageJob {torrentHandle, newPath, mode};
     m_moveStorageQueue << moveStorageJob;
     LogMsg(tr("Enqueued to move \"%1\" from \"%2\" to \"%3\".").arg(torrent->name(), currentLocation, newPath));
  
     if (m_moveStorageQueue.size() == 1)
         moveTorrentStorage(moveStorageJob);
  
     return true;
 }

References BitTorrent::TorrentImpl::actualStorageLocation(), LogMsg(), m_moveStorageQueue, moveTorrentStorage(), BitTorrent::TorrentImpl::name(), BitTorrent::TorrentImpl::nativeHandle(), and Utils::Fs::toNativePath().

Referenced by BitTorrent::TorrentImpl::moveStorage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addTag()

bool Session::addTag ( const QString & tag )

Definition at line 839 of file session.cpp.

 {
     if (!isValidTag(tag) || hasTag(tag))
         return false;
  
     m_tags.insert(tag);
     m_storedTags = m_tags.values();
     emit tagAdded(tag);
     return true;
 }

References hasTag(), isValidTag(), m_storedTags, m_tags, and tagAdded().

Referenced by TagFilterWidget::addTag(), BitTorrent::TorrentImpl::addTag(), TorrentsController::createTagsAction(), and initLoadTorrentParams().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addTorrent() [1/3]

bool Session::addTorrent	(	const MagnetUri &	magnetUri,
		const AddTorrentParams &	params = `AddTorrentParams()`
	)

Definition at line 2037 of file session.cpp.

 {
     if (!magnetUri.isValid()) return false;
  
     return addTorrent_impl(magnetUri, params);
 }

References addTorrent_impl(), and BitTorrent::MagnetUri::isValid().

Here is the call graph for this function:

◆ addTorrent() [2/3]

bool Session::addTorrent	(	const QString &	source,
		const AddTorrentParams &	params = `AddTorrentParams()`
	)

Definition at line 2007 of file session.cpp.

 {
     // `source`: .torrent file path/url or magnet uri
  
     if (Net::DownloadManager::hasSupportedScheme(source))
     {
         LogMsg(tr("Downloading '%1', please wait...", "e.g: Downloading 'xxx.torrent', please wait...").arg(source));
         // Launch downloader
         Net::DownloadManager::instance()->download(Net::DownloadRequest(source).limit(MAX_TORRENT_SIZE)
                                                    , this, &Session::handleDownloadFinished);
         m_downloadedTorrents[source] = params;
         return true;
     }
  
     const MagnetUri magnetUri {source};
     if (magnetUri.isValid())
         return addTorrent(magnetUri, params);
  
     TorrentFileGuard guard {source};
     const nonstd::expected<TorrentInfo, QString> loadResult = TorrentInfo::loadFromFile(source);
     if (!loadResult)
     {
        LogMsg(tr("Couldn't load torrent: %1").arg(loadResult.error()), Log::WARNING);
        return false;
     }
  
     guard.markAsAddedToSession();
     return addTorrent(loadResult.value(), params);
 }

References Net::DownloadManager::download(), handleDownloadFinished(), Net::DownloadManager::hasSupportedScheme(), Net::DownloadManager::instance(), BitTorrent::TorrentInfo::loadFromFile(), LogMsg(), m_downloadedTorrents, MAX_TORRENT_SIZE, anonymous_namespace{misc.cpp}::source, and Log::WARNING.

Referenced by AddNewTorrentDialog::accept(), TorrentsController::addAction(), SearchJobWidget::addTorrentToSession(), MainWindow::downloadFromURLList(), RSSWidget::downloadSelectedTorrents(), MainWindow::dropEvent(), TorrentCreatorDialog::handleCreationSuccess(), handleDownloadFinished(), MainWindow::keyPressEvent(), MainWindow::on_actionOpen_triggered(), TorrentFilesWatcher::onMagnetFound(), TorrentFilesWatcher::onTorrentFound(), RSS::AutoDownloader::processJob(), Application::processParams(), and recursiveTorrentDownload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addTorrent() [3/3]

bool Session::addTorrent	(	const TorrentInfo &	torrentInfo,
		const AddTorrentParams &	params = `AddTorrentParams()`
	)

Definition at line 2044 of file session.cpp.

 {
     return addTorrent_impl(torrentInfo, params);
 }

References addTorrent_impl().

Here is the call graph for this function:

◆ addTorrent_impl()

bool Session::addTorrent_impl	(	const std::variant< MagnetUri, TorrentInfo > &	source,
		const AddTorrentParams &	addTorrentParams
	)

private

Definition at line 2094 of file session.cpp.

 {
     const bool hasMetadata = std::holds_alternative<TorrentInfo>(source);
     const auto id = TorrentID::fromInfoHash(hasMetadata ? std::get<TorrentInfo>(source).infoHash() : std::get<MagnetUri>(source).infoHash());
  
     // It looks illogical that we don't just use an existing handle,
     // but as previous experience has shown, it actually creates unnecessary
     // problems and unwanted behavior due to the fact that it was originally
     // added with parameters other than those provided by the user.
     cancelDownloadMetadata(id);
  
     // We should not add the torrent if it is already
     // processed or is pending to add to session
     if (m_loadingTorrents.contains(id))
         return false;
  
     TorrentImpl *const torrent = m_torrents.value(id);
     if (torrent)
     {  // a duplicate torrent is added
         if (torrent->isPrivate())
             return false;
  
         if (hasMetadata)
         {
             const TorrentInfo &torrentInfo = std::get<TorrentInfo>(source);
  
             if (torrentInfo.isPrivate())
                 return false;
  
             // merge trackers and web seeds
             torrent->addTrackers(torrentInfo.trackers());
             torrent->addUrlSeeds(torrentInfo.urlSeeds());
         }
         else
         {
             const MagnetUri &magnetUri = std::get<MagnetUri>(source);
  
             // merge trackers and web seeds
             torrent->addTrackers(magnetUri.trackers());
             torrent->addUrlSeeds(magnetUri.urlSeeds());
         }
  
         return true;
     }
  
     LoadTorrentParams loadTorrentParams = initLoadTorrentParams(addTorrentParams);
     lt::add_torrent_params &p = loadTorrentParams.ltAddTorrentParams;
  
     bool isFindingIncompleteFiles = false;
  
     const bool useAutoTMM = loadTorrentParams.useAutoTMM;
     const QString actualSavePath = useAutoTMM ? categorySavePath(loadTorrentParams.category) : loadTorrentParams.savePath;
  
     if (hasMetadata)
     {
         const TorrentInfo &torrentInfo = std::get<TorrentInfo>(source);
  
         // if torrent name wasn't explicitly set we handle the case of
         // initial renaming of torrent content and rename torrent accordingly
         if (loadTorrentParams.name.isEmpty())
         {
             QString contentName = torrentInfo.rootFolder();
             if (contentName.isEmpty() && (torrentInfo.filesCount() == 1))
                 contentName = Utils::Fs::fileName(torrentInfo.filePath(0));
  
             if (!contentName.isEmpty() && (contentName != torrentInfo.name()))
                 loadTorrentParams.name = contentName;
         }
  
         Q_ASSERT(addTorrentParams.filePaths.isEmpty() || (addTorrentParams.filePaths.size() == torrentInfo.filesCount()));
  
         const TorrentContentLayout contentLayout = ((loadTorrentParams.contentLayout == TorrentContentLayout::Original)
                                                     ? detectContentLayout(torrentInfo.filePaths()) : loadTorrentParams.contentLayout);
         QStringList filePaths = (!addTorrentParams.filePaths.isEmpty() ? addTorrentParams.filePaths : torrentInfo.filePaths());
         applyContentLayout(filePaths, contentLayout, Utils::Fs::findRootFolder(torrentInfo.filePaths()));
  
         if (!loadTorrentParams.hasSeedStatus)
         {
             const QString actualDownloadPath = useAutoTMM
                     ? categoryDownloadPath(loadTorrentParams.category) : loadTorrentParams.downloadPath;
             findIncompleteFiles(torrentInfo, actualSavePath, actualDownloadPath, filePaths);
             isFindingIncompleteFiles = true;
         }
  
         const auto nativeIndexes = torrentInfo.nativeIndexes();
         if (!filePaths.isEmpty())
         {
             for (int index = 0; index < addTorrentParams.filePaths.size(); ++index)
                 p.renamed_files[nativeIndexes[index]] = Utils::Fs::toNativePath(addTorrentParams.filePaths.at(index)).toStdString();
         }
  
         Q_ASSERT(p.file_priorities.empty());
         const int internalFilesCount = torrentInfo.nativeInfo()->files().num_files(); // including .pad files
         // Use qBittorrent default priority rather than libtorrent's (4)
         p.file_priorities = std::vector(internalFilesCount, LT::toNative(DownloadPriority::Normal));
         Q_ASSERT(addTorrentParams.filePriorities.isEmpty() || (addTorrentParams.filePriorities.size() == nativeIndexes.size()));
         for (int i = 0; i < addTorrentParams.filePriorities.size(); ++i)
             p.file_priorities[LT::toUnderlyingType(nativeIndexes[i])] = LT::toNative(addTorrentParams.filePriorities[i]);
  
         p.ti = torrentInfo.nativeInfo();
     }
     else
     {
         const MagnetUri &magnetUri = std::get<MagnetUri>(source);
         p = magnetUri.addTorrentParams();
  
         if (loadTorrentParams.name.isEmpty() && !p.name.empty())
             loadTorrentParams.name = QString::fromStdString(p.name);
     }
  
     p.save_path = Utils::Fs::toNativePath(actualSavePath).toStdString();
  
     p.upload_limit = addTorrentParams.uploadLimit;
     p.download_limit = addTorrentParams.downloadLimit;
  
     // Preallocation mode
     p.storage_mode = isPreallocationEnabled() ? lt::storage_mode_allocate : lt::storage_mode_sparse;
  
     if (addTorrentParams.sequential)
         p.flags |= lt::torrent_flags::sequential_download;
     else
         p.flags &= ~lt::torrent_flags::sequential_download;
  
     // Seeding mode
     // Skip checking and directly start seeding
     if (addTorrentParams.skipChecking)
         p.flags |= lt::torrent_flags::seed_mode;
     else
         p.flags &= ~lt::torrent_flags::seed_mode;
  
     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::AutoManaged))
         p.flags |= lt::torrent_flags::paused;
     else
         p.flags &= ~lt::torrent_flags::paused;
     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::Forced))
         p.flags &= ~lt::torrent_flags::auto_managed;
     else
         p.flags |= lt::torrent_flags::auto_managed;
  
     p.added_time = std::time(nullptr);
  
     if (!isFindingIncompleteFiles)
         return loadTorrent(loadTorrentParams);
  
     m_loadingTorrents.insert(id, loadTorrentParams);
     return true;
 }

Referenced by addTorrent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ adjustLimits() [1/2]

void Session::adjustLimits ( )

private

Definition at line 1002 of file session.cpp.

 {
     if (isQueueingSystemEnabled())
     {
         lt::settings_pack settingsPack = m_nativeSession->get_settings();
         adjustLimits(settingsPack);
         m_nativeSession->apply_settings(settingsPack);
     }
 }

References isQueueingSystemEnabled(), and m_nativeSession.

Referenced by cancelDownloadMetadata(), downloadMetadata(), handleMetadataReceivedAlert(), and loadLTSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ adjustLimits() [2/2]

void Session::adjustLimits ( lt::settings_pack & settingsPack ) const

private

Definition at line 1127 of file session.cpp.

 {
     // Internally increase the queue limits to ensure that the magnet is started
     const int maxDownloads = maxActiveDownloads();
     const int maxActive = maxActiveTorrents();
  
     settingsPack.set_int(lt::settings_pack::active_downloads
                          , maxDownloads > -1 ? maxDownloads + m_extraLimit : maxDownloads);
     settingsPack.set_int(lt::settings_pack::active_limit
                          , maxActive > -1 ? maxActive + m_extraLimit : maxActive);
 }

References m_extraLimit, maxActiveDownloads(), and maxActiveTorrents().

Here is the call graph for this function:

◆ allTorrentsFinished

void BitTorrent::Session::allTorrentsFinished ( )

signal

Referenced by Application::exec(), and handleTorrentFinished().

Here is the caller graph for this function:

◆ altGlobalDownloadSpeedLimit()

int Session::altGlobalDownloadSpeedLimit ( ) const

Definition at line 2646 of file session.cpp.

 {
     // Unfortunately the value was saved as KiB instead of B.
     // But it is better to pass it around internally(+ webui) as Bytes.
     return m_altGlobalDownloadSpeedLimit * 1024;
 }

References m_altGlobalDownloadSpeedLimit.

Referenced by applyBandwidthLimits(), downloadSpeedLimit(), and setAltGlobalDownloadSpeedLimit().

Here is the caller graph for this function:

◆ altGlobalUploadSpeedLimit()

int Session::altGlobalUploadSpeedLimit ( ) const

Definition at line 2671 of file session.cpp.

 {
     // Unfortunately the value was saved as KiB instead of B.
     // But it is better to pass it around internally(+ webui) as Bytes.
     return m_altGlobalUploadSpeedLimit * 1024;
 }

References m_altGlobalUploadSpeedLimit.

Referenced by applyBandwidthLimits(), setAltGlobalUploadSpeedLimit(), and uploadSpeedLimit().

Here is the caller graph for this function:

◆ announceIP()

QString Session::announceIP ( ) const

Definition at line 3615 of file session.cpp.

 {
     return m_announceIP;
 }

References m_announceIP.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the caller graph for this function:

◆ announceToAllTiers()

bool Session::announceToAllTiers ( ) const

Definition at line 3123 of file session.cpp.

 {
     return m_announceToAllTiers;
 }

References m_announceToAllTiers.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the caller graph for this function:

◆ announceToAllTrackers()

bool Session::announceToAllTrackers ( ) const

Definition at line 3109 of file session.cpp.

 {
     return m_announceToAllTrackers;
 }

References m_announceToAllTrackers.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the caller graph for this function:

◆ applyBandwidthLimits() [1/2]

void Session::applyBandwidthLimits ( )

private

Definition at line 1012 of file session.cpp.

 {
     lt::settings_pack settingsPack = m_nativeSession->get_settings();
     applyBandwidthLimits(settingsPack);
     m_nativeSession->apply_settings(settingsPack);
 }

References m_nativeSession.

Referenced by loadLTSettings(), and setAltGlobalSpeedLimitEnabled().

Here is the caller graph for this function:

◆ applyBandwidthLimits() [2/2]

void Session::applyBandwidthLimits ( lt::settings_pack & settingsPack ) const

private

Definition at line 1139 of file session.cpp.

 {
     const bool altSpeedLimitEnabled = isAltGlobalSpeedLimitEnabled();
     settingsPack.set_int(lt::settings_pack::download_rate_limit, altSpeedLimitEnabled ? altGlobalDownloadSpeedLimit() : globalDownloadSpeedLimit());
     settingsPack.set_int(lt::settings_pack::upload_rate_limit, altSpeedLimitEnabled ? altGlobalUploadSpeedLimit() : globalUploadSpeedLimit());
 }

References altGlobalDownloadSpeedLimit(), altGlobalUploadSpeedLimit(), globalDownloadSpeedLimit(), globalUploadSpeedLimit(), and isAltGlobalSpeedLimitEnabled().

Here is the call graph for this function:

◆ asyncIOThreads()

int Session::asyncIOThreads ( ) const

Definition at line 3179 of file session.cpp.

 {
     return std::clamp(m_asyncIOThreads.get(), 1, 1024);
 }

References CachedSettingValue< T >::get(), and m_asyncIOThreads.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ banIP()

void Session::banIP ( const QString & ip )

Definition at line 1771 of file session.cpp.

 {
     QStringList bannedIPs = m_bannedIPs;
     if (!bannedIPs.contains(ip))
     {
         lt::ip_filter filter = m_nativeSession->get_ip_filter();
         lt::error_code ec;
         const lt::address addr = lt::make_address(ip.toLatin1().constData(), ec);
         Q_ASSERT(!ec);
         if (ec) return;
         filter.add_rule(addr, addr, lt::ip_filter::blocked);
         m_nativeSession->set_ip_filter(filter);
  
         bannedIPs << ip;
         bannedIPs.sort();
         m_bannedIPs = bannedIPs;
     }
 }

References bannedIPs(), m_bannedIPs, and m_nativeSession.

Referenced by TransferController::banPeersAction(), and PeerListWidget::banSelectedPeers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bannedIPs()

QStringList Session::bannedIPs ( ) const

Definition at line 2995 of file session.cpp.

 {
     return m_bannedIPs;
 }

References m_bannedIPs.

Referenced by banIP().

Here is the caller graph for this function:

◆ blockPeersOnPrivilegedPorts()

bool Session::blockPeersOnPrivilegedPorts ( ) const

Definition at line 3801 of file session.cpp.

 {
     return m_blockPeersOnPrivilegedPorts;
 }

References m_blockPeersOnPrivilegedPorts.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the caller graph for this function:

◆ bottomTorrentsQueuePos()

void Session::bottomTorrentsQueuePos ( const QVector< TorrentID > & ids )

Definition at line 1942 of file session.cpp.

 {
     using ElementType = std::pair<int, const TorrentImpl *>;
     std::priority_queue<ElementType
         , std::vector<ElementType>
         , std::greater<ElementType>> torrentQueue;
  
     // Sort torrents by queue position
     for (const TorrentID &id : ids)
     {
         const TorrentImpl *torrent = m_torrents.value(id);
         if (!torrent) continue;
         if (const int position = torrent->queuePosition(); position >= 0)
             torrentQueue.emplace(position, torrent);
     }
  
     // Bottom torrents queue position (starting with the one in the highest queue position)
     while (!torrentQueue.empty())
     {
         const TorrentImpl *torrent = torrentQueue.top().second;
         torrentQueuePositionBottom(torrent->nativeHandle());
         torrentQueue.pop();
     }
  
     for (auto i = m_downloadedMetadata.cbegin(); i != m_downloadedMetadata.cend(); ++i)
         torrentQueuePositionBottom(m_nativeSession->find_torrent(*i));
  
     saveTorrentsQueue();
 }

References m_downloadedMetadata, m_nativeSession, m_torrents, BitTorrent::TorrentImpl::nativeHandle(), BitTorrent::TorrentImpl::queuePosition(), saveTorrentsQueue(), and anonymous_namespace{session.cpp}::torrentQueuePositionBottom().

Referenced by TorrentsController::bottomPrioAction(), and TransferListWidget::bottomQueuePosSelectedTorrents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ btProtocol()

BTProtocol Session::btProtocol ( ) const

Definition at line 3706 of file session.cpp.

 {
     return m_btProtocol;
 }

References m_btProtocol.

Referenced by loadLTSettings().

Here is the caller graph for this function:

◆ cacheStatus()

const CacheStatus & Session::cacheStatus ( ) const

Definition at line 4306 of file session.cpp.

 {
     return m_cacheStatus;
 }

References m_cacheStatus.

Referenced by StatsDialog::update().

Here is the caller graph for this function:

◆ cancelDownloadMetadata()

bool Session::cancelDownloadMetadata ( const TorrentID & id )

Definition at line 1850 of file session.cpp.

 {
     const auto downloadedMetadataIter = m_downloadedMetadata.find(id);
     if (downloadedMetadataIter == m_downloadedMetadata.end()) return false;
  
     m_downloadedMetadata.erase(downloadedMetadataIter);
     --m_extraLimit;
     adjustLimits();
     m_nativeSession->remove_torrent(m_nativeSession->find_torrent(id), lt::session::delete_files);
     return true;
 }

References adjustLimits(), m_downloadedMetadata, m_extraLimit, and m_nativeSession.

Referenced by addTorrent_impl(), and AddNewTorrentDialog::reject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ categories()

QStringList Session::categories ( ) const

Definition at line 659 of file session.cpp.

 {
     return m_categories.keys();
 }

References m_categories.

Referenced by AutomatedRssDownloader::initCategoryCombobox(), and BitTorrent::TorrentImpl::setCategory().

Here is the caller graph for this function:

◆ categoryAdded

void BitTorrent::Session::categoryAdded ( const QString & categoryName )

signal

Referenced by addCategory().

Here is the caller graph for this function:

◆ categoryDownloadPath()

QString Session::categoryDownloadPath ( const QString & categoryName ) const

Definition at line 682 of file session.cpp.

 {
     const CategoryOptions categoryOptions = m_categories.value(categoryName);
     const CategoryOptions::DownloadPathOption downloadPathOption =
             categoryOptions.downloadPath.value_or(CategoryOptions::DownloadPathOption {isDownloadPathEnabled(), downloadPath()});
     if (!downloadPathOption.enabled)
         return {};
  
     const QString basePath = downloadPath();
     if (categoryName.isEmpty())
         return basePath;
  
     const QString path = (!downloadPathOption.path.isEmpty()
                           ? downloadPathOption.path
                           : Utils::Fs::toValidFileSystemName(categoryName, true)); // use implicit download path
  
     return (QDir::isAbsolutePath(path) ? path : Utils::Fs::resolvePath(path, basePath));
 }

References categoryOptions(), BitTorrent::CategoryOptions::downloadPath, downloadPath(), BitTorrent::CategoryOptions::DownloadPathOption::enabled, isDownloadPathEnabled(), m_categories, BitTorrent::CategoryOptions::DownloadPathOption::path, Utils::Fs::resolvePath(), and Utils::Fs::toValidFileSystemName().

Referenced by addTorrent_impl(), BitTorrent::TorrentImpl::downloadPath(), TorrentOptionsDialog::handleTMMChanged(), and BitTorrent::TorrentImpl::setAutoTMMEnabled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ categoryOptions()

CategoryOptions Session::categoryOptions ( const QString & categoryName ) const

Definition at line 664 of file session.cpp.

 {
     return m_categories.value(categoryName);
 }

References m_categories.

Referenced by categoryDownloadPath(), loadCategories(), storeCategories(), and upgradeCategories().

Here is the caller graph for this function:

◆ categoryRemoved

void BitTorrent::Session::categoryRemoved ( const QString & categoryName )

signal

Referenced by removeCategory().

Here is the caller graph for this function:

◆ categorySavePath()

QString Session::categorySavePath ( const QString & categoryName ) const

Definition at line 669 of file session.cpp.

 {
     const QString basePath = savePath();
     if (categoryName.isEmpty())
         return basePath;
  
     QString path = m_categories.value(categoryName).savePath;
     if (path.isEmpty()) // use implicit save path
         path = Utils::Fs::toValidFileSystemName(categoryName, true);
  
     return (QDir::isAbsolutePath(path) ? path : Utils::Fs::resolvePath(path, basePath));
 }

References m_categories, Utils::Fs::resolvePath(), savePath(), and Utils::Fs::toValidFileSystemName().

Referenced by addTorrent_impl(), TorrentOptionsDialog::handleCategoryChanged(), TorrentOptionsDialog::handleTMMChanged(), BitTorrent::TorrentImpl::savePath(), and BitTorrent::TorrentImpl::setAutoTMMEnabled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkingMemUsage()

int Session::checkingMemUsage ( ) const

Definition at line 3221 of file session.cpp.

 {
     return std::max(1, m_checkingMemUsage.get());
 }

References CachedSettingValue< T >::get(), and m_checkingMemUsage.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ chokingAlgorithm()

ChokingAlgorithm Session::chokingAlgorithm ( ) const

Definition at line 2868 of file session.cpp.

 {
     return m_chokingAlgorithm;
 }

References m_chokingAlgorithm.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the caller graph for this function:

◆ configure()

void Session::configure ( )

private

Definition at line 1019 of file session.cpp.

 {
     lt::settings_pack settingsPack = m_nativeSession->get_settings();
     loadLTSettings(settingsPack);
     m_nativeSession->apply_settings(settingsPack);
  
     configureComponents();
  
     m_deferredConfigureScheduled = false;
 }

References configureComponents(), loadLTSettings(), m_deferredConfigureScheduled, and m_nativeSession.

Referenced by configureDeferred().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ configureComponents()

void Session::configureComponents ( )

private

Definition at line 1030 of file session.cpp.

 {
     // This function contains components/actions that:
     // 1. Need to be setup at start up
     // 2. When deferred configure is called
  
     configurePeerClasses();
  
     if (!m_IPFilteringConfigured)
     {
         if (isIPFilteringEnabled())
             enableIPFilter();
         else
             disableIPFilter();
         m_IPFilteringConfigured = true;
     }
  
 #if defined(Q_OS_WIN)
     applyOSMemoryPriority();
 #endif
 }

References configurePeerClasses(), disableIPFilter(), enableIPFilter(), isIPFilteringEnabled(), and m_IPFilteringConfigured.

Referenced by configure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ configureDeferred

void Session::configureDeferred ( )

privateslot

Definition at line 4230 of file session.cpp.

 {
     if (m_deferredConfigureScheduled)
         return;
  
     m_deferredConfigureScheduled = true;
     QMetaObject::invokeMethod(this, qOverload<>(&Session::configure), Qt::QueuedConnection);
 }

References configure(), and m_deferredConfigureScheduled.

Referenced by configureListeningInterface(), setAltGlobalDownloadSpeedLimit(), setAltGlobalUploadSpeedLimit(), setAnnounceIP(), setAnnounceToAllTiers(), setAnnounceToAllTrackers(), setAnonymousModeEnabled(), setAsyncIOThreads(), setBannedIPs(), setBlockPeersOnPrivilegedPorts(), setBTProtocol(), setCheckingMemUsage(), setChokingAlgorithm(), setCoalesceReadWriteEnabled(), setConnectionSpeed(), setDHTEnabled(), setDiskCacheSize(), setDiskCacheTTL(), setDownloadRateForSlowTorrents(), setEncryption(), setFilePoolSize(), setGlobalDownloadSpeedLimit(), setGlobalUploadSpeedLimit(), setHashingThreads(), setIDNSupportEnabled(), setIgnoreLimitsOnLAN(), setIgnoreSlowTorrentsForQueueing(), setIncludeOverheadInLimits(), setIPFilterFile(), setIPFilteringEnabled(), setLSDEnabled(), setMaxActiveDownloads(), setMaxActiveTorrents(), setMaxActiveUploads(), setMaxConcurrentHTTPAnnounces(), setMaxConnections(), setMaxUploads(), setMultiConnectionsPerIpEnabled(), setOutgoingPortsMax(), setOutgoingPortsMin(), setPeerToS(), setPeerTurnover(), setPeerTurnoverCutoff(), setPeerTurnoverInterval(), setPieceExtentAffinity(), setProxyPeerConnectionsEnabled(), setQueueingSystemEnabled(), setSeedChokingAlgorithm(), setSendBufferLowWatermark(), setSendBufferWatermark(), setSendBufferWatermarkFactor(), setSlowTorrentsInactivityTimer(), setSocketBacklogSize(), setSSRFMitigationEnabled(), setStopTrackerTimeout(), setSuggestMode(), setTrackerFilteringEnabled(), setUploadRateForSlowTorrents(), setUPnPLeaseDuration(), setUseOSCache(), setUtpMixedMode(), setUTPRateLimited(), and setValidateHTTPSTrackerCertificate().

Here is the call graph for this function:

◆ configureListeningInterface()

void Session::configureListeningInterface ( )

private

Definition at line 2590 of file session.cpp.

 {
     m_listenInterfaceConfigured = false;
     configureDeferred();
 }

References configureDeferred(), and m_listenInterfaceConfigured.

Referenced by setNetworkInterface(), setNetworkInterfaceAddress(), and setPort().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ configureNetworkInterfaces()

void Session::configureNetworkInterfaces ( lt::settings_pack & settingsPack )

private

Definition at line 1421 of file session.cpp.

 {
     if (m_listenInterfaceConfigured)
         return;
  
     if (port() > 0)  // user has specified port number
         settingsPack.set_int(lt::settings_pack::max_retry_port_bind, 0);
  
     QStringList endpoints;
     QStringList outgoingInterfaces;
     const QString portString = ':' + QString::number(port());
  
     for (const QString &ip : asConst(getListeningIPs()))
     {
         const QHostAddress addr {ip};
         if (!addr.isNull())
         {
             const bool isIPv6 = (addr.protocol() == QAbstractSocket::IPv6Protocol);
             const QString ip = isIPv6
                           ? Utils::Net::canonicalIPv6Addr(addr).toString()
                           : addr.toString();
  
             endpoints << ((isIPv6 ? ('[' + ip + ']') : ip) + portString);
  
             if ((ip != QLatin1String("0.0.0.0")) && (ip != QLatin1String("::")))
                 outgoingInterfaces << ip;
         }
         else
         {
             // ip holds an interface name
 #ifdef Q_OS_WIN
             // On Vista+ versions and after Qt 5.5 QNetworkInterface::name() returns
             // the interface's LUID and not the GUID.
             // Libtorrent expects GUIDs for the 'listen_interfaces' setting.
             const QString guid = convertIfaceNameToGuid(ip);
             if (!guid.isEmpty())
             {
                 endpoints << (guid + portString);
                 outgoingInterfaces << guid;
             }
             else
             {
                 LogMsg(tr("Could not get GUID of network interface: %1").arg(ip) , Log::WARNING);
                 // Since we can't get the GUID, we'll pass the interface name instead.
                 // Otherwise an empty string will be passed to outgoing_interface which will cause IP leak.
                 endpoints << (ip + portString);
                 outgoingInterfaces << ip;
             }
 #else
             endpoints << (ip + portString);
             outgoingInterfaces << ip;
 #endif
         }
     }
  
     const QString finalEndpoints = endpoints.join(',');
     settingsPack.set_str(lt::settings_pack::listen_interfaces, finalEndpoints.toStdString());
     LogMsg(tr("Trying to listen on: %1", "e.g: Trying to listen on: 192.168.0.1:6881")
            .arg(finalEndpoints), Log::INFO);
  
     settingsPack.set_str(lt::settings_pack::outgoing_interfaces, outgoingInterfaces.join(',').toStdString());
     m_listenInterfaceConfigured = true;
 }

References asConst(), Utils::Net::canonicalIPv6Addr(), getListeningIPs(), Log::INFO, LogMsg(), m_listenInterfaceConfigured, port(), and Log::WARNING.

Referenced by loadLTSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ configurePeerClasses()

void Session::configurePeerClasses ( )

private

Definition at line 1485 of file session.cpp.

 {
     lt::ip_filter f;
     // lt::make_address("255.255.255.255") crashes on some people's systems
     // so instead we use address_v4::broadcast()
     // Proactively do the same for 0.0.0.0 and address_v4::any()
     f.add_rule(lt::address_v4::any()
                , lt::address_v4::broadcast()
                , 1 << LT::toUnderlyingType(lt::session::global_peer_class_id));
  
     // IPv6 may not be available on OS and the parsing
     // would result in an exception -> abnormal program termination
     // Affects Windows XP
     try
     {
         f.add_rule(lt::address_v6::any()
                    , lt::make_address("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
                    , 1 << LT::toUnderlyingType(lt::session::global_peer_class_id));
     }
     catch (const std::exception &) {}
  
     if (ignoreLimitsOnLAN())
     {
         // local networks
         f.add_rule(lt::make_address("10.0.0.0")
                    , lt::make_address("10.255.255.255")
                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
         f.add_rule(lt::make_address("172.16.0.0")
                    , lt::make_address("172.31.255.255")
                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
         f.add_rule(lt::make_address("192.168.0.0")
                    , lt::make_address("192.168.255.255")
                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
         // link local
         f.add_rule(lt::make_address("169.254.0.0")
                    , lt::make_address("169.254.255.255")
                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
         // loopback
         f.add_rule(lt::make_address("127.0.0.0")
                    , lt::make_address("127.255.255.255")
                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
  
         // IPv6 may not be available on OS and the parsing
         // would result in an exception -> abnormal program termination
         // Affects Windows XP
         try
         {
             // link local
             f.add_rule(lt::make_address("fe80::")
                        , lt::make_address("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
             // unique local addresses
             f.add_rule(lt::make_address("fc00::")
                        , lt::make_address("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
             // loopback
             f.add_rule(lt::address_v6::loopback()
                        , lt::address_v6::loopback()
                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
         }
         catch (const std::exception &) {}
     }
     m_nativeSession->set_peer_class_filter(f);
  
     lt::peer_class_type_filter peerClassTypeFilter;
     peerClassTypeFilter.add(lt::peer_class_type_filter::tcp_socket, lt::session::tcp_peer_class_id);
     peerClassTypeFilter.add(lt::peer_class_type_filter::ssl_tcp_socket, lt::session::tcp_peer_class_id);
     peerClassTypeFilter.add(lt::peer_class_type_filter::i2p_socket, lt::session::tcp_peer_class_id);
     if (!isUTPRateLimited())
     {
         peerClassTypeFilter.disallow(lt::peer_class_type_filter::utp_socket
             , lt::session::global_peer_class_id);
         peerClassTypeFilter.disallow(lt::peer_class_type_filter::ssl_utp_socket
             , lt::session::global_peer_class_id);
     }
     m_nativeSession->set_peer_class_type_filter(peerClassTypeFilter);
 }

References f(), ignoreLimitsOnLAN(), isUTPRateLimited(), m_nativeSession, and BitTorrent::LT::toUnderlyingType().

Referenced by configureComponents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ connectionSpeed()

int Session::connectionSpeed ( ) const

Definition at line 3369 of file session.cpp.

 {
     return m_connectionSpeed;
 }

References m_connectionSpeed.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the caller graph for this function:

◆ createTorrent()

void Session::createTorrent ( const lt::torrent_handle & nativeHandle )

private

Definition at line 4588 of file session.cpp.

 {
 #ifdef QBT_USES_LIBTORRENT2
     const auto torrentID = TorrentID::fromInfoHash(nativeHandle.info_hashes());
 #else
     const auto torrentID = TorrentID::fromInfoHash(nativeHandle.info_hash());
 #endif
  
     Q_ASSERT(m_loadingTorrents.contains(torrentID));
  
     const LoadTorrentParams params = m_loadingTorrents.take(torrentID);
  
     auto *const torrent = new TorrentImpl {this, m_nativeSession, nativeHandle, params};
     m_torrents.insert(torrent->id(), torrent);
  
     const bool hasMetadata = torrent->hasMetadata();
  
     if (params.restored)
     {
         LogMsg(tr("'%1' restored.", "'torrent name' restored.").arg(torrent->name()));
     }
     else
     {
         m_resumeDataStorage->store(torrent->id(), params);
  
         // The following is useless for newly added magnet
         if (hasMetadata)
         {
             // Copy the torrent file to the export folder
             if (!torrentExportDirectory().isEmpty())
             {
                 const TorrentInfo torrentInfo {*params.ltAddTorrentParams.ti};
                 exportTorrentFile(torrentInfo, torrentExportDirectory(), torrent->name());
             }
         }
  
         if (isAddTrackersEnabled() && !torrent->isPrivate())
             torrent->addTrackers(m_additionalTrackerList);
  
         LogMsg(tr("'%1' added to download list.", "'torrent name' was added to download list.")
             .arg(torrent->name()));
     }
  
     if (((torrent->ratioLimit() >= 0) || (torrent->seedingTimeLimit() >= 0))
         && !m_seedingLimitTimer->isActive())
         m_seedingLimitTimer->start();
  
     // Send torrent addition signal
     emit torrentLoaded(torrent);
     // Send new torrent signal
     if (!params.restored)
         emit torrentAdded(torrent);
  
     // Torrent could have error just after adding to libtorrent
     if (torrent->hasError())
         LogMsg(tr("Torrent errored. Torrent: \"%1\". Error: %2.").arg(torrent->name(), torrent->error()), Log::WARNING);
 }

References exportTorrentFile(), BitTorrent::TorrentID::fromInfoHash(), isAddTrackersEnabled(), LogMsg(), BitTorrent::LoadTorrentParams::ltAddTorrentParams, m_additionalTrackerList, m_loadingTorrents, m_nativeSession, m_resumeDataStorage, m_seedingLimitTimer, m_torrents, BitTorrent::LoadTorrentParams::restored, BitTorrent::ResumeDataStorage::store(), torrentAdded(), torrentExportDirectory(), torrentLoaded(), and Log::WARNING.

Referenced by handleAddTorrentAlert().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decreaseTorrentsQueuePos()

void Session::decreaseTorrentsQueuePos ( const QVector< TorrentID > & ids )

Definition at line 1889 of file session.cpp.

 {
     using ElementType = std::pair<int, const TorrentImpl *>;
     std::priority_queue<ElementType> torrentQueue;
  
     // Sort torrents by queue position
     for (const TorrentID &id : ids)
     {
         const TorrentImpl *torrent = m_torrents.value(id);
         if (!torrent) continue;
         if (const int position = torrent->queuePosition(); position >= 0)
             torrentQueue.emplace(position, torrent);
     }
  
     // Decrease torrents queue position (starting with the one in the lowest queue position)
     while (!torrentQueue.empty())
     {
         const TorrentImpl *torrent = torrentQueue.top().second;
         torrentQueuePositionDown(torrent->nativeHandle());
         torrentQueue.pop();
     }
  
     for (auto i = m_downloadedMetadata.cbegin(); i != m_downloadedMetadata.cend(); ++i)
         torrentQueuePositionBottom(m_nativeSession->find_torrent(*i));
  
     saveTorrentsQueue();
 }

References m_downloadedMetadata, m_nativeSession, m_torrents, BitTorrent::TorrentImpl::nativeHandle(), BitTorrent::TorrentImpl::queuePosition(), saveTorrentsQueue(), anonymous_namespace{session.cpp}::torrentQueuePositionBottom(), and anonymous_namespace{session.cpp}::torrentQueuePositionDown().

Referenced by TorrentsController::decreasePrioAction(), and TransferListWidget::decreaseQueuePosSelectedTorrents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deleteTorrent()

bool Session::deleteTorrent	(	const TorrentID &	id,
		DeleteOption	deleteOption = `DeleteTorrent`
	)

Definition at line 1792 of file session.cpp.

 {
     TorrentImpl *const torrent = m_torrents.take(id);
     if (!torrent) return false;
  
     qDebug("Deleting torrent with ID: %s", qUtf8Printable(torrent->id().toString()));
     emit torrentAboutToBeRemoved(torrent);
  
     // Remove it from session
     if (deleteOption == DeleteTorrent)
     {
         m_removingTorrents[torrent->id()] = {torrent->name(), "", deleteOption};
  
         const lt::torrent_handle nativeHandle {torrent->nativeHandle()};
         const auto iter = std::find_if(m_moveStorageQueue.begin(), m_moveStorageQueue.end()
                                  , [&nativeHandle](const MoveStorageJob &job)
         {
             return job.torrentHandle == nativeHandle;
         });
         if (iter != m_moveStorageQueue.end())
         {
             // We shouldn't actually remove torrent until existing "move storage jobs" are done
             torrentQueuePositionBottom(nativeHandle);
             nativeHandle.unset_flags(lt::torrent_flags::auto_managed);
             nativeHandle.pause();
         }
         else
         {
             m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_partfile);
         }
     }
     else
     {
         m_removingTorrents[torrent->id()] = {torrent->name(), torrent->rootPath(), deleteOption};
  
         if (m_moveStorageQueue.size() > 1)
         {
             // Delete "move storage job" for the deleted torrent
             // (note: we shouldn't delete active job)
             const auto iter = std::find_if(m_moveStorageQueue.begin() + 1, m_moveStorageQueue.end()
                                      , [torrent](const MoveStorageJob &job)
             {
                 return job.torrentHandle == torrent->nativeHandle();
             });
             if (iter != m_moveStorageQueue.end())
                 m_moveStorageQueue.erase(iter);
         }
  
         m_nativeSession->remove_torrent(torrent->nativeHandle(), lt::session::delete_files);
     }
  
     // Remove it from torrent resume directory
     m_resumeDataStorage->remove(torrent->id());
  
     delete torrent;
     return true;
 }

References DeleteTorrent, BitTorrent::Torrent::id(), m_moveStorageQueue, m_nativeSession, m_removingTorrents, m_resumeDataStorage, m_torrents, BitTorrent::TorrentImpl::name(), BitTorrent::TorrentImpl::nativeHandle(), BitTorrent::ResumeDataStorage::remove(), BitTorrent::TorrentImpl::rootPath(), torrentAboutToBeRemoved(), anonymous_namespace{session.cpp}::torrentQueuePositionBottom(), and Digest32< N >::toString().

Referenced by TorrentsController::deleteAction(), and processShareLimits().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disableIPFilter()

void Session::disableIPFilter ( )

private

Definition at line 4258 of file session.cpp.

 {
     qDebug("Disabling IPFilter");
     if (m_filterParser)
     {
         disconnect(m_filterParser.data(), nullptr, this, nullptr);
         delete m_filterParser;
     }
  
     // Add the banned IPs after the IPFilter disabling
     // which creates an empty filter and overrides all previously
     // applied bans.
     lt::ip_filter filter;
     processBannedIPs(filter);
     m_nativeSession->set_ip_filter(filter);
 }

References m_filterParser, m_nativeSession, and processBannedIPs().

Referenced by configureComponents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diskCacheSize()

int Session::diskCacheSize ( ) const

Definition at line 3237 of file session.cpp.

 {
 #ifdef QBT_APP_64BIT
     return std::min(m_diskCacheSize.get(), 33554431);  // 32768GiB
 #else
     // When build as 32bit binary, set the maximum at less than 2GB to prevent crashes
     // allocate 1536MiB and leave 512MiB to the rest of program data in RAM
     return std::min(m_diskCacheSize.get(), 1536);
 #endif
 }

References CachedSettingValue< T >::get(), and m_diskCacheSize.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diskCacheTTL()

int Session::diskCacheTTL ( ) const

Definition at line 3263 of file session.cpp.

 {
     return m_diskCacheTTL;
 }

References m_diskCacheTTL.

Referenced by AdvancedSettings::loadAdvancedSettings(), and loadLTSettings().

Here is the caller graph for this function:

◆ dispatchTorrentAlert()

void Session::dispatchTorrentAlert ( const lt::alert * a )

private

Definition at line 4571 of file session.cpp.

 {
     TorrentImpl *const torrent = m_torrents.value(static_cast<const lt::torrent_alert*>(a)->handle.info_hash());
     if (torrent)
     {
         torrent->handleAlert(a);
         return;
     }
  
     switch (a->type())
     {
     case lt::metadata_received_alert::alert_type:
         handleMetadataReceivedAlert(static_cast<const lt::metadata_received_alert*>(a));
         break;
     }
 }

References BitTorrent::TorrentImpl::handleAlert(), handleMetadataReceivedAlert(), and m_torrents.

Referenced by handleAlert(), and saveResumeData().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ downloadFromUrlFailed

void BitTorrent::Session::downloadFromUrlFailed	(	const QString &	url,
		const QString &	reason
	)

signal

Referenced by RSS::AutoDownloader::AutoDownloader(), handleDownloadFinished(), and MainWindow::MainWindow().

Here is the caller graph for this function:

◆ downloadFromUrlFinished

void BitTorrent::Session::downloadFromUrlFinished ( const QString & url )

signal

Referenced by RSS::AutoDownloader::AutoDownloader(), and handleDownloadFinished().

Here is the caller graph for this function:

◆ downloadMetadata()

bool Session::downloadMetadata ( const MagnetUri & magnetUri )

Definition at line 2283 of file session.cpp.

 {
     if (!magnetUri.isValid()) return false;
  
     const auto id = TorrentID::fromInfoHash(magnetUri.infoHash());
     const QString name = magnetUri.name();
  
     // We should not add torrent if it's already
     // processed or adding to session
     if (m_torrents.contains(id)) return false;
     if (m_loadingTorrents.contains(id)) return false;
     if (m_downloadedMetadata.contains(id)) return false;
  
     qDebug("Adding torrent to preload metadata...");
     qDebug(" -> Torrent ID: %s", qUtf8Printable(id.toString()));
     qDebug(" -> Name: %s", qUtf8Printable(name));
  
     lt::add_torrent_params p = magnetUri.addTorrentParams();
  
     // Flags
     // Preallocation mode
     if (isPreallocationEnabled())
         p.storage_mode = lt::storage_mode_allocate;
     else
         p.storage_mode = lt::storage_mode_sparse;
  
     // Limits
     p.max_connections = maxConnectionsPerTorrent();
     p.max_uploads = maxUploadsPerTorrent();
  
     const QString savePath = Utils::Fs::tempPath() + id.toString();
     p.save_path = Utils::Fs::toNativePath(savePath).toStdString();
  
     // Forced start
     p.flags &= ~lt::torrent_flags::paused;
     p.flags &= ~lt::torrent_flags::auto_managed;
  
     // Solution to avoid accidental file writes
     p.flags |= lt::torrent_flags::upload_mode;
  
 #ifndef QBT_USES_LIBTORRENT2
     p.storage = customStorageConstructor;
 #endif
  
     // Adding torrent to libtorrent session
     lt::error_code ec;
     lt::torrent_handle h = m_nativeSession->add_torrent(p, ec);
     if (ec) return false;
  
     // waiting for metadata...
     m_downloadedMetadata.insert(h.info_hash());
     ++m_extraLimit;
     adjustLimits();
  
     return true;
 }

References BitTorrent::MagnetUri::addTorrentParams(), adjustLimits(), customStorageConstructor(), BitTorrent::TorrentID::fromInfoHash(), BitTorrent::MagnetUri::infoHash(), isPreallocationEnabled(), BitTorrent::MagnetUri::isValid(), m_downloadedMetadata, m_extraLimit, m_loadingTorrents, m_nativeSession, m_torrents, maxConnectionsPerTorrent(), maxUploadsPerTorrent(), BitTorrent::MagnetUri::name(), savePath(), Utils::Fs::tempPath(), Utils::Fs::toNativePath(), and anonymous_namespace{session.cpp}::toString().

Referenced by AddNewTorrentDialog::loadMagnet().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ downloadPath()

QString Session::downloadPath ( ) const

Definition at line 625 of file session.cpp.

 {
     return m_downloadPath;
 }

References m_downloadPath.

Referenced by categoryDownloadPath(), findIncompleteFiles(), initLoadTorrentParams(), BitTorrent::TorrentImpl::setDownloadPath(), and startUpTorrents().

Here is the caller graph for this function:

◆ downloadRateForSlowTorrents()

int Session::downloadRateForSlowTorrents ( ) const

Definition at line 3489 of file session.cpp.

 {
     return m_downloadRateForSlowTorrents;
 }

References m_downloadRateForSlowTorrents.

Referenced by loadLTSettings().

Here is the caller graph for this function:

◆ downloadSpeedLimit()

int Session::downloadSpeedLimit ( ) const

Definition at line 2696 of file session.cpp.

 {
     return isAltGlobalSpeedLimitEnabled()
             ? altGlobalDownloadSpeedLimit()
             : globalDownloadSpeedLimit();
 }

References altGlobalDownloadSpeedLimit(), globalDownloadSpeedLimit(), and isAltGlobalSpeedLimitEnabled().

Referenced by TransferController::infoAction(), and StatusBar::updateSpeedLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ editCategory()

bool Session::editCategory	(	const QString &	name,
		const CategoryOptions &	options
	)

Definition at line 728 of file session.cpp.

 {
     const auto it = m_categories.find(name);
     if (it == m_categories.end())
         return false;
  
     CategoryOptions &currentOptions = it.value();
     if (options == currentOptions)
         return false;
  
     currentOptions = options;
     storeCategories();
     if (isDisableAutoTMMWhenCategorySavePathChanged())
     {
         for (TorrentImpl *const torrent : asConst(m_torrents))
         {
             if (torrent->category() == name)
                 torrent->setAutoTMMEnabled(false);
         }
     }
     else
     {
         for (TorrentImpl *const torrent : asConst(m_torrents))
         {
             if (torrent->category() == name)
                 torrent->handleCategoryOptionsChanged();
         }
     }
  
     return true;
 }

References asConst(), isDisableAutoTMMWhenCategorySavePathChanged(), m_categories, m_torrents, and storeCategories().

Here is the call graph for this function:

◆ enableBandwidthScheduler()

void Session::enableBandwidthScheduler ( )

private

Definition at line 1578 of file session.cpp.

 {
     if (!m_bwScheduler)
     {
         m_bwScheduler = new BandwidthScheduler(this);
         connect(m_bwScheduler.data(), &BandwidthScheduler::bandwidthLimitRequested
                 , this, &Session::setAltGlobalSpeedLimitEnabled);
     }
     m_bwScheduler->start();
 }

References BandwidthScheduler::bandwidthLimitRequested(), m_bwScheduler, and setAltGlobalSpeedLimitEnabled().

Referenced by setBandwidthSchedulerEnabled().

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Signals

Public Member Functions

Static Public Member Functions

Private Slots

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Session()

◆ ~Session()

Member Function Documentation

◆ addCategory()

◆ additionalTrackers()

◆ addMoveTorrentStorageJob()

◆ addTag()

◆ addTorrent() [1/3]

◆ addTorrent() [2/3]

◆ addTorrent() [3/3]

◆ addTorrent_impl()

◆ adjustLimits() [1/2]

◆ adjustLimits() [2/2]

◆ allTorrentsFinished

◆ altGlobalDownloadSpeedLimit()

◆ altGlobalUploadSpeedLimit()

◆ announceIP()

◆ announceToAllTiers()

◆ announceToAllTrackers()

◆ applyBandwidthLimits() [1/2]

◆ applyBandwidthLimits() [2/2]

◆ asyncIOThreads()

◆ banIP()

◆ bannedIPs()

◆ blockPeersOnPrivilegedPorts()

◆ bottomTorrentsQueuePos()

◆ btProtocol()

◆ cacheStatus()

◆ cancelDownloadMetadata()

◆ categories()

◆ categoryAdded

◆ categoryDownloadPath()

◆ categoryOptions()

◆ categoryRemoved

◆ categorySavePath()

◆ checkingMemUsage()

◆ chokingAlgorithm()

◆ configure()

◆ configureComponents()

◆ configureDeferred

◆ configureListeningInterface()

◆ configureNetworkInterfaces()

◆ configurePeerClasses()

◆ connectionSpeed()

◆ createTorrent()

◆ decreaseTorrentsQueuePos()

◆ deleteTorrent()

◆ disableIPFilter()

◆ diskCacheSize()

◆ diskCacheTTL()

◆ dispatchTorrentAlert()

◆ downloadFromUrlFailed

◆ downloadFromUrlFinished

◆ downloadMetadata()

◆ downloadPath()

◆ downloadRateForSlowTorrents()

◆ downloadSpeedLimit()

◆ editCategory()

◆ enableBandwidthScheduler()