source: trunk/qt/session.cc @ 12461

Last change on this file since 12461 was 12461, checked in by jordan, 11 years ago

(trunk) #3817 remove OS proxy integration from the GTK+ client

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