/* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* tr_free */ #include /* LONG_VERSION */ #include "prefs.h" #include "qticonloader.h" #include "session.h" #include "session-dialog.h" #include "torrent.h" #include "utils.h" // #define DEBUG_HTTP namespace { enum { TAG_SOME_TORRENTS, TAG_ALL_TORRENTS, TAG_SESSION_STATS, TAG_SESSION_INFO, TAG_BLOCKLIST_UPDATE, TAG_ADD_TORRENT, TAG_PORT_TEST, TAG_MAGNET_LINK, FIRST_UNIQUE_TAG }; } /*** **** ***/ namespace { typedef Torrent::KeyList KeyList; const KeyList& getInfoKeys( ) { return Torrent::getInfoKeys( ); } const KeyList& getStatKeys( ) { return Torrent::getStatKeys( ); } const KeyList& getExtraStatKeys( ) { return Torrent::getExtraStatKeys( ); } void addList( tr_benc * list, const KeyList& strings ) { tr_bencListReserve( list, strings.size( ) ); foreach( const char * str, strings ) tr_bencListAddStr( list, str ); } } /*** **** ***/ void Session :: sessionSet( const char * key, const QVariant& value ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "session-set" ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 1 ) ); switch( value.type( ) ) { case QVariant::Bool: tr_bencDictAddBool ( args, key, value.toBool() ); break; case QVariant::Int: tr_bencDictAddInt ( args, key, value.toInt() ); break; case QVariant::Double: tr_bencDictAddReal ( args, key, value.toDouble() ); break; case QVariant::String: tr_bencDictAddStr ( args, key, value.toString().toUtf8() ); break; default: assert( "unknown type" ); } exec( &top ); tr_bencFree( &top ); } void Session :: portTest( ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "port-test" ); tr_bencDictAddInt( &top, "tag", TAG_PORT_TEST ); exec( &top ); tr_bencFree( &top ); } void Session :: copyMagnetLinkToClipboard( int torrentId ) { tr_benc top; tr_bencInitDict( &top, 3 ); tr_bencDictAddStr( &top, "method", "torrent-get" ); tr_bencDictAddInt( &top, "tag", TAG_MAGNET_LINK ); tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 ); tr_bencListAddInt( tr_bencDictAddList( args, "ids", 1 ), torrentId ); tr_bencListAddStr( tr_bencDictAddList( args, "fields", 1 ), "magnetLink" ); exec( &top ); tr_bencFree( &top ); } void Session :: updatePref( int key ) { if( myPrefs.isCore( key ) ) switch( key ) { case Prefs :: ALT_SPEED_LIMIT_DOWN: case Prefs :: ALT_SPEED_LIMIT_ENABLED: case Prefs :: ALT_SPEED_LIMIT_TIME_BEGIN: case Prefs :: ALT_SPEED_LIMIT_TIME_DAY: case Prefs :: ALT_SPEED_LIMIT_TIME_ENABLED: case Prefs :: ALT_SPEED_LIMIT_TIME_END: case Prefs :: ALT_SPEED_LIMIT_UP: case Prefs :: BLOCKLIST_DATE: case Prefs :: BLOCKLIST_ENABLED: case Prefs :: DHT_ENABLED: case Prefs :: DOWNLOAD_DIR: case Prefs :: DSPEED: case Prefs :: DSPEED_ENABLED: case Prefs :: INCOMPLETE_DIR: case Prefs :: INCOMPLETE_DIR_ENABLED: case Prefs :: LPD_ENABLED: case Prefs :: PEER_LIMIT_GLOBAL: case Prefs :: PEER_LIMIT_TORRENT: case Prefs :: PEER_PORT: case Prefs :: PEER_PORT_RANDOM_ON_START: case Prefs :: PEX_ENABLED: case Prefs :: PORT_FORWARDING: case Prefs :: SCRIPT_TORRENT_DONE_ENABLED: case Prefs :: SCRIPT_TORRENT_DONE_FILENAME: case Prefs :: START: case Prefs :: TRASH_ORIGINAL: case Prefs :: USPEED: case Prefs :: USPEED_ENABLED: sessionSet( myPrefs.keyStr(key), myPrefs.variant(key) ); break; case Prefs :: RATIO: sessionSet( "seedRatioLimit", myPrefs.variant(key) ); break; case Prefs :: RATIO_ENABLED: sessionSet( "seedRatioLimited", myPrefs.variant(key) ); break; case Prefs :: ENCRYPTION: { const int i = myPrefs.variant(key).toInt(); switch( i ) { case 0: sessionSet( myPrefs.keyStr(key), "tolerated" ); break; case 1: sessionSet( myPrefs.keyStr(key), "preferred" ); break; case 2: sessionSet( myPrefs.keyStr(key), "required" ); break; } break; } case Prefs :: RPC_AUTH_REQUIRED: if( mySession ) tr_sessionSetRPCEnabled( mySession, myPrefs.getBool(key) ); break; case Prefs :: RPC_ENABLED: if( mySession ) tr_sessionSetRPCEnabled( mySession, myPrefs.getBool(key) ); break; case Prefs :: RPC_PASSWORD: if( mySession ) tr_sessionSetRPCPassword( mySession, myPrefs.getString(key).toUtf8().constData() ); break; case Prefs :: RPC_PORT: if( mySession ) tr_sessionSetRPCPort( mySession, myPrefs.getInt(key) ); break; case Prefs :: RPC_USERNAME: if( mySession ) tr_sessionSetRPCUsername( mySession, myPrefs.getString(key).toUtf8().constData() ); break; case Prefs :: RPC_WHITELIST_ENABLED: if( mySession ) tr_sessionSetRPCWhitelistEnabled( mySession, myPrefs.getBool(key) ); break; case Prefs :: RPC_WHITELIST: if( mySession ) tr_sessionSetRPCWhitelist( mySession, myPrefs.getString(key).toUtf8().constData() ); break; default: std::cerr << "unhandled pref: " << key << std::endl; } } /*** **** ***/ Session :: Session( const char * configDir, Prefs& prefs ): nextUniqueTag( FIRST_UNIQUE_TAG ), myBlocklistSize( -1 ), myPrefs( prefs ), mySession( 0 ), myConfigDir( configDir ) { myStats.ratio = TR_RATIO_NA; myStats.uploadedBytes = 0; myStats.downloadedBytes = 0; myStats.filesAdded = 0; myStats.sessionCount = 0; myStats.secondsActive = 0; myCumulativeStats = myStats; connect( &myNAM, SIGNAL(finished(QNetworkReply*)), this, SLOT(onFinished(QNetworkReply*)) ); connect( &myNAM, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), this, SIGNAL(httpAuthenticationRequired()) ); connect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) ); } Session :: ~Session( ) { stop( ); } /*** **** ***/ void Session :: stop( ) { foreach( Reply myReply, myReplies ) myReply.networkReply->abort(); myUrl.clear( ); if( mySession ) { tr_sessionClose( mySession ); mySession = 0; } } void Session :: restart( ) { stop( ); start( ); } void Session :: start( ) { if( myPrefs.get(Prefs::SESSION_IS_REMOTE) ) { const int port( myPrefs.get(Prefs::SESSION_REMOTE_PORT) ); const bool auth( myPrefs.get(Prefs::SESSION_REMOTE_AUTH) ); const QString host( myPrefs.get(Prefs::SESSION_REMOTE_HOST) ); const QString user( myPrefs.get(Prefs::SESSION_REMOTE_USERNAME) ); const QString pass( myPrefs.get(Prefs::SESSION_REMOTE_PASSWORD) ); QUrl url; url.setScheme( "http" ); url.setHost( host ); url.setPort( port ); url.setPath( "/transmission/rpc" ); if( auth ) { url.setUserName( user ); url.setPassword( pass ); } myUrl = url; } else { tr_benc settings; tr_bencInitDict( &settings, 0 ); tr_sessionLoadSettings( &settings, myConfigDir.toUtf8().constData(), "qt" ); mySession = tr_sessionInit( "qt", myConfigDir.toUtf8().constData(), true, &settings ); tr_bencFree( &settings ); tr_ctor * ctor = tr_ctorNew( mySession ); int torrentCount; tr_torrent ** torrents = tr_sessionLoadTorrents( mySession, ctor, &torrentCount ); tr_free( torrents ); tr_ctorFree( ctor ); } emit sourceChanged( ); } bool Session :: isServer( ) const { return mySession != 0; } bool Session :: isLocal( ) const { if( mySession != 0 ) return true; if( myUrl.host() == "127.0.0.1" ) return true; if( !myUrl.host().compare( "localhost", Qt::CaseInsensitive ) ) return true; return false; } /*** **** ***/ namespace { tr_benc * buildRequest( const char * method, tr_benc& top, int tag=-1 ) { tr_bencInitDict( &top, 3 ); tr_bencDictAddStr( &top, "method", method ); if( tag >= 0 ) tr_bencDictAddInt( &top, "tag", tag ); return tr_bencDictAddDict( &top, "arguments", 0 ); } void addOptionalIds( tr_benc * args, const QSet& ids ) { if( !ids.isEmpty( ) ) { tr_benc * idList( tr_bencDictAddList( args, "ids", ids.size( ) ) ); foreach( int i, ids ) tr_bencListAddInt( idList, i ); } } } void Session :: torrentSet( const QSet& ids, const QString& key, double value ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-set" ); tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 ); tr_bencDictAddReal( args, key.toUtf8().constData(), value ); addOptionalIds( args, ids ); exec( &top ); tr_bencFree( &top ); } void Session :: torrentSet( const QSet& ids, const QString& key, int value ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-set" ); tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 ); tr_bencDictAddInt( args, key.toUtf8().constData(), value ); addOptionalIds( args, ids ); exec( &top ); tr_bencFree( &top ); } void Session :: torrentSet( const QSet& ids, const QString& key, bool value ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-set" ); tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 ); tr_bencDictAddBool( args, key.toUtf8().constData(), value ); addOptionalIds( args, ids ); exec( &top ); tr_bencFree( &top ); } void Session :: torrentSet( const QSet& ids, const QString& key, const QList& value ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-set" ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) ); addOptionalIds( args, ids ); tr_benc * list( tr_bencDictAddList( args, key.toUtf8().constData(), value.size( ) ) ); foreach( int i, value ) tr_bencListAddInt( list, i ); exec( &top ); tr_bencFree( &top ); } void Session :: torrentSet( const QSet& ids, const QString& key, const tr_benc * value ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-set" ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) ); addOptionalIds( args, ids ); tr_benc * child( tr_bencDictAdd( args, key.toUtf8().constData() ) ); memcpy( child, value, sizeof(tr_benc) ); exec( &top ); tr_bencFree( &top ); } void Session :: torrentSetLocation( const QSet& ids, const QString& location, bool doMove ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-set-location" ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 3 ) ); addOptionalIds( args, ids ); tr_bencDictAddStr( args, "location", location.toUtf8().constData() ); tr_bencDictAddBool( args, "move", doMove ); exec( &top ); tr_bencFree( &top ); } void Session :: refreshTorrents( const QSet& ids ) { if( ids.empty( ) ) { refreshAllTorrents( ); } else { tr_benc top; tr_bencInitDict( &top, 3 ); tr_bencDictAddStr( &top, "method", "torrent-get" ); tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) ); addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) ); addOptionalIds( args, ids ); exec( &top ); tr_bencFree( &top ); } } void Session :: refreshExtraStats( const QSet& ids ) { tr_benc top; tr_bencInitDict( &top, 3 ); tr_bencDictAddStr( &top, "method", "torrent-get" ); tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) ); addOptionalIds( args, ids ); addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) + getExtraStatKeys( )); exec( &top ); tr_bencFree( &top ); } void Session :: sendTorrentRequest( const char * request, const QSet& ids ) { tr_benc top; tr_benc * args( buildRequest( request, top ) ); addOptionalIds( args, ids ); exec( &top ); tr_bencFree( &top ); refreshTorrents( ids ); } void Session :: pauseTorrents( const QSet& ids ) { sendTorrentRequest( "torrent-stop", ids ); } void Session :: startTorrents( const QSet& ids ) { sendTorrentRequest( "torrent-start", ids ); } void Session :: refreshActiveTorrents( ) { tr_benc top; tr_bencInitDict( &top, 3 ); tr_bencDictAddStr( &top, "method", "torrent-get" ); tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) ); tr_bencDictAddStr( args, "ids", "recently-active" ); addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) ); exec( &top ); tr_bencFree( &top ); } void Session :: refreshAllTorrents( ) { tr_benc top; tr_bencInitDict( &top, 3 ); tr_bencDictAddStr( &top, "method", "torrent-get" ); tr_bencDictAddInt( &top, "tag", TAG_ALL_TORRENTS ); tr_benc * args( tr_bencDictAddDict( &top, "arguments", 1 ) ); addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) ); exec( &top ); tr_bencFree( &top ); } void Session :: initTorrents( const QSet& ids ) { tr_benc top; const int tag( ids.isEmpty() ? TAG_ALL_TORRENTS : TAG_SOME_TORRENTS ); tr_benc * args( buildRequest( "torrent-get", top, tag ) ); addOptionalIds( args, ids ); addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys()+getInfoKeys() ); exec( &top ); tr_bencFree( &top ); } void Session :: refreshSessionStats( ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "session-stats" ); tr_bencDictAddInt( &top, "tag", TAG_SESSION_STATS ); exec( &top ); tr_bencFree( &top ); } void Session :: refreshSessionInfo( ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "session-get" ); tr_bencDictAddInt( &top, "tag", TAG_SESSION_INFO ); exec( &top ); tr_bencFree( &top ); } void Session :: updateBlocklist( ) { tr_benc top; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "blocklist-update" ); tr_bencDictAddInt( &top, "tag", TAG_BLOCKLIST_UPDATE ); exec( &top ); tr_bencFree( &top ); } /*** **** ***/ void Session :: exec( const tr_benc * request ) { char * str = tr_bencToStr( request, TR_FMT_JSON_LEAN, NULL ); exec( str ); tr_free( str ); } void Session :: localSessionCallback( tr_session * session, const char * json, size_t len, void * self ) { Q_UNUSED( session ); ((Session*)self)->parseResponse( json, len ); } void Session :: exec( const char * json ) { if( mySession ) { tr_rpc_request_exec_json( mySession, json, strlen( json ), localSessionCallback, this ); } else if( !myUrl.isEmpty( ) ) { QNetworkRequest request; request.setUrl( myUrl ); request.setRawHeader( "User-Agent", QString( QCoreApplication::instance()->applicationName() + "/" + LONG_VERSION_STRING ).toAscii() ); request.setRawHeader( "Content-Type", "application/json; charset=UTF-8" ); if( !mySessionId.isEmpty( ) ) request.setRawHeader( TR_RPC_SESSION_ID_HEADER, mySessionId.toAscii() ); QBuffer * reqbuf = new QBuffer; reqbuf->setData( QByteArray( json ) ); QNetworkReply * reply = myNAM.post( request, reqbuf ); connect( reply, SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(dataReadProgress())); connect( reply, SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(dataSendProgress())); Reply myReply; myReply.networkReply = reply; myReply.buffer = reqbuf; myReplies << myReply; #ifdef DEBUG_HTTP std::cerr << "sending " << "POST " << qPrintable( myUrl.path() ) << std::endl; foreach( QByteArray b, request.rawHeaderList() ) std::cerr << b.constData() << ": " << request.rawHeader( b ).constData() << std::endl; std::cerr << "Body:\n" << json << std::endl; #endif } } void Session :: onFinished( QNetworkReply * reply ) { QBuffer * buffer; for( QList::iterator i = myReplies.begin(); i != myReplies.end(); ++i ) { if( reply == i->networkReply ) { buffer = i->buffer; myReplies.erase( i ); break; } } #ifdef DEBUG_HTTP std::cerr << "http response header: " << std::endl; foreach( QByteArray b, reply->rawHeaderList() ) std::cerr << b.constData() << ": " << reply->rawHeader( b ).constData() << std::endl; std::cerr << "json:\n" << reply->peek( reply->bytesAvailable() ).constData() << std::endl; #endif if( ( reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ).toInt() == 409 ) && ( reply->hasRawHeader( TR_RPC_SESSION_ID_HEADER ) ) ) { // we got a 409 telling us our session id has expired. // update it and resubmit the request. mySessionId = QString( reply->rawHeader( TR_RPC_SESSION_ID_HEADER ) ); exec( buffer->buffer().constData() ); } else if( reply->error() != QNetworkReply::NoError ) { std::cerr << "http error: " << qPrintable( reply->errorString() ) << std::endl; } else { const QByteArray response( reply->readAll() ); const char * json( response.constData( ) ); int jsonLength( response.size( ) ); if( jsonLength>0 && json[jsonLength-1] == '\n' ) --jsonLength; parseResponse( json, jsonLength ); } delete buffer; reply->deleteLater(); } void Session :: parseResponse( const char * json, size_t jsonLength ) { tr_benc top; const uint8_t * end( 0 ); const int err( tr_jsonParse( "rpc", json, jsonLength, &top, &end ) ); if( !err ) { int64_t tag = -1; const char * result = NULL; tr_benc * args = NULL; tr_bencDictFindInt ( &top, "tag", &tag ); tr_bencDictFindStr ( &top, "result", &result ); tr_bencDictFindDict( &top, "arguments", &args ); emit executed( tag, result, args ); tr_benc * torrents; const char * str; if( tr_bencDictFindInt( &top, "tag", &tag ) ) { switch( tag ) { case TAG_SOME_TORRENTS: case TAG_ALL_TORRENTS: if( tr_bencDictFindDict( &top, "arguments", &args ) ) { if( tr_bencDictFindList( args, "torrents", &torrents ) ) emit torrentsUpdated( torrents, tag==TAG_ALL_TORRENTS ); if( tr_bencDictFindList( args, "removed", &torrents ) ) emit torrentsRemoved( torrents ); } break; case TAG_SESSION_STATS: if( tr_bencDictFindDict( &top, "arguments", &args ) ) updateStats( args ); break; case TAG_SESSION_INFO: if( tr_bencDictFindDict( &top, "arguments", &args ) ) updateInfo( args ); break; case TAG_BLOCKLIST_UPDATE: { int64_t intVal = 0; if( tr_bencDictFindDict( &top, "arguments", &args ) ) if( tr_bencDictFindInt( args, "blocklist-size", &intVal ) ) setBlocklistSize( intVal ); break; } case TAG_PORT_TEST: { tr_bool isOpen = 0; if( tr_bencDictFindDict( &top, "arguments", &args ) ) tr_bencDictFindBool( args, "port-is-open", &isOpen ); emit portTested( (bool)isOpen ); } case TAG_MAGNET_LINK: { tr_benc * args; tr_benc * torrents; tr_benc * child; const char * str; if( tr_bencDictFindDict( &top, "arguments", &args ) && tr_bencDictFindList( args, "torrents", &torrents ) && (( child = tr_bencListChild( torrents, 0 ))) && tr_bencDictFindStr( child, "magnetLink", &str ) ) QApplication::clipboard()->setText( str ); break; } case TAG_ADD_TORRENT: str = ""; if( tr_bencDictFindStr( &top, "result", &str ) && strcmp( str, "success" ) ) { QMessageBox * d = new QMessageBox( QMessageBox::Information, tr( "Add Torrent" ), QString::fromUtf8(str), QMessageBox::Close, QApplication::activeWindow()); QPixmap pixmap; QIcon icon = QtIconLoader :: icon( "dialog-information" ); if( !icon.isNull( ) ) { const int size = QApplication::style()->pixelMetric( QStyle::PM_LargeIconSize ); d->setIconPixmap( icon.pixmap( size, size ) ); } connect( d, SIGNAL(rejected()), d, SLOT(deleteLater()) ); d->show( ); } break; default: break; } } tr_bencFree( &top ); } } void Session :: updateStats( tr_benc * d, struct tr_session_stats * stats ) { int64_t i; if( tr_bencDictFindInt( d, "uploadedBytes", &i ) ) stats->uploadedBytes = i; if( tr_bencDictFindInt( d, "downloadedBytes", &i ) ) stats->downloadedBytes = i; if( tr_bencDictFindInt( d, "filesAdded", &i ) ) stats->filesAdded = i; if( tr_bencDictFindInt( d, "sessionCount", &i ) ) stats->sessionCount = i; if( tr_bencDictFindInt( d, "secondsActive", &i ) ) stats->secondsActive = i; stats->ratio = tr_getRatio( stats->uploadedBytes, stats->downloadedBytes ); } void Session :: updateStats( tr_benc * d ) { tr_benc * c; if( tr_bencDictFindDict( d, "current-stats", &c ) ) updateStats( c, &myStats ); if( tr_bencDictFindDict( d, "cumulative-stats", &c ) ) updateStats( c, &myCumulativeStats ); emit statsUpdated( ); } void Session :: updateInfo( tr_benc * d ) { int64_t i; const char * str; disconnect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) ); for( int i=Prefs::FIRST_CORE_PREF; i<=Prefs::LAST_CORE_PREF; ++i ) { const tr_benc * b( tr_bencDictFind( d, myPrefs.keyStr( i ) ) ); if( !b ) continue; if( i == Prefs :: ENCRYPTION ) { const char * val; if( tr_bencGetStr( b, &val ) ) { if( !qstrcmp( val , "required" ) ) myPrefs.set( i, 2 ); else if( !qstrcmp( val , "preferred" ) ) myPrefs.set( i, 1 ); else if( !qstrcmp( val , "tolerated" ) ) myPrefs.set( i, 0 ); } continue; } switch( myPrefs.type( i ) ) { case QVariant :: Int: { int64_t val; if( tr_bencGetInt( b, &val ) ) myPrefs.set( i, (int)val ); break; } case QVariant :: Double: { double val; if( tr_bencGetReal( b, &val ) ) myPrefs.set( i, val ); break; } case QVariant :: Bool: { tr_bool val; if( tr_bencGetBool( b, &val ) ) myPrefs.set( i, (bool)val ); break; } case TrTypes :: FilterModeType: case TrTypes :: SortModeType: case QVariant :: String: { const char * val; if( tr_bencGetStr( b, &val ) ) myPrefs.set( i, QString(val) ); break; } default: break; } } tr_bool b; double x; if( tr_bencDictFindBool( d, "seedRatioLimited", &b ) ) myPrefs.set( Prefs::RATIO_ENABLED, b ? true : false ); if( tr_bencDictFindReal( d, "seedRatioLimit", &x ) ) myPrefs.set( Prefs::RATIO, x ); /* Use the C API to get settings that, for security reasons, aren't supported by RPC */ if( mySession != 0 ) { myPrefs.set( Prefs::RPC_ENABLED, tr_sessionIsRPCEnabled ( mySession ) ); myPrefs.set( Prefs::RPC_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled ( mySession ) ); myPrefs.set( Prefs::RPC_PASSWORD, tr_sessionGetRPCPassword ( mySession ) ); myPrefs.set( Prefs::RPC_PORT, tr_sessionGetRPCPort ( mySession ) ); myPrefs.set( Prefs::RPC_USERNAME, tr_sessionGetRPCUsername ( mySession ) ); myPrefs.set( Prefs::RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled ( mySession ) ); myPrefs.set( Prefs::RPC_WHITELIST, tr_sessionGetRPCWhitelist ( mySession ) ); } if( tr_bencDictFindInt( d, "blocklist-size", &i ) && i!=blocklistSize( ) ) setBlocklistSize( i ); if( tr_bencDictFindStr( d, "version", &str ) && ( mySessionVersion != str ) ) mySessionVersion = str; //std::cerr << "Session :: updateInfo end" << std::endl; connect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) ); emit sessionUpdated( ); } void Session :: setBlocklistSize( int64_t i ) { myBlocklistSize = i; emit blocklistUpdated( i ); } void Session :: addTorrent( QString filename ) { addTorrent( filename, myPrefs.getString( Prefs::DOWNLOAD_DIR ) ); } namespace { bool isLink( const QString& str ) { return Utils::isMagnetLink(str) || Utils::isURL(str); } } void Session :: addTorrent( QString key, QString localPath ) { tr_benc top, *args; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-add" ); args = tr_bencDictAddDict( &top, "arguments", 3 ); tr_bencDictAddStr( args, "download-dir", qPrintable(localPath) ); tr_bencDictAddBool( args, "paused", !myPrefs.getBool( Prefs::START ) ); // figure out what to do with "key".... bool keyHandled = false; if( !keyHandled && isLink( key )) { tr_bencDictAddStr( args, "filename", key.toUtf8().constData() ); keyHandled = true; // it's a URL or magnet link... } if( !keyHandled ) { QFile file( key ); file.open( QIODevice::ReadOnly ); const QByteArray raw( file.readAll( ) ); file.close( ); if( !raw.isEmpty( ) ) { int b64len = 0; char * b64 = tr_base64_encode( raw.constData(), raw.size(), &b64len ); tr_bencDictAddRaw( args, "metainfo", b64, b64len ); tr_free( b64 ); keyHandled = true; // it's a local file... } } if( !keyHandled ) { const QByteArray tmp = key.toUtf8(); tr_bencDictAddRaw( args, "metainfo", tmp.constData(), tmp.length() ); keyHandled = true; // treat it as base64 } exec( &top ); tr_bencFree( &top ); } void Session :: removeTorrents( const QSet& ids, bool deleteFiles ) { if( !ids.isEmpty( ) ) { tr_benc top, *args; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-remove" ); args = tr_bencDictAddDict( &top, "arguments", 2 ); addOptionalIds( args, ids ); tr_bencDictAddInt( args, "delete-local-data", deleteFiles ); exec( &top ); tr_bencFree( &top ); } } void Session :: verifyTorrents( const QSet& ids ) { if( !ids.isEmpty( ) ) { tr_benc top, *args; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-verify" ); args = tr_bencDictAddDict( &top, "arguments", 1 ); addOptionalIds( args, ids ); exec( &top ); tr_bencFree( &top ); } } void Session :: reannounceTorrents( const QSet& ids ) { if( !ids.isEmpty( ) ) { tr_benc top, *args; tr_bencInitDict( &top, 2 ); tr_bencDictAddStr( &top, "method", "torrent-reannounce" ); args = tr_bencDictAddDict( &top, "arguments", 1 ); addOptionalIds( args, ids ); exec( &top ); tr_bencFree( &top ); } } /*** **** ***/ void Session :: launchWebInterface( ) { QUrl url; if( !mySession ) // remote session url = myUrl; else { // local session url.setScheme( "http" ); url.setHost( "localhost" ); url.setPort( myPrefs.getInt( Prefs::RPC_PORT ) ); } QDesktopServices :: openUrl( url ); }