source: trunk/qt/session.cc @ 11514

Last change on this file since 11514 was 11514, checked in by charles, 11 years ago

(trunk) #3817 "Use the OS' proxy support" -- implemented for Qt

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