source: branches/2.0x/qt/session.cc @ 11108

Last change on this file since 11108 was 11108, checked in by charles, 12 years ago

(2.0x qt) #3481 "crash when accessing a remote session that's password protected" -- fixed

  • Property svn:keywords set to Date Rev Author Id
File size: 29.8 KB
Line 
1/*
2 * This file Copyright (C) 2009-2010 Mnemosyne LLC
3 *
4 * This file is licensed by the GPL version 2.  Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: session.cc 11108 2010-08-04 13:56:51Z charles $
11 */
12
13#include <cassert>
14#include <iostream>
15
16#include <QApplication>
17#include <QByteArray>
18#include <QClipboard>
19#include <QCoreApplication>
20#include <QDesktopServices>
21#include <QMessageBox>
22#include <QNetworkReply>
23#include <QNetworkRequest>
24#include <QSet>
25#include <QStyle>
26#include <QTextStream>
27
28#include <libtransmission/transmission.h>
29#include <libtransmission/bencode.h>
30#include <libtransmission/json.h>
31#include <libtransmission/rpcimpl.h>
32#include <libtransmission/utils.h> /* tr_free */
33#include <libtransmission/version.h> /* LONG_VERSION */
34
35#include "prefs.h"
36#include "qticonloader.h"
37#include "session.h"
38#include "session-dialog.h"
39#include "torrent.h"
40#include "utils.h"
41
42// #define DEBUG_HTTP
43
44namespace
45{
46    enum
47    {
48        TAG_SOME_TORRENTS,
49        TAG_ALL_TORRENTS,
50        TAG_SESSION_STATS,
51        TAG_SESSION_INFO,
52        TAG_BLOCKLIST_UPDATE,
53        TAG_ADD_TORRENT,
54        TAG_PORT_TEST,
55        TAG_MAGNET_LINK,
56
57        FIRST_UNIQUE_TAG
58    };
59}
60
61/***
62****
63***/
64
65namespace
66{
67    typedef Torrent::KeyList KeyList;
68    const KeyList& getInfoKeys( ) { return Torrent::getInfoKeys( ); }
69    const KeyList& getStatKeys( ) { return Torrent::getStatKeys( ); }
70    const KeyList& getExtraStatKeys( ) { return Torrent::getExtraStatKeys( ); }
71
72    void
73    addList( tr_benc * list, const KeyList& strings )
74    {
75        tr_bencListReserve( list, strings.size( ) );
76        foreach( const char * str, strings )
77            tr_bencListAddStr( list, str );
78    }
79}
80
81/***
82****
83***/
84
85void
86Session :: sessionSet( const char * key, const QVariant& value )
87{
88    tr_benc top;
89    tr_bencInitDict( &top, 2 );
90    tr_bencDictAddStr( &top, "method", "session-set" );
91    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 1 ) );
92    switch( value.type( ) ) {
93        case QVariant::Bool:   tr_bencDictAddBool ( args, key, value.toBool() ); break;
94        case QVariant::Int:    tr_bencDictAddInt  ( args, key, value.toInt() ); break;
95        case QVariant::Double: tr_bencDictAddReal ( args, key, value.toDouble() ); break;
96        case QVariant::String: tr_bencDictAddStr  ( args, key, value.toString().toUtf8() ); break;
97        default: assert( "unknown type" );
98    }
99    exec( &top );
100    tr_bencFree( &top );
101}
102
103void
104Session :: portTest( )
105{
106    tr_benc top;
107    tr_bencInitDict( &top, 2 );
108    tr_bencDictAddStr( &top, "method", "port-test" );
109    tr_bencDictAddInt( &top, "tag", TAG_PORT_TEST );
110    exec( &top );
111    tr_bencFree( &top );
112}
113
114void
115Session :: copyMagnetLinkToClipboard( int torrentId )
116{
117    tr_benc top;
118    tr_bencInitDict( &top, 3 );
119    tr_bencDictAddStr( &top, "method", "torrent-get" );
120    tr_bencDictAddInt( &top, "tag", TAG_MAGNET_LINK );
121    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
122    tr_bencListAddInt( tr_bencDictAddList( args, "ids", 1 ), torrentId );
123    tr_bencListAddStr( tr_bencDictAddList( args, "fields", 1 ), "magnetLink" );
124
125    exec( &top );
126    tr_bencFree( &top );
127}
128
129void
130Session :: updatePref( int key )
131{
132    if( myPrefs.isCore( key ) ) switch( key )
133    {
134        case Prefs :: ALT_SPEED_LIMIT_DOWN:
135        case Prefs :: ALT_SPEED_LIMIT_ENABLED:
136        case Prefs :: ALT_SPEED_LIMIT_TIME_BEGIN:
137        case Prefs :: ALT_SPEED_LIMIT_TIME_DAY:
138        case Prefs :: ALT_SPEED_LIMIT_TIME_ENABLED:
139        case Prefs :: ALT_SPEED_LIMIT_TIME_END:
140        case Prefs :: ALT_SPEED_LIMIT_UP:
141        case Prefs :: BLOCKLIST_DATE:
142        case Prefs :: BLOCKLIST_ENABLED:
143        case Prefs :: DHT_ENABLED:
144        case Prefs :: DOWNLOAD_DIR:
145        case Prefs :: DSPEED:
146        case Prefs :: DSPEED_ENABLED:
147        case Prefs :: INCOMPLETE_DIR:
148        case Prefs :: INCOMPLETE_DIR_ENABLED:
149        case Prefs :: LPD_ENABLED:
150        case Prefs :: PEER_LIMIT_GLOBAL:
151        case Prefs :: PEER_LIMIT_TORRENT:
152        case Prefs :: PEER_PORT:
153        case Prefs :: PEER_PORT_RANDOM_ON_START:
154        case Prefs :: PEX_ENABLED:
155        case Prefs :: PORT_FORWARDING:
156        case Prefs :: SCRIPT_TORRENT_DONE_ENABLED:
157        case Prefs :: SCRIPT_TORRENT_DONE_FILENAME:
158        case Prefs :: START:
159        case Prefs :: TRASH_ORIGINAL:
160        case Prefs :: USPEED:
161        case Prefs :: USPEED_ENABLED:
162            sessionSet( myPrefs.keyStr(key), myPrefs.variant(key) );
163            break;
164
165        case Prefs :: RATIO:
166            sessionSet( "seedRatioLimit", myPrefs.variant(key) );
167            break;
168        case Prefs :: RATIO_ENABLED:
169            sessionSet( "seedRatioLimited", myPrefs.variant(key) );
170            break;
171
172        case Prefs :: ENCRYPTION:
173            {
174                const int i = myPrefs.variant(key).toInt();
175                switch( i )
176                {
177                    case 0:
178                        sessionSet( myPrefs.keyStr(key), "tolerated" );
179                        break;
180                    case 1:
181                        sessionSet( myPrefs.keyStr(key), "preferred" );
182                        break;
183                    case 2:
184                        sessionSet( myPrefs.keyStr(key), "required" );
185                        break;
186                }
187                break;
188            }
189
190        case Prefs :: RPC_AUTH_REQUIRED:
191            if( mySession )
192                tr_sessionSetRPCEnabled( mySession, myPrefs.getBool(key) );
193            break;
194        case Prefs :: RPC_ENABLED:
195            if( mySession )
196                tr_sessionSetRPCEnabled( mySession, myPrefs.getBool(key) );
197            break;
198        case Prefs :: RPC_PASSWORD:
199            if( mySession )
200                tr_sessionSetRPCPassword( mySession, myPrefs.getString(key).toUtf8().constData() );
201            break;
202        case Prefs :: RPC_PORT:
203            if( mySession )
204                tr_sessionSetRPCPort( mySession, myPrefs.getInt(key) );
205            break;
206        case Prefs :: RPC_USERNAME:
207            if( mySession )
208                tr_sessionSetRPCUsername( mySession, myPrefs.getString(key).toUtf8().constData() );
209            break;
210        case Prefs :: RPC_WHITELIST_ENABLED:
211            if( mySession )
212                tr_sessionSetRPCWhitelistEnabled( mySession, myPrefs.getBool(key) );
213            break;
214        case Prefs :: RPC_WHITELIST:
215            if( mySession )
216                tr_sessionSetRPCWhitelist( mySession, myPrefs.getString(key).toUtf8().constData() );
217            break;
218
219        default:
220            std::cerr << "unhandled pref: " << key << std::endl;
221    }
222}
223
224/***
225****
226***/
227
228Session :: Session( const char * configDir, Prefs& prefs ):
229    nextUniqueTag( FIRST_UNIQUE_TAG ),
230    myBlocklistSize( -1 ),
231    myPrefs( prefs ),
232    mySession( 0 ),
233    myConfigDir( configDir ),
234    myNAM( 0 )
235{
236    myStats.ratio = TR_RATIO_NA;
237    myStats.uploadedBytes = 0;
238    myStats.downloadedBytes = 0;
239    myStats.filesAdded = 0;
240    myStats.sessionCount = 0;
241    myStats.secondsActive = 0;
242    myCumulativeStats = myStats;
243
244    connect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) );
245}
246
247Session :: ~Session( )
248{
249    stop( );
250}
251
252QNetworkAccessManager *
253Session :: networkAccessManager( )
254{
255    if( myNAM == 0 )
256    {
257        myNAM = new QNetworkAccessManager;
258
259        connect( myNAM, SIGNAL(finished(QNetworkReply*)),
260                 this, SLOT(onFinished(QNetworkReply*)) );
261
262        connect( myNAM, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)),
263                 this, SIGNAL(httpAuthenticationRequired()) );
264    }
265
266    return myNAM;
267}
268
269/***
270****
271***/
272
273void
274Session :: stop( )
275{
276    if( myNAM != 0 )
277    {
278        myNAM->deleteLater( );
279        myNAM = 0;
280    }
281
282    myUrl.clear( );
283
284    if( mySession )
285    {
286        tr_sessionClose( mySession );
287        mySession = 0;
288    }
289}
290
291void
292Session :: restart( )
293{
294    stop( );
295    start( );
296}
297
298void
299Session :: start( )
300{
301    if( myPrefs.get<bool>(Prefs::SESSION_IS_REMOTE) )
302    {
303        QUrl url;
304        url.setScheme( "http" );
305        url.setHost( myPrefs.get<QString>(Prefs::SESSION_REMOTE_HOST) );
306        url.setPort( myPrefs.get<int>(Prefs::SESSION_REMOTE_PORT) );
307        url.setPath( "/transmission/rpc" );
308        if( myPrefs.get<bool>(Prefs::SESSION_REMOTE_AUTH) )
309        {
310            url.setUserName( myPrefs.get<QString>(Prefs::SESSION_REMOTE_USERNAME) );
311            url.setPassword( myPrefs.get<QString>(Prefs::SESSION_REMOTE_PASSWORD) );
312        }
313        myUrl = url;
314    }
315    else
316    {
317        tr_benc settings;
318        tr_bencInitDict( &settings, 0 );
319        tr_sessionLoadSettings( &settings, myConfigDir.toUtf8().constData(), "qt" );
320        mySession = tr_sessionInit( "qt", myConfigDir.toUtf8().constData(), true, &settings );
321        tr_bencFree( &settings );
322
323        tr_ctor * ctor = tr_ctorNew( mySession );
324        int torrentCount;
325        tr_torrent ** torrents = tr_sessionLoadTorrents( mySession, ctor, &torrentCount );
326        tr_free( torrents );
327        tr_ctorFree( ctor );
328    }
329
330    emit sourceChanged( );
331}
332
333bool
334Session :: isServer( ) const
335{
336    return mySession != 0;
337}
338
339bool
340Session :: isLocal( ) const
341{
342    if( mySession != 0 )
343        return true;
344
345    if( myUrl.host() == "127.0.0.1" )
346        return true;
347
348    if( !myUrl.host().compare( "localhost", Qt::CaseInsensitive ) )
349        return true;
350
351    return false;
352}
353
354/***
355****
356***/
357
358namespace
359{
360    tr_benc *
361    buildRequest( const char * method, tr_benc& top, int tag=-1 )
362    {
363        tr_bencInitDict( &top, 3 );
364        tr_bencDictAddStr( &top, "method", method );
365        if( tag >= 0 )
366            tr_bencDictAddInt( &top, "tag", tag );
367        return tr_bencDictAddDict( &top, "arguments", 0 );
368    }
369
370    void
371    addOptionalIds( tr_benc * args, const QSet<int>& ids )
372    {
373        if( !ids.isEmpty( ) )
374        {
375            tr_benc * idList( tr_bencDictAddList( args, "ids", ids.size( ) ) );
376            foreach( int i, ids )
377                tr_bencListAddInt( idList, i );
378        }
379    }
380}
381
382void
383Session :: torrentSet( const QSet<int>& ids, const QString& key, double value )
384{
385    tr_benc top;
386    tr_bencInitDict( &top, 2 );
387    tr_bencDictAddStr( &top, "method", "torrent-set" );
388    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
389    tr_bencDictAddReal( args, key.toUtf8().constData(), value );
390    addOptionalIds( args, ids );
391    exec( &top );
392    tr_bencFree( &top );
393}
394
395void
396Session :: torrentSet( const QSet<int>& ids, const QString& key, int value )
397{
398    tr_benc top;
399    tr_bencInitDict( &top, 2 );
400    tr_bencDictAddStr( &top, "method", "torrent-set" );
401    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
402    tr_bencDictAddInt( args, key.toUtf8().constData(), value );
403    addOptionalIds( args, ids );
404    exec( &top );
405    tr_bencFree( &top );
406}
407
408void
409Session :: torrentSet( const QSet<int>& ids, const QString& key, bool value )
410{
411    tr_benc top;
412    tr_bencInitDict( &top, 2 );
413    tr_bencDictAddStr( &top, "method", "torrent-set" );
414    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
415    tr_bencDictAddBool( args, key.toUtf8().constData(), value );
416    addOptionalIds( args, ids );
417    exec( &top );
418    tr_bencFree( &top );
419}
420
421void
422Session :: torrentSet( const QSet<int>& ids, const QString& key, const QList<int>& value )
423{
424    tr_benc top;
425    tr_bencInitDict( &top, 2 );
426    tr_bencDictAddStr( &top, "method", "torrent-set" );
427    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
428    addOptionalIds( args, ids );
429    tr_benc * list( tr_bencDictAddList( args, key.toUtf8().constData(), value.size( ) ) );
430    foreach( int i, value )
431        tr_bencListAddInt( list, i );
432    exec( &top );
433    tr_bencFree( &top );
434}
435
436void
437Session :: torrentSetLocation( const QSet<int>& ids, const QString& location, bool doMove )
438{
439    tr_benc top;
440    tr_bencInitDict( &top, 2 );
441    tr_bencDictAddStr( &top, "method", "torrent-set-location" );
442    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 3 ) );
443    addOptionalIds( args, ids );
444    tr_bencDictAddStr( args, "location", location.toUtf8().constData() );
445    tr_bencDictAddBool( args, "move", doMove );
446    exec( &top );
447    tr_bencFree( &top );
448}
449
450void
451Session :: refreshTorrents( const QSet<int>& ids )
452{
453    if( ids.empty( ) )
454    {
455        refreshAllTorrents( );
456    }
457    else
458    {
459        tr_benc top;
460        tr_bencInitDict( &top, 3 );
461        tr_bencDictAddStr( &top, "method", "torrent-get" );
462        tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
463        tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
464        addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
465        addOptionalIds( args, ids );
466        exec( &top );
467        tr_bencFree( &top );
468    }
469}
470
471void
472Session :: refreshExtraStats( const QSet<int>& ids )
473{
474    tr_benc top;
475    tr_bencInitDict( &top, 3 );
476    tr_bencDictAddStr( &top, "method", "torrent-get" );
477    tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
478    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
479    addOptionalIds( args, ids );
480    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) + getExtraStatKeys( ));
481    exec( &top );
482    tr_bencFree( &top );
483}
484
485void
486Session :: sendTorrentRequest( const char * request, const QSet<int>& ids )
487{
488    tr_benc top;
489    tr_benc * args( buildRequest( request, top ) );
490    addOptionalIds( args, ids );
491    exec( &top );
492    tr_bencFree( &top );
493
494    refreshTorrents( ids );
495}
496
497void
498Session :: pauseTorrents( const QSet<int>& ids )
499{
500    sendTorrentRequest( "torrent-stop", ids );
501}
502
503void
504Session :: startTorrents( const QSet<int>& ids )
505{
506    sendTorrentRequest( "torrent-start", ids );
507}
508
509void
510Session :: refreshActiveTorrents( )
511{
512    tr_benc top;
513    tr_bencInitDict( &top, 3 );
514    tr_bencDictAddStr( &top, "method", "torrent-get" );
515    tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
516    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
517    tr_bencDictAddStr( args, "ids", "recently-active" );
518    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
519    exec( &top );
520    tr_bencFree( &top );
521}
522
523void
524Session :: refreshAllTorrents( )
525{
526    tr_benc top;
527    tr_bencInitDict( &top, 3 );
528    tr_bencDictAddStr( &top, "method", "torrent-get" );
529    tr_bencDictAddInt( &top, "tag", TAG_ALL_TORRENTS );
530    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 1 ) );
531    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
532    exec( &top );
533    tr_bencFree( &top );
534}
535
536void
537Session :: initTorrents( const QSet<int>& ids )
538{
539    tr_benc top;
540    const int tag( ids.isEmpty() ? TAG_ALL_TORRENTS : TAG_SOME_TORRENTS );
541    tr_benc * args( buildRequest( "torrent-get", top, tag ) );
542    addOptionalIds( args, ids );
543    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys()+getInfoKeys() );
544    exec( &top );
545    tr_bencFree( &top );
546}
547
548void
549Session :: refreshSessionStats( )
550{
551    tr_benc top;
552    tr_bencInitDict( &top, 2 );
553    tr_bencDictAddStr( &top, "method", "session-stats" );
554    tr_bencDictAddInt( &top, "tag", TAG_SESSION_STATS );
555    exec( &top );
556    tr_bencFree( &top );
557}
558
559void
560Session :: refreshSessionInfo( )
561{
562    tr_benc top;
563    tr_bencInitDict( &top, 2 );
564    tr_bencDictAddStr( &top, "method", "session-get" );
565    tr_bencDictAddInt( &top, "tag", TAG_SESSION_INFO );
566    exec( &top );
567    tr_bencFree( &top );
568}
569
570void
571Session :: updateBlocklist( )
572{
573    tr_benc top;
574    tr_bencInitDict( &top, 2 );
575    tr_bencDictAddStr( &top, "method", "blocklist-update" );
576    tr_bencDictAddInt( &top, "tag", TAG_BLOCKLIST_UPDATE );
577    exec( &top );
578    tr_bencFree( &top );
579}
580
581/***
582****
583***/
584
585void
586Session :: exec( const tr_benc * request )
587{
588    char * str = tr_bencToStr( request, TR_FMT_JSON_LEAN, NULL );
589    exec( str );
590    tr_free( str );
591}
592
593void
594Session :: localSessionCallback( tr_session * session, const char * json, size_t len, void * self )
595{
596    Q_UNUSED( session );
597
598    ((Session*)self)->parseResponse( json, len );
599}
600
601#define REQUEST_DATA_PROPERTY_KEY "requestData"
602
603void
604Session :: exec( const char * json )
605{
606    if( mySession  )
607    {
608        tr_rpc_request_exec_json( mySession, json, strlen( json ), localSessionCallback, this );
609    }
610    else if( !myUrl.isEmpty( ) )
611    {
612        QNetworkRequest request;
613        request.setUrl( myUrl );
614        request.setRawHeader( "User-Agent", QString( QCoreApplication::instance()->applicationName() + "/" + LONG_VERSION_STRING ).toAscii() );
615        request.setRawHeader( "Content-Type", "application/json; charset=UTF-8" );
616        if( !mySessionId.isEmpty( ) )
617            request.setRawHeader( TR_RPC_SESSION_ID_HEADER, mySessionId.toAscii() );
618
619        const QByteArray requestData( json );
620        QNetworkReply * reply = networkAccessManager()->post( request, requestData );
621        reply->setProperty( REQUEST_DATA_PROPERTY_KEY, requestData );
622        connect( reply, SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(dataReadProgress()));
623        connect( reply, SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(dataSendProgress()));
624
625#ifdef DEBUG_HTTP
626        std::cerr << "sending " << "POST " << qPrintable( myUrl.path() ) << std::endl;
627        foreach( QByteArray b, request.rawHeaderList() )
628            std::cerr << b.constData()
629                      << ": "
630                      << request.rawHeader( b ).constData()
631                      << std::endl;
632        std::cerr << "Body:\n" << json << std::endl;
633#endif
634    }
635}
636
637void
638Session :: onFinished( QNetworkReply * reply )
639{
640#ifdef DEBUG_HTTP
641    std::cerr << "http response header: " << std::endl;
642    foreach( QByteArray b, reply->rawHeaderList() )
643        std::cerr << b.constData()
644                  << ": "
645                  << reply->rawHeader( b ).constData()
646                  << std::endl;
647    std::cerr << "json:\n" << reply->peek( reply->bytesAvailable() ).constData() << std::endl;
648#endif
649
650    if( ( reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ).toInt() == 409 )
651        && ( reply->hasRawHeader( TR_RPC_SESSION_ID_HEADER ) ) )
652    {
653        // we got a 409 telling us our session id has expired.
654        // update it and resubmit the request.
655        mySessionId = QString( reply->rawHeader( TR_RPC_SESSION_ID_HEADER ) );
656        exec( reply->property( REQUEST_DATA_PROPERTY_KEY ).toByteArray( ).constData( ) );
657    }
658    else if( reply->error() != QNetworkReply::NoError )
659    {
660        std::cerr << "http error: " << qPrintable( reply->errorString() ) << std::endl;
661    }
662    else
663    {
664        const QByteArray response( reply->readAll() );
665        const char * json( response.constData( ) );
666        int jsonLength( response.size( ) );
667        if( jsonLength>0 && json[jsonLength-1] == '\n' ) --jsonLength;
668        parseResponse( json, jsonLength );
669    }
670
671    reply->deleteLater();
672}
673
674void
675Session :: parseResponse( const char * json, size_t jsonLength )
676{
677    tr_benc top;
678    const uint8_t * end( 0 );
679    const int err( tr_jsonParse( "rpc", json, jsonLength, &top, &end ) );
680    if( !err )
681    {
682        int64_t tag = -1;
683        const char * result = NULL;
684        tr_benc * args = NULL;
685
686        tr_bencDictFindInt ( &top, "tag", &tag );
687        tr_bencDictFindStr ( &top, "result", &result );
688        tr_bencDictFindDict( &top, "arguments", &args );
689
690        emit executed( tag, result, args );
691
692        tr_benc * torrents;
693        const char * str;
694
695        if( tr_bencDictFindInt( &top, "tag", &tag ) )
696        {
697            switch( tag )
698            {
699                case TAG_SOME_TORRENTS:
700                case TAG_ALL_TORRENTS:
701                    if( tr_bencDictFindDict( &top, "arguments", &args ) ) {
702                        if( tr_bencDictFindList( args, "torrents", &torrents ) )
703                            emit torrentsUpdated( torrents, tag==TAG_ALL_TORRENTS );
704                        if( tr_bencDictFindList( args, "removed", &torrents ) )
705                            emit torrentsRemoved( torrents );
706                    }
707                    break;
708
709                case TAG_SESSION_STATS:
710                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
711                        updateStats( args );
712                    break;
713
714                case TAG_SESSION_INFO:
715                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
716                        updateInfo( args );
717                    break;
718
719                case TAG_BLOCKLIST_UPDATE: {
720                    int64_t intVal = 0;
721                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
722                        if( tr_bencDictFindInt( args, "blocklist-size", &intVal ) )
723                            setBlocklistSize( intVal );
724                    break;
725                }
726
727                case TAG_PORT_TEST: {
728                    tr_bool isOpen = 0;
729                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
730                        tr_bencDictFindBool( args, "port-is-open", &isOpen );
731                    emit portTested( (bool)isOpen );
732                }
733
734                case TAG_MAGNET_LINK: {
735                    tr_benc * args;
736                    tr_benc * torrents;
737                    tr_benc * child;
738                    const char * str;
739                    if( tr_bencDictFindDict( &top, "arguments", &args )
740                        && tr_bencDictFindList( args, "torrents", &torrents )
741                        && (( child = tr_bencListChild( torrents, 0 )))
742                        && tr_bencDictFindStr( child, "magnetLink", &str ) )
743                            QApplication::clipboard()->setText( str );
744                    break;
745                }
746
747                case TAG_ADD_TORRENT:
748                    str = "";
749                    if( tr_bencDictFindStr( &top, "result", &str ) && strcmp( str, "success" ) ) {
750                        QMessageBox * d = new QMessageBox( QMessageBox::Information,
751                                                           tr( "Add Torrent" ),
752                                                           QString::fromUtf8(str),
753                                                           QMessageBox::Close,
754                                                           QApplication::activeWindow());
755                        QPixmap pixmap;
756                        QIcon icon = QtIconLoader :: icon( "dialog-information" );
757                        if( !icon.isNull( ) ) {
758                            const int size = QApplication::style()->pixelMetric( QStyle::PM_LargeIconSize );
759                            d->setIconPixmap( icon.pixmap( size, size ) );
760                        }
761                        connect( d, SIGNAL(rejected()), d, SLOT(deleteLater()) );
762                        d->show( );
763                    }
764                    break;
765
766                default:
767                    break;
768            }
769        }
770        tr_bencFree( &top );
771    }
772}
773
774void
775Session :: updateStats( tr_benc * d, struct tr_session_stats * stats )
776{
777    int64_t i;
778
779    if( tr_bencDictFindInt( d, "uploadedBytes", &i ) )
780        stats->uploadedBytes = i;
781    if( tr_bencDictFindInt( d, "downloadedBytes", &i ) )
782        stats->downloadedBytes = i;
783    if( tr_bencDictFindInt( d, "filesAdded", &i ) )
784        stats->filesAdded = i;
785    if( tr_bencDictFindInt( d, "sessionCount", &i ) )
786        stats->sessionCount = i;
787    if( tr_bencDictFindInt( d, "secondsActive", &i ) )
788        stats->secondsActive = i;
789
790    stats->ratio = tr_getRatio( stats->uploadedBytes, stats->downloadedBytes );
791
792}
793
794void
795Session :: updateStats( tr_benc * d )
796{
797    tr_benc * c;
798
799    if( tr_bencDictFindDict( d, "current-stats", &c ) )
800        updateStats( c, &myStats );
801
802    if( tr_bencDictFindDict( d, "cumulative-stats", &c ) )
803        updateStats( c, &myCumulativeStats );
804
805    emit statsUpdated( );
806}
807
808void
809Session :: updateInfo( tr_benc * d )
810{
811    int64_t i;
812    const char * str;
813    disconnect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) );
814
815    for( int i=Prefs::FIRST_CORE_PREF; i<=Prefs::LAST_CORE_PREF; ++i )
816    {
817        const tr_benc * b( tr_bencDictFind( d, myPrefs.keyStr( i ) ) );
818
819        if( !b )
820            continue;
821
822        if( i == Prefs :: ENCRYPTION )
823        {
824            const char * val;
825            if( tr_bencGetStr( b, &val ) )
826            {
827                if( !qstrcmp( val , "required" ) )
828                    myPrefs.set( i, 2 );
829                else if( !qstrcmp( val , "preferred" ) )
830                    myPrefs.set( i, 1 );
831                else if( !qstrcmp( val , "tolerated" ) )
832                    myPrefs.set( i, 0 );
833            }
834            continue;
835        }
836
837        switch( myPrefs.type( i ) )
838        {
839            case QVariant :: Int: {
840                int64_t val;
841                if( tr_bencGetInt( b, &val ) )
842                    myPrefs.set( i, (int)val );
843                break;
844            }
845            case QVariant :: Double: {
846                double val;
847                if( tr_bencGetReal( b, &val ) )
848                    myPrefs.set( i, val );
849                break;
850            }
851            case QVariant :: Bool: {
852                tr_bool val;
853                if( tr_bencGetBool( b, &val ) )
854                    myPrefs.set( i, (bool)val );
855                break;
856            }
857            case TrTypes :: FilterModeType:
858            case TrTypes :: SortModeType:
859            case QVariant :: String: {
860                const char * val;
861                if( tr_bencGetStr( b, &val ) )
862                    myPrefs.set( i, QString(val) );
863                break;
864            }
865            default:
866                break;
867        }
868    }
869
870    tr_bool b;
871    double x;
872    if( tr_bencDictFindBool( d, "seedRatioLimited", &b ) )
873        myPrefs.set( Prefs::RATIO_ENABLED, b ? true : false );
874    if( tr_bencDictFindReal( d, "seedRatioLimit", &x ) )
875        myPrefs.set( Prefs::RATIO, x );
876
877    /* Use the C API to get settings that, for security reasons, aren't supported by RPC */
878    if( mySession != 0 )
879    {
880        myPrefs.set( Prefs::RPC_ENABLED,           tr_sessionIsRPCEnabled           ( mySession ) );
881        myPrefs.set( Prefs::RPC_AUTH_REQUIRED,     tr_sessionIsRPCPasswordEnabled   ( mySession ) );
882        myPrefs.set( Prefs::RPC_PASSWORD,          tr_sessionGetRPCPassword         ( mySession ) );
883        myPrefs.set( Prefs::RPC_PORT,              tr_sessionGetRPCPort             ( mySession ) );
884        myPrefs.set( Prefs::RPC_USERNAME,          tr_sessionGetRPCUsername         ( mySession ) );
885        myPrefs.set( Prefs::RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled ( mySession ) );
886        myPrefs.set( Prefs::RPC_WHITELIST,         tr_sessionGetRPCWhitelist        ( mySession ) );
887    }
888
889    if( tr_bencDictFindInt( d, "blocklist-size", &i ) && i!=blocklistSize( ) )
890        setBlocklistSize( i );
891
892    if( tr_bencDictFindStr( d, "version", &str ) && ( mySessionVersion != str ) )
893        mySessionVersion = str;
894
895    //std::cerr << "Session :: updateInfo end" << std::endl;
896    connect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) );
897
898    emit sessionUpdated( );
899}
900
901void
902Session :: setBlocklistSize( int64_t i )
903{
904    myBlocklistSize = i;
905
906    emit blocklistUpdated( i );
907}
908
909void
910Session :: addTorrent( QString filename )
911{
912    addTorrent( filename, myPrefs.getString( Prefs::DOWNLOAD_DIR ) );
913}
914
915namespace
916{
917    bool isLink( const QString& str )
918    {
919        return Utils::isMagnetLink(str) || Utils::isURL(str);
920    }
921}
922
923void
924Session :: addTorrent( QString key, QString localPath )
925{
926    tr_benc top, *args;
927    tr_bencInitDict( &top, 2 );
928    tr_bencDictAddStr( &top, "method", "torrent-add" );
929    args = tr_bencDictAddDict( &top, "arguments", 3 );
930    tr_bencDictAddStr( args, "download-dir", qPrintable(localPath) );
931    tr_bencDictAddBool( args, "paused", !myPrefs.getBool( Prefs::START ) );
932
933    // figure out what to do with "key"....
934    bool keyHandled = false;
935    if( !keyHandled && isLink( key  )) {
936        tr_bencDictAddStr( args, "filename", key.toUtf8().constData() );
937        keyHandled = true; // it's a URL or magnet link...
938    }
939    if( !keyHandled ) {
940        QFile file( key );
941        file.open( QIODevice::ReadOnly );
942        const QByteArray raw( file.readAll( ) );
943        file.close( );
944        if( !raw.isEmpty( ) ) {
945            int b64len = 0;
946            char * b64 = tr_base64_encode( raw.constData(), raw.size(), &b64len );
947            tr_bencDictAddRaw( args, "metainfo", b64, b64len  );
948            tr_free( b64 );
949            keyHandled = true; // it's a local file...
950        }
951    }
952    if( !keyHandled ) {
953        const QByteArray tmp = key.toUtf8();
954        tr_bencDictAddRaw( args, "metainfo", tmp.constData(), tmp.length() );
955        keyHandled = true; // treat it as base64
956    }
957
958    exec( &top );
959    tr_bencFree( &top );
960}
961
962void
963Session :: removeTorrents( const QSet<int>& ids, bool deleteFiles )
964{
965    if( !ids.isEmpty( ) )
966    {
967        tr_benc top, *args;
968        tr_bencInitDict( &top, 2 );
969        tr_bencDictAddStr( &top, "method", "torrent-remove" );
970        args = tr_bencDictAddDict( &top, "arguments", 2 );
971        addOptionalIds( args, ids );
972        tr_bencDictAddInt( args, "delete-local-data", deleteFiles );
973        exec( &top );
974        tr_bencFree( &top );
975    }
976}
977
978void
979Session :: verifyTorrents( const QSet<int>& ids )
980{
981    if( !ids.isEmpty( ) )
982    {
983        tr_benc top, *args;
984        tr_bencInitDict( &top, 2 );
985        tr_bencDictAddStr( &top, "method", "torrent-verify" );
986        args = tr_bencDictAddDict( &top, "arguments", 1 );
987        addOptionalIds( args, ids );
988        exec( &top );
989        tr_bencFree( &top );
990    }
991}
992
993void
994Session :: reannounceTorrents( const QSet<int>& ids )
995{
996    if( !ids.isEmpty( ) )
997    {
998        tr_benc top, *args;
999        tr_bencInitDict( &top, 2 );
1000        tr_bencDictAddStr( &top, "method", "torrent-reannounce" );
1001        args = tr_bencDictAddDict( &top, "arguments", 1 );
1002        addOptionalIds( args, ids );
1003        exec( &top );
1004        tr_bencFree( &top );
1005    }
1006}
1007
1008/***
1009****
1010***/
1011
1012void
1013Session :: launchWebInterface( )
1014{
1015    QUrl url;
1016    if( !mySession ) // remote session
1017        url = myUrl;
1018    else { // local session
1019        url.setScheme( "http" );
1020        url.setHost( "localhost" );
1021        url.setPort( myPrefs.getInt( Prefs::RPC_PORT ) );
1022    }
1023    QDesktopServices :: openUrl( url );
1024}
Note: See TracBrowser for help on using the repository browser.