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

Last change on this file since 10868 was 10868, checked in by Longinus00, 12 years ago

(2.0x qt) #3299:Enabled setting encryption preference

  • Property svn:keywords set to Date Rev Author Id
File size: 30.0 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 10868 2010-06-26 17:16:46Z Longinus00 $
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{
235    myStats.ratio = TR_RATIO_NA;
236    myStats.uploadedBytes = 0;
237    myStats.downloadedBytes = 0;
238    myStats.filesAdded = 0;
239    myStats.sessionCount = 0;
240    myStats.secondsActive = 0;
241    myCumulativeStats = myStats;
242
243    connect( &myNAM, SIGNAL(finished(QNetworkReply*)), this, SLOT(onFinished(QNetworkReply*)) );
244    connect( &myNAM, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)), this, SIGNAL(httpAuthenticationRequired()) );
245    connect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) );
246}
247
248Session :: ~Session( )
249{
250    stop( );
251}
252
253/***
254****
255***/
256
257void
258Session :: stop( )
259{
260    foreach( Reply myReply, myReplies )
261        myReply.networkReply->abort();
262    myUrl.clear( );
263
264    if( mySession )
265    {
266        tr_sessionClose( mySession );
267        mySession = 0;
268    }
269}
270
271void
272Session :: restart( )
273{
274    stop( );
275    start( );
276}
277
278void
279Session :: start( )
280{
281    if( myPrefs.get<bool>(Prefs::SESSION_IS_REMOTE) )
282    {
283        const int port( myPrefs.get<int>(Prefs::SESSION_REMOTE_PORT) );
284        const bool auth( myPrefs.get<bool>(Prefs::SESSION_REMOTE_AUTH) );
285        const QString host( myPrefs.get<QString>(Prefs::SESSION_REMOTE_HOST) );
286        const QString user( myPrefs.get<QString>(Prefs::SESSION_REMOTE_USERNAME) );
287        const QString pass( myPrefs.get<QString>(Prefs::SESSION_REMOTE_PASSWORD) );
288
289        QUrl url;
290        url.setScheme( "http" );
291        url.setHost( host );
292        url.setPort( port );
293        url.setPath( "/transmission/rpc" );
294        if( auth ) {
295            url.setUserName( user );
296            url.setPassword( pass );
297        }
298        myUrl = url;
299    }
300    else
301    {
302        tr_benc settings;
303        tr_bencInitDict( &settings, 0 );
304        tr_sessionLoadSettings( &settings, myConfigDir.toUtf8().constData(), "qt" );
305        mySession = tr_sessionInit( "qt", myConfigDir.toUtf8().constData(), true, &settings );
306        tr_bencFree( &settings );
307
308        tr_ctor * ctor = tr_ctorNew( mySession );
309        int torrentCount;
310        tr_torrent ** torrents = tr_sessionLoadTorrents( mySession, ctor, &torrentCount );
311        tr_free( torrents );
312        tr_ctorFree( ctor );
313    }
314
315    emit sourceChanged( );
316}
317
318bool
319Session :: isServer( ) const
320{
321    return mySession != 0;
322}
323
324bool
325Session :: isLocal( ) const
326{
327    if( mySession != 0 )
328        return true;
329
330    if( myUrl.host() == "127.0.0.1" )
331        return true;
332
333    if( !myUrl.host().compare( "localhost", Qt::CaseInsensitive ) )
334        return true;
335
336    return false;
337}
338
339/***
340****
341***/
342
343namespace
344{
345    tr_benc *
346    buildRequest( const char * method, tr_benc& top, int tag=-1 )
347    {
348        tr_bencInitDict( &top, 3 );
349        tr_bencDictAddStr( &top, "method", method );
350        if( tag >= 0 )
351            tr_bencDictAddInt( &top, "tag", tag );
352        return tr_bencDictAddDict( &top, "arguments", 0 );
353    }
354
355    void
356    addOptionalIds( tr_benc * args, const QSet<int>& ids )
357    {
358        if( !ids.isEmpty( ) )
359        {
360            tr_benc * idList( tr_bencDictAddList( args, "ids", ids.size( ) ) );
361            foreach( int i, ids )
362                tr_bencListAddInt( idList, i );
363        }
364    }
365}
366
367void
368Session :: torrentSet( const QSet<int>& ids, const QString& key, double value )
369{
370    tr_benc top;
371    tr_bencInitDict( &top, 2 );
372    tr_bencDictAddStr( &top, "method", "torrent-set" );
373    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
374    tr_bencDictAddReal( args, key.toUtf8().constData(), value );
375    addOptionalIds( args, ids );
376    exec( &top );
377    tr_bencFree( &top );
378}
379
380void
381Session :: torrentSet( const QSet<int>& ids, const QString& key, int value )
382{
383    tr_benc top;
384    tr_bencInitDict( &top, 2 );
385    tr_bencDictAddStr( &top, "method", "torrent-set" );
386    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
387    tr_bencDictAddInt( args, key.toUtf8().constData(), value );
388    addOptionalIds( args, ids );
389    exec( &top );
390    tr_bencFree( &top );
391}
392
393void
394Session :: torrentSet( const QSet<int>& ids, const QString& key, bool value )
395{
396    tr_benc top;
397    tr_bencInitDict( &top, 2 );
398    tr_bencDictAddStr( &top, "method", "torrent-set" );
399    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
400    tr_bencDictAddBool( args, key.toUtf8().constData(), value );
401    addOptionalIds( args, ids );
402    exec( &top );
403    tr_bencFree( &top );
404}
405
406void
407Session :: torrentSet( const QSet<int>& ids, const QString& key, const QList<int>& value )
408{
409    tr_benc top;
410    tr_bencInitDict( &top, 2 );
411    tr_bencDictAddStr( &top, "method", "torrent-set" );
412    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
413    addOptionalIds( args, ids );
414    tr_benc * list( tr_bencDictAddList( args, key.toUtf8().constData(), value.size( ) ) );
415    foreach( int i, value )
416        tr_bencListAddInt( list, i );
417    exec( &top );
418    tr_bencFree( &top );
419}
420
421void
422Session :: torrentSetLocation( const QSet<int>& ids, const QString& location, bool doMove )
423{
424    tr_benc top;
425    tr_bencInitDict( &top, 2 );
426    tr_bencDictAddStr( &top, "method", "torrent-set-location" );
427    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 3 ) );
428    addOptionalIds( args, ids );
429    tr_bencDictAddStr( args, "location", location.toUtf8().constData() );
430    tr_bencDictAddBool( args, "move", doMove );
431    exec( &top );
432    tr_bencFree( &top );
433}
434
435void
436Session :: refreshTorrents( const QSet<int>& ids )
437{
438    if( ids.empty( ) )
439    {
440        refreshAllTorrents( );
441    }
442    else
443    {
444        tr_benc top;
445        tr_bencInitDict( &top, 3 );
446        tr_bencDictAddStr( &top, "method", "torrent-get" );
447        tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
448        tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
449        addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
450        addOptionalIds( args, ids );
451        exec( &top );
452        tr_bencFree( &top );
453    }
454}
455
456void
457Session :: refreshExtraStats( const QSet<int>& ids )
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    addOptionalIds( args, ids );
465    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) + getExtraStatKeys( ));
466    exec( &top );
467    tr_bencFree( &top );
468}
469
470void
471Session :: sendTorrentRequest( const char * request, const QSet<int>& ids )
472{
473    tr_benc top;
474    tr_benc * args( buildRequest( request, top ) );
475    addOptionalIds( args, ids );
476    exec( &top );
477    tr_bencFree( &top );
478
479    refreshTorrents( ids );
480}
481
482void
483Session :: pauseTorrents( const QSet<int>& ids )
484{
485    sendTorrentRequest( "torrent-stop", ids );
486}
487
488void
489Session :: startTorrents( const QSet<int>& ids )
490{
491    sendTorrentRequest( "torrent-start", ids );
492}
493
494void
495Session :: refreshActiveTorrents( )
496{
497    tr_benc top;
498    tr_bencInitDict( &top, 3 );
499    tr_bencDictAddStr( &top, "method", "torrent-get" );
500    tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
501    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
502    tr_bencDictAddStr( args, "ids", "recently-active" );
503    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
504    exec( &top );
505    tr_bencFree( &top );
506}
507
508void
509Session :: refreshAllTorrents( )
510{
511    tr_benc top;
512    tr_bencInitDict( &top, 3 );
513    tr_bencDictAddStr( &top, "method", "torrent-get" );
514    tr_bencDictAddInt( &top, "tag", TAG_ALL_TORRENTS );
515    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 1 ) );
516    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
517    exec( &top );
518    tr_bencFree( &top );
519}
520
521void
522Session :: initTorrents( const QSet<int>& ids )
523{
524    tr_benc top;
525    const int tag( ids.isEmpty() ? TAG_ALL_TORRENTS : TAG_SOME_TORRENTS );
526    tr_benc * args( buildRequest( "torrent-get", top, tag ) );
527    addOptionalIds( args, ids );
528    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys()+getInfoKeys() );
529    exec( &top );
530    tr_bencFree( &top );
531}
532
533void
534Session :: refreshSessionStats( )
535{
536    tr_benc top;
537    tr_bencInitDict( &top, 2 );
538    tr_bencDictAddStr( &top, "method", "session-stats" );
539    tr_bencDictAddInt( &top, "tag", TAG_SESSION_STATS );
540    exec( &top );
541    tr_bencFree( &top );
542}
543
544void
545Session :: refreshSessionInfo( )
546{
547    tr_benc top;
548    tr_bencInitDict( &top, 2 );
549    tr_bencDictAddStr( &top, "method", "session-get" );
550    tr_bencDictAddInt( &top, "tag", TAG_SESSION_INFO );
551    exec( &top );
552    tr_bencFree( &top );
553}
554
555void
556Session :: updateBlocklist( )
557{
558    tr_benc top;
559    tr_bencInitDict( &top, 2 );
560    tr_bencDictAddStr( &top, "method", "blocklist-update" );
561    tr_bencDictAddInt( &top, "tag", TAG_BLOCKLIST_UPDATE );
562    exec( &top );
563    tr_bencFree( &top );
564}
565
566/***
567****
568***/
569
570void
571Session :: exec( const tr_benc * request )
572{
573    char * str = tr_bencToStr( request, TR_FMT_JSON_LEAN, NULL );
574    exec( str );
575    tr_free( str );
576}
577
578void
579Session :: localSessionCallback( tr_session * session, const char * json, size_t len, void * self )
580{
581    Q_UNUSED( session );
582
583    ((Session*)self)->parseResponse( json, len );
584}
585
586void
587Session :: exec( const char * json )
588{
589    if( mySession  )
590    {
591        tr_rpc_request_exec_json( mySession, json, strlen( json ), localSessionCallback, this );
592    }
593    else if( !myUrl.isEmpty( ) )
594    {
595        QNetworkRequest request;
596        request.setUrl( myUrl );
597        request.setRawHeader( "User-Agent", QString( QCoreApplication::instance()->applicationName() + "/" + LONG_VERSION_STRING ).toAscii() );
598        request.setRawHeader( "Content-Type", "application/json; charset=UTF-8" );
599        if( !mySessionId.isEmpty( ) )
600            request.setRawHeader( TR_RPC_SESSION_ID_HEADER, mySessionId.toAscii() );
601
602        QBuffer * reqbuf = new QBuffer;
603        reqbuf->setData( QByteArray( json ) );
604
605        QNetworkReply * reply = myNAM.post( request, reqbuf );
606        connect( reply, SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(dataReadProgress()));
607        connect( reply, SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(dataSendProgress()));
608
609        Reply myReply;
610        myReply.networkReply = reply;
611        myReply.buffer = reqbuf;
612        myReplies << myReply;
613#ifdef DEBUG_HTTP
614        std::cerr << "sending " << "POST " << qPrintable( myUrl.path() ) << std::endl;
615        foreach( QByteArray b, request.rawHeaderList() )
616            std::cerr << b.constData()
617                      << ": "
618                      << request.rawHeader( b ).constData()
619                      << std::endl;
620        std::cerr << "Body:\n" << json << std::endl;
621#endif
622    }
623}
624
625void
626Session :: onFinished( QNetworkReply * reply )
627{
628    QBuffer * buffer;
629    for( QList<Reply>::iterator i = myReplies.begin(); i != myReplies.end(); ++i )
630    {
631        if( reply == i->networkReply )
632        {
633            buffer = i->buffer;
634            myReplies.erase( i );
635            break;
636        }
637    }
638
639#ifdef DEBUG_HTTP
640    std::cerr << "http response header: " << std::endl;
641    foreach( QByteArray b, reply->rawHeaderList() )
642        std::cerr << b.constData()
643                  << ": "
644                  << reply->rawHeader( b ).constData()
645                  << std::endl;
646    std::cerr << "json:\n" << reply->peek( reply->bytesAvailable() ).constData() << std::endl;
647#endif
648
649    if( ( reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ).toInt() == 409 )
650        && ( reply->hasRawHeader( TR_RPC_SESSION_ID_HEADER ) ) )
651    {
652        // we got a 409 telling us our session id has expired.
653        // update it and resubmit the request.
654        mySessionId = QString( reply->rawHeader( TR_RPC_SESSION_ID_HEADER ) );
655        exec( buffer->buffer().constData() );
656    }
657    else if( reply->error() != QNetworkReply::NoError )
658    {
659        std::cerr << "http error: " << qPrintable( reply->errorString() ) << std::endl;
660    }
661    else
662    {
663        const QByteArray response( reply->readAll() );
664        const char * json( response.constData( ) );
665        int jsonLength( response.size( ) );
666        if( jsonLength>0 && json[jsonLength-1] == '\n' ) --jsonLength;
667        parseResponse( json, jsonLength );
668    }
669
670    delete buffer;
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.