mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity
transmission/qt/torrent.cc

700 lines
21 KiB
C++
Raw Blame History

/*
* This file Copyright (C) 2009-2010 Mnemosyne LLC
*
* This file is licensed by the GPL version 2. Works owned by the
* Transmission project are granted a special exemption to clause 2(b)
* so that the bulk of its code can remain under the MIT license.
* This exemption does not extend to derived works not owned by
* the Transmission project.
*
* $Id$
*/
#include <cassert>
#include <iostream>
#include <QApplication>
#include <QFileIconProvider>
#include <QFileInfo>
#include <QSet>
#include <QString>
#include <QStyle>
#include <QVariant>
#include <libtransmission/transmission.h>
#include <libtransmission/bencode.h>
#include <libtransmission/utils.h> /* tr_new0, tr_strdup */
#include "app.h"
#include "prefs.h"
#include "torrent.h"
#include "utils.h"
Torrent :: Torrent( Prefs& prefs, int id ):
myPrefs( prefs )
{
for( int i=0; i<PROPERTY_COUNT; ++i )
assert( myProperties[i].id == i );
setInt( ID, id );
setIcon( MIME_ICON, QApplication::style()->standardIcon( QStyle::SP_FileIcon ) );
}
Torrent :: ~Torrent( )
{
}
/***
****
***/
Torrent :: Property
Torrent :: myProperties[] =
{
{ ID, "id", QVariant::Int, INFO, },
{ UPLOAD_SPEED, "rateUpload", QVariant::Int, STAT } /* B/s */,
{ DOWNLOAD_SPEED, "rateDownload", QVariant::Int, STAT }, /* B/s */
{ DOWNLOAD_DIR, "downloadDir", QVariant::String, STAT },
{ ACTIVITY, "status", QVariant::Int, STAT },
{ NAME, "name", QVariant::String, INFO },
{ ERROR, "error", QVariant::Int, STAT },
{ ERROR_STRING, "errorString", QVariant::String, STAT },
{ SIZE_WHEN_DONE, "sizeWhenDone", QVariant::ULongLong, STAT },
{ LEFT_UNTIL_DONE, "leftUntilDone", QVariant::ULongLong, STAT },
{ HAVE_UNCHECKED, "haveUnchecked", QVariant::ULongLong, STAT },
{ HAVE_VERIFIED, "haveValid", QVariant::ULongLong, STAT },
{ DESIRED_AVAILABLE, "desiredAvailable", QVariant::ULongLong, STAT },
{ TOTAL_SIZE, "totalSize", QVariant::ULongLong, INFO },
{ PIECE_SIZE, "pieceSize", QVariant::ULongLong, INFO },
{ PIECE_COUNT, "pieceCount", QVariant::Int, INFO },
{ PEERS_GETTING_FROM_US, "peersGettingFromUs", QVariant::Int, STAT },
{ PEERS_SENDING_TO_US, "peersSendingToUs", QVariant::Int, STAT },
{ WEBSEEDS_SENDING_TO_US, "webseedsSendingToUs", QVariant::Int, STAT_EXTRA },
{ PERCENT_DONE, "percentDone", QVariant::Double, STAT },
{ METADATA_PERCENT_DONE, "metadataPercentComplete", QVariant::Double, STAT },
{ PERCENT_VERIFIED, "recheckProgress", QVariant::Double, STAT },
{ DATE_ACTIVITY, "activityDate", QVariant::DateTime, STAT_EXTRA },
{ DATE_ADDED, "addedDate", QVariant::DateTime, INFO },
{ DATE_STARTED, "startDate", QVariant::DateTime, STAT_EXTRA },
{ DATE_CREATED, "dateCreated", QVariant::DateTime, INFO },
{ PEERS_CONNECTED, "peersConnected", QVariant::Int, STAT },
{ ETA, "eta", QVariant::Int, STAT },
{ RATIO, "uploadRatio", QVariant::Double, STAT },
{ DOWNLOADED_EVER, "downloadedEver", QVariant::ULongLong, STAT },
{ UPLOADED_EVER, "uploadedEver", QVariant::ULongLong, STAT },
{ FAILED_EVER, "corruptEver", QVariant::ULongLong, STAT_EXTRA },
{ TRACKERS, "trackers", QVariant::StringList, INFO },
{ TRACKERSTATS, "trackerStats", TrTypes::TrackerStatsList, STAT_EXTRA },
{ MIME_ICON, "ccc", QVariant::Icon, DERIVED },
{ SEED_RATIO_LIMIT, "seedRatioLimit", QVariant::Double, STAT_EXTRA },
{ SEED_RATIO_MODE, "seedRatioMode", QVariant::Int, STAT_EXTRA },
{ DOWN_LIMIT, "downloadLimit", QVariant::Int, STAT_EXTRA }, /* KiB/s */
{ DOWN_LIMITED, "downloadLimited", QVariant::Bool, STAT_EXTRA },
{ UP_LIMIT, "uploadLimit", QVariant::Int, STAT_EXTRA }, /* KiB/s */
{ UP_LIMITED, "uploadLimited", QVariant::Bool, STAT_EXTRA },
{ HONORS_SESSION_LIMITS, "honorsSessionLimits", QVariant::Bool, STAT_EXTRA },
{ PEER_LIMIT, "peer-limit", QVariant::Int, STAT_EXTRA },
{ HASH_STRING, "hashString", QVariant::String, INFO },
{ IS_FINISHED, "isFinished", QVariant::Bool, STAT },
{ IS_PRIVATE, "isPrivate", QVariant::Bool, INFO },
{ COMMENT, "comment", QVariant::String, INFO },
{ CREATOR, "creator", QVariant::String, INFO },
{ MANUAL_ANNOUNCE_TIME, "manualAnnounceTime", QVariant::DateTime, STAT_EXTRA },
{ PEERS, "peers", TrTypes::PeerList, STAT_EXTRA },
{ TORRENT_FILE, "torrentFile", QVariant::String, STAT_EXTRA },
{ BANDWIDTH_PRIORITY, "bandwidthPriority", QVariant::Int, STAT_EXTRA }
};
Torrent :: KeyList
Torrent :: buildKeyList( Group group )
{
KeyList keys;
if( keys.empty( ) )
for( int i=0; i<PROPERTY_COUNT; ++i )
if( myProperties[i].id==ID || myProperties[i].group==group )
keys << myProperties[i].key;
return keys;
}
const Torrent :: KeyList&
Torrent :: getInfoKeys( )
{
static KeyList keys;
if( keys.isEmpty( ) )
keys << buildKeyList( INFO ) << "files";
return keys;
}
const Torrent :: KeyList&
Torrent :: getStatKeys( )
{
static KeyList keys( buildKeyList( STAT ) );
return keys;
}
const Torrent :: KeyList&
Torrent :: getExtraStatKeys( )
{
static KeyList keys;
if( keys.isEmpty( ) )
keys << buildKeyList( STAT_EXTRA ) << "fileStats";
return keys;
}
bool
Torrent :: setInt( int i, int value )
{
bool changed = false;
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Int );
if( myValues[i].isNull() || myValues[i].toInt()!=value )
{
myValues[i].setValue( value );
changed = true;
}
return changed;
}
bool
Torrent :: setBool( int i, bool value )
{
bool changed = false;
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Bool );
if( myValues[i].isNull() || myValues[i].toBool()!=value )
{
myValues[i].setValue( value );
changed = true;
}
return changed;
}
bool
Torrent :: setDouble( int i, double value )
{
bool changed = false;
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Double );
if( myValues[i].isNull() || myValues[i].toDouble()!=value )
{
myValues[i].setValue( value );
changed = true;
}
return changed;
}
bool
Torrent :: setDateTime( int i, const QDateTime& value )
{
bool changed = false;
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::DateTime );
if( myValues[i].isNull() || myValues[i].toDateTime()!=value )
{
myValues[i].setValue( value );
changed = true;
}
return changed;
}
bool
Torrent :: setSize( int i, qulonglong value )
{
bool changed = false;
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::ULongLong );
if( myValues[i].isNull() || myValues[i].toULongLong()!=value )
{
myValues[i].setValue( value );
changed = true;
}
return changed;
}
bool
Torrent :: setString( int i, const char * value )
{
bool changed = false;
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::String );
if( myValues[i].isNull() || myValues[i].toString()!=value )
{
myValues[i].setValue( QString::fromUtf8( value ) );
changed = true;
}
return changed;
}
bool
Torrent :: setIcon( int i, const QIcon& value )
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Icon );
myValues[i].setValue( value );
return true;
}
int
Torrent :: getInt( int i ) const
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Int );
return myValues[i].toInt( );
}
QDateTime
Torrent :: getDateTime( int i ) const
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::DateTime );
return myValues[i].toDateTime( );
}
bool
Torrent :: getBool( int i ) const
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Bool );
return myValues[i].toBool( );
}
qulonglong
Torrent :: getSize( int i ) const
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::ULongLong );
return myValues[i].toULongLong( );
}
double
Torrent :: getDouble( int i ) const
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Double );
return myValues[i].toDouble( );
}
QString
Torrent :: getString( int i ) const
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::String );
return myValues[i].toString( );
}
QIcon
Torrent :: getIcon( int i ) const
{
assert( 0<=i && i<PROPERTY_COUNT );
assert( myProperties[i].type == QVariant::Icon );
return myValues[i].value<QIcon>();
}
/***
****
***/
bool
Torrent :: getSeedRatio( double& ratio ) const
{
bool isLimited;
switch( seedRatioMode( ) )
{
case TR_RATIOLIMIT_SINGLE:
isLimited = true;
ratio = seedRatioLimit( );
break;
case TR_RATIOLIMIT_GLOBAL:
if(( isLimited = myPrefs.getBool( Prefs :: RATIO_ENABLED )))
ratio = myPrefs.getDouble( Prefs :: RATIO );
break;
case TR_RATIOLIMIT_UNLIMITED:
isLimited = false;
break;
}
return isLimited;
}
bool
Torrent :: hasFileSubstring( const QString& substr ) const
{
foreach( const TrFile file, myFiles )
if( file.filename.contains( substr, Qt::CaseInsensitive ) )
return true;
return false;
}
bool
Torrent :: hasTrackerSubstring( const QString& substr ) const
{
foreach( QString s, myValues[TRACKERS].toStringList() )
if( s.contains( substr, Qt::CaseInsensitive ) )
return true;
return false;
}
int
Torrent :: compareRatio( const Torrent& that ) const
{
const double a = ratio( );
const double b = that.ratio( );
if( (int)a == TR_RATIO_INF && (int)b == TR_RATIO_INF ) return 0;
if( (int)a == TR_RATIO_INF ) return 1;
if( (int)b == TR_RATIO_INF ) return -1;
if( a < b ) return -1;
if( a > b ) return 1;
return 0;
}
int
Torrent :: compareETA( const Torrent& that ) const
{
const bool haveA( hasETA( ) );
const bool haveB( that.hasETA( ) );
if( haveA && haveB ) return getETA() - that.getETA();
if( haveA ) return 1;
if( haveB ) return -1;
return 0;
}
int
Torrent :: compareTracker( const Torrent& that ) const
{
Q_UNUSED( that );
// FIXME
return 0;
}
/***
****
***/
void
Torrent :: updateMimeIcon( )
{
const FileList& files( myFiles );
QIcon icon;
if( files.size( ) > 1 )
icon = QFileIconProvider().icon( QFileIconProvider::Folder );
else if( files.size( ) == 1 )
icon = Utils :: guessMimeIcon( files.at(0).filename );
else
icon = QIcon( );
setIcon( MIME_ICON, icon );
}
/***
****
***/
void
Torrent :: notifyComplete( ) const
{
// if someone wants to implement notification, here's the hook.
}
/***
****
***/
void
Torrent :: update( tr_benc * d )
{
bool changed = false;
for( int i=0; i<PROPERTY_COUNT; ++i )
{
tr_benc * child = tr_bencDictFind( d, myProperties[i].key );
if( !child )
continue;
switch( myProperties[i].type )
{
case QVariant :: Int: {
int64_t val;
if( tr_bencGetInt( child, &val ) )
changed |= setInt( i, val );
break;
}
case QVariant :: Bool: {
tr_bool val;
if( tr_bencGetBool( child, &val ) )
changed |= setBool( i, val );
break;
}
case QVariant :: String: {
const char * val;
if( tr_bencGetStr( child, &val ) )
changed |= setString( i, val );
break;
}
case QVariant :: ULongLong: {
int64_t val;
if( tr_bencGetInt( child, &val ) )
changed |= setSize( i, val );
break;
}
case QVariant :: Double: {
double val;
if( tr_bencGetReal( child, &val ) )
changed |= setDouble( i, val );
break;
}
case QVariant :: DateTime: {
int64_t val;
if( tr_bencGetInt( child, &val ) && val )
changed |= setDateTime( i, QDateTime :: fromTime_t( val ) );
break;
}
case QVariant :: StringList:
case TrTypes :: PeerList:
break;
default:
assert( 0 && "unhandled type" );
}
}
tr_benc * files;
if( tr_bencDictFindList( d, "files", &files ) ) {
const char * str;
int64_t intVal;
int i = 0;
myFiles.clear( );
tr_benc * child;
while(( child = tr_bencListChild( files, i ))) {
TrFile file;
file.index = i++;
if( tr_bencDictFindStr( child, "name", &str ) )
file.filename = QString::fromUtf8( str );
if( tr_bencDictFindInt( child, "length", &intVal ) )
file.size = intVal;
myFiles.append( file );
}
updateMimeIcon( );
changed = true;
}
if( tr_bencDictFindList( d, "fileStats", &files ) ) {
const int n = tr_bencListSize( files );
assert( n == myFiles.size( ) );
for( int i=0; i<n; ++i ) {
int64_t intVal;
tr_bool boolVal;
tr_benc * child = tr_bencListChild( files, i );
TrFile& file( myFiles[i] );
if( tr_bencDictFindInt( child, "bytesCompleted", &intVal ) )
file.have = intVal;
if( tr_bencDictFindBool( child, "wanted", &boolVal ) )
file.wanted = boolVal;
if( tr_bencDictFindInt( child, "priority", &intVal ) )
file.priority = intVal;
}
changed = true;
}
tr_benc * trackers;
if( tr_bencDictFindList( d, "trackers", &trackers ) ) {
const char * str;
int i = 0;
QStringList list;
tr_benc * child;
while(( child = tr_bencListChild( trackers, i++ )))
if( tr_bencDictFindStr( child, "announce", &str ))
list.append( QString::fromUtf8( str ) );
if( myValues[TRACKERS] != list ) {
myValues[TRACKERS].setValue( list );
changed = true;
}
}
tr_benc * trackerStats;
if( tr_bencDictFindList( d, "trackerStats", &trackerStats ) ) {
tr_benc * child;
TrackerStatsList trackerStatsList;
int childNum = 0;
while(( child = tr_bencListChild( trackerStats, childNum++ ))) {
tr_bool b;
int64_t i;
const char * str;
TrackerStat trackerStat;
if( tr_bencDictFindStr( child, "announce", &str ) )
trackerStat.announce = QString::fromUtf8( str );
if( tr_bencDictFindInt( child, "announceState", &i ) )
trackerStat.announceState = i;
if( tr_bencDictFindInt( child, "downloadCount", &i ) )
trackerStat.downloadCount = i;
if( tr_bencDictFindBool( child, "hasAnnounced", &b ) )
trackerStat.hasAnnounced = b;
if( tr_bencDictFindBool( child, "hasScraped", &b ) )
trackerStat.hasScraped = b;
if( tr_bencDictFindStr( child, "host", &str ) )
trackerStat.host = QString::fromUtf8( str );
if( tr_bencDictFindInt( child, "id", &i ) )
trackerStat.id = i;
if( tr_bencDictFindBool( child, "isBackup", &b ) )
trackerStat.isBackup = b;
if( tr_bencDictFindInt( child, "lastAnnouncePeerCount", &i ) )
trackerStat.lastAnnouncePeerCount = i;
if( tr_bencDictFindInt( child, "lastAnnounceResult", &i ) )
trackerStat.lastAnnounceResult = i;
if( tr_bencDictFindInt( child, "lastAnnounceStartTime", &i ) )
trackerStat.lastAnnounceStartTime = i;
if( tr_bencDictFindBool( child, "lastAnnounceSucceeded", &b ) )
trackerStat.lastAnnounceSucceeded = b;
if( tr_bencDictFindInt( child, "lastAnnounceTime", &i ) )
trackerStat.lastAnnounceTime = i;
if( tr_bencDictFindBool( child, "lastAnnounceTimedOut", &b ) )
trackerStat.lastAnnounceTimedOut = b;
if( tr_bencDictFindStr( child, "lastScrapeResult", &str ) )
trackerStat.lastScrapeResult = QString::fromUtf8( str );
if( tr_bencDictFindInt( child, "lastScrapeStartTime", &i ) )
trackerStat.lastScrapeStartTime = i;
if( tr_bencDictFindBool( child, "lastScrapeSucceeded", &b ) )
trackerStat.lastScrapeSucceeded = b;
if( tr_bencDictFindInt( child, "lastScrapeTime", &i ) )
trackerStat.lastScrapeTime = i;
if( tr_bencDictFindBool( child, "lastScrapeTimedOut", &b ) )
trackerStat.lastScrapeTimedOut = b;
if( tr_bencDictFindInt( child, "leecherCount", &i ) )
trackerStat.leecherCount = i;
if( tr_bencDictFindInt( child, "nextAnnounceTime", &i ) )
trackerStat.nextAnnounceTime = i;
if( tr_bencDictFindInt( child, "nextScrapeTime", &i ) )
trackerStat.nextScrapeTime = i;
if( tr_bencDictFindInt( child, "scrapeState", &i ) )
trackerStat.scrapeState = i;
if( tr_bencDictFindInt( child, "seederCount", &i ) )
trackerStat.seederCount = i;
if( tr_bencDictFindInt( child, "tier", &i ) )
trackerStat.tier = i;
trackerStatsList << trackerStat;
}
myValues[TRACKERSTATS].setValue( trackerStatsList );
changed = true;
}
tr_benc * peers;
if( tr_bencDictFindList( d, "peers", &peers ) ) {
tr_benc * child;
PeerList peerList;
int childNum = 0;
while(( child = tr_bencListChild( peers, childNum++ ))) {
double d;
tr_bool b;
int64_t i;
const char * str;
Peer peer;
if( tr_bencDictFindStr( child, "address", &str ) )
peer.address = QString::fromUtf8( str );
if( tr_bencDictFindStr( child, "clientName", &str ) )
peer.clientName = QString::fromUtf8( str );
if( tr_bencDictFindBool( child, "clientIsChoked", &b ) )
peer.clientIsChoked = b;
if( tr_bencDictFindBool( child, "clientIsInterested", &b ) )
peer.clientIsInterested = b;
if( tr_bencDictFindBool( child, "isDownloadingFrom", &b ) )
peer.isDownloadingFrom = b;
if( tr_bencDictFindBool( child, "isEncrypted", &b ) )
peer.isEncrypted = b;
if( tr_bencDictFindBool( child, "isIncoming", &b ) )
peer.isIncoming = b;
if( tr_bencDictFindBool( child, "isUploadingTo", &b ) )
peer.isUploadingTo = b;
if( tr_bencDictFindBool( child, "peerIsChoked", &b ) )
peer.peerIsChoked = b;
if( tr_bencDictFindBool( child, "peerIsInterested", &b ) )
peer.peerIsInterested = b;
if( tr_bencDictFindInt( child, "port", &i ) )
peer.port = i;
if( tr_bencDictFindReal( child, "progress", &d ) )
peer.progress = d;
if( tr_bencDictFindInt( child, "rateToClient", &i ) )
peer.rateToClient = Speed::fromBps( i );
if( tr_bencDictFindInt( child, "rateToPeer", &i ) )
peer.rateToPeer = Speed::fromBps( i );
peerList << peer;
}
myValues[PEERS].setValue( peerList );
changed = true;
}
if( changed )
emit torrentChanged( id( ) );
}
QString
Torrent :: activityString( ) const
{
QString str;
switch( getActivity( ) )
{
case TR_STATUS_CHECK_WAIT: str = tr( "Waiting to verify local data" ); break;
case TR_STATUS_CHECK: str = tr( "Verifying local data" ); break;
case TR_STATUS_DOWNLOAD: str = tr( "Downloading" ); break;
case TR_STATUS_SEED: str = tr( "Seeding" ); break;
case TR_STATUS_STOPPED: str = isFinished() ? tr( "Finished" ): tr( "Paused" ); break;
}
return str;
}
QString
Torrent :: getError( ) const
{
QString s = getString( ERROR_STRING );
switch( getInt( ERROR ) )
{
case TR_STAT_TRACKER_WARNING: s = tr( "Tracker gave a warning: %1" ).arg( s ); break;
case TR_STAT_TRACKER_ERROR: s = tr( "Tracker gave an error: %1" ).arg( s ); break;
case TR_STAT_LOCAL_ERROR: s = tr( "Error: %1" ).arg( s ); break;
default: s.clear(); break;
}
return s;
}
Reference in New Issue View Git Blame Copy Permalink