source: trunk/qt/session.cc @ 12214

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

(trunk qt) housekeeping: tr_bool --> bool

  • Property svn:keywords set to Date Rev Author Id
File size: 31.9 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 12214 2011-03-23 18:26:01Z 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
310static void
311curlConfigFunc( tr_session * session UNUSED, void * vcurl, const char * destination )
312{
313    CURL * easy = vcurl;
314    const QUrl url( destination );
315    const QNetworkProxyQuery query( url );
316    QList<QNetworkProxy> proxyList = QNetworkProxyFactory :: systemProxyForQuery( query );
317
318    foreach( QNetworkProxy proxy, proxyList )
319    {
320        long type = -1;
321
322        switch( proxy.type( ) ) {
323            case QNetworkProxy::HttpProxy: type = CURLPROXY_HTTP; break;
324            case QNetworkProxy::Socks5Proxy: type = CURLPROXY_SOCKS5; break;
325            default: break;
326        }
327
328        if( type != -1 ) {
329            curl_easy_setopt( easy, CURLOPT_PROXY, proxy.hostName().toUtf8().data() );
330            curl_easy_setopt( easy, CURLOPT_PROXYPORT, long(proxy.port()) );
331            curl_easy_setopt( easy, CURLOPT_PROXYTYPE, type );
332            const QString user = proxy.user();
333            const QString pass = proxy.password();
334            if( !user.isEmpty() && !pass.isEmpty() )
335                curl_easy_setopt( easy, CURLOPT_PROXYUSERPWD, (user+":"+pass).toUtf8().data() );
336            return;
337        }
338    }
339}
340
341void
342Session :: start( )
343{
344    if( myPrefs.get<bool>(Prefs::SESSION_IS_REMOTE) )
345    {
346        QUrl url;
347        url.setScheme( "http" );
348        url.setHost( myPrefs.get<QString>(Prefs::SESSION_REMOTE_HOST) );
349        url.setPort( myPrefs.get<int>(Prefs::SESSION_REMOTE_PORT) );
350        url.setPath( "/transmission/rpc" );
351        if( myPrefs.get<bool>(Prefs::SESSION_REMOTE_AUTH) )
352        {
353            url.setUserName( myPrefs.get<QString>(Prefs::SESSION_REMOTE_USERNAME) );
354            url.setPassword( myPrefs.get<QString>(Prefs::SESSION_REMOTE_PASSWORD) );
355        }
356        myUrl = url;
357    }
358    else
359    {
360        tr_benc settings;
361        tr_bencInitDict( &settings, 0 );
362        tr_sessionLoadSettings( &settings, myConfigDir.toUtf8().constData(), "qt" );
363        mySession = tr_sessionInit( "qt", myConfigDir.toUtf8().constData(), true, &settings );
364        tr_sessionSetWebConfigFunc( mySession, curlConfigFunc );
365        tr_bencFree( &settings );
366
367        tr_ctor * ctor = tr_ctorNew( mySession );
368        int torrentCount;
369        tr_torrent ** torrents = tr_sessionLoadTorrents( mySession, ctor, &torrentCount );
370        tr_free( torrents );
371        tr_ctorFree( ctor );
372    }
373
374    emit sourceChanged( );
375}
376
377bool
378Session :: isServer( ) const
379{
380    return mySession != 0;
381}
382
383bool
384Session :: isLocal( ) const
385{
386    if( mySession != 0 )
387        return true;
388
389    if( myUrl.host() == "127.0.0.1" )
390        return true;
391
392    if( !myUrl.host().compare( "localhost", Qt::CaseInsensitive ) )
393        return true;
394
395    return false;
396}
397
398/***
399****
400***/
401
402namespace
403{
404    tr_benc *
405    buildRequest( const char * method, tr_benc& top, int tag=-1 )
406    {
407        tr_bencInitDict( &top, 3 );
408        tr_bencDictAddStr( &top, "method", method );
409        if( tag >= 0 )
410            tr_bencDictAddInt( &top, "tag", tag );
411        return tr_bencDictAddDict( &top, "arguments", 0 );
412    }
413
414    void
415    addOptionalIds( tr_benc * args, const QSet<int>& ids )
416    {
417        if( !ids.isEmpty( ) )
418        {
419            tr_benc * idList( tr_bencDictAddList( args, "ids", ids.size( ) ) );
420            foreach( int i, ids )
421                tr_bencListAddInt( idList, i );
422        }
423    }
424}
425
426void
427Session :: torrentSet( const QSet<int>& ids, const QString& key, double value )
428{
429    tr_benc top;
430    tr_bencInitDict( &top, 2 );
431    tr_bencDictAddStr( &top, "method", "torrent-set" );
432    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
433    tr_bencDictAddReal( args, key.toUtf8().constData(), value );
434    addOptionalIds( args, ids );
435    exec( &top );
436    tr_bencFree( &top );
437}
438
439void
440Session :: torrentSet( const QSet<int>& ids, const QString& key, int value )
441{
442    tr_benc top;
443    tr_bencInitDict( &top, 2 );
444    tr_bencDictAddStr( &top, "method", "torrent-set" );
445    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
446    tr_bencDictAddInt( args, key.toUtf8().constData(), value );
447    addOptionalIds( args, ids );
448    exec( &top );
449    tr_bencFree( &top );
450}
451
452void
453Session :: torrentSet( const QSet<int>& ids, const QString& key, bool value )
454{
455    tr_benc top;
456    tr_bencInitDict( &top, 2 );
457    tr_bencDictAddStr( &top, "method", "torrent-set" );
458    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
459    tr_bencDictAddBool( args, key.toUtf8().constData(), value );
460    addOptionalIds( args, ids );
461    exec( &top );
462    tr_bencFree( &top );
463}
464
465void
466Session :: torrentSet( const QSet<int>& ids, const QString& key, const QStringList& value )
467{
468    tr_benc top;
469    tr_bencInitDict( &top, 2 );
470    tr_bencDictAddStr( &top, "method", "torrent-set" );
471    tr_benc * args = tr_bencDictAddDict( &top, "arguments", 2 );
472    addOptionalIds( args, ids );
473    tr_benc * list( tr_bencDictAddList( args, key.toUtf8().constData(), value.size( ) ) );
474    foreach( const QString str, value )
475        tr_bencListAddStr( list, str.toUtf8().constData() );
476    exec( &top );
477    tr_bencFree( &top );
478}
479
480void
481Session :: torrentSet( const QSet<int>& ids, const QString& key, const QList<int>& value )
482{
483    tr_benc top;
484    tr_bencInitDict( &top, 2 );
485    tr_bencDictAddStr( &top, "method", "torrent-set" );
486    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
487    addOptionalIds( args, ids );
488    tr_benc * list( tr_bencDictAddList( args, key.toUtf8().constData(), value.size( ) ) );
489    foreach( int i, value )
490        tr_bencListAddInt( list, i );
491    exec( &top );
492    tr_bencFree( &top );
493}
494
495void
496Session :: torrentSet( const QSet<int>& ids, const QString& key, const QPair<int,QString>& value )
497{
498    tr_benc top;
499    tr_bencInitDict( &top, 2 );
500    tr_bencDictAddStr( &top, "method", "torrent-set" );
501    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
502    addOptionalIds( args, ids );
503    tr_benc * list( tr_bencDictAddList( args, key.toUtf8().constData(), 2 ) );
504    tr_bencListAddInt( list, value.first );
505    tr_bencListAddStr( list, value.second.toUtf8().constData() );
506    exec( &top );
507    tr_bencFree( &top );
508}
509
510void
511Session :: torrentSetLocation( const QSet<int>& ids, const QString& location, bool doMove )
512{
513    tr_benc top;
514    tr_bencInitDict( &top, 2 );
515    tr_bencDictAddStr( &top, "method", "torrent-set-location" );
516    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 3 ) );
517    addOptionalIds( args, ids );
518    tr_bencDictAddStr( args, "location", location.toUtf8().constData() );
519    tr_bencDictAddBool( args, "move", doMove );
520    exec( &top );
521    tr_bencFree( &top );
522}
523
524void
525Session :: refreshTorrents( const QSet<int>& ids )
526{
527    if( ids.empty( ) )
528    {
529        refreshAllTorrents( );
530    }
531    else
532    {
533        tr_benc top;
534        tr_bencInitDict( &top, 3 );
535        tr_bencDictAddStr( &top, "method", "torrent-get" );
536        tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
537        tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
538        addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
539        addOptionalIds( args, ids );
540        exec( &top );
541        tr_bencFree( &top );
542    }
543}
544
545void
546Session :: refreshExtraStats( const QSet<int>& ids )
547{
548    tr_benc top;
549    tr_bencInitDict( &top, 3 );
550    tr_bencDictAddStr( &top, "method", "torrent-get" );
551    tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
552    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
553    addOptionalIds( args, ids );
554    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) + getExtraStatKeys( ));
555    exec( &top );
556    tr_bencFree( &top );
557}
558
559void
560Session :: sendTorrentRequest( const char * request, const QSet<int>& ids )
561{
562    tr_benc top;
563    tr_benc * args( buildRequest( request, top ) );
564    addOptionalIds( args, ids );
565    exec( &top );
566    tr_bencFree( &top );
567
568    refreshTorrents( ids );
569}
570
571void
572Session :: pauseTorrents( const QSet<int>& ids )
573{
574    sendTorrentRequest( "torrent-stop", ids );
575}
576
577void
578Session :: startTorrents( const QSet<int>& ids )
579{
580    sendTorrentRequest( "torrent-start", ids );
581}
582
583void
584Session :: refreshActiveTorrents( )
585{
586    tr_benc top;
587    tr_bencInitDict( &top, 3 );
588    tr_bencDictAddStr( &top, "method", "torrent-get" );
589    tr_bencDictAddInt( &top, "tag", TAG_SOME_TORRENTS );
590    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 2 ) );
591    tr_bencDictAddStr( args, "ids", "recently-active" );
592    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
593    exec( &top );
594    tr_bencFree( &top );
595}
596
597void
598Session :: refreshAllTorrents( )
599{
600    tr_benc top;
601    tr_bencInitDict( &top, 3 );
602    tr_bencDictAddStr( &top, "method", "torrent-get" );
603    tr_bencDictAddInt( &top, "tag", TAG_ALL_TORRENTS );
604    tr_benc * args( tr_bencDictAddDict( &top, "arguments", 1 ) );
605    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys( ) );
606    exec( &top );
607    tr_bencFree( &top );
608}
609
610void
611Session :: initTorrents( const QSet<int>& ids )
612{
613    tr_benc top;
614    const int tag( ids.isEmpty() ? TAG_ALL_TORRENTS : TAG_SOME_TORRENTS );
615    tr_benc * args( buildRequest( "torrent-get", top, tag ) );
616    addOptionalIds( args, ids );
617    addList( tr_bencDictAddList( args, "fields", 0 ), getStatKeys()+getInfoKeys() );
618    exec( &top );
619    tr_bencFree( &top );
620}
621
622void
623Session :: refreshSessionStats( )
624{
625    tr_benc top;
626    tr_bencInitDict( &top, 2 );
627    tr_bencDictAddStr( &top, "method", "session-stats" );
628    tr_bencDictAddInt( &top, "tag", TAG_SESSION_STATS );
629    exec( &top );
630    tr_bencFree( &top );
631}
632
633void
634Session :: refreshSessionInfo( )
635{
636    tr_benc top;
637    tr_bencInitDict( &top, 2 );
638    tr_bencDictAddStr( &top, "method", "session-get" );
639    tr_bencDictAddInt( &top, "tag", TAG_SESSION_INFO );
640    exec( &top );
641    tr_bencFree( &top );
642}
643
644void
645Session :: updateBlocklist( )
646{
647    tr_benc top;
648    tr_bencInitDict( &top, 2 );
649    tr_bencDictAddStr( &top, "method", "blocklist-update" );
650    tr_bencDictAddInt( &top, "tag", TAG_BLOCKLIST_UPDATE );
651    exec( &top );
652    tr_bencFree( &top );
653}
654
655/***
656****
657***/
658
659void
660Session :: exec( const tr_benc * request )
661{
662    char * str = tr_bencToStr( request, TR_FMT_JSON_LEAN, NULL );
663    exec( str );
664    tr_free( str );
665}
666
667void
668Session :: localSessionCallback( tr_session * session, struct evbuffer * json, void * self )
669{
670    Q_UNUSED( session );
671
672    ((Session*)self)->parseResponse( (const char*) evbuffer_pullup( json, -1 ), evbuffer_get_length( json ) );
673}
674
675#define REQUEST_DATA_PROPERTY_KEY "requestData"
676
677void
678Session :: exec( const char * json )
679{
680    if( mySession  )
681    {
682        tr_rpc_request_exec_json( mySession, json, strlen( json ), localSessionCallback, this );
683    }
684    else if( !myUrl.isEmpty( ) )
685    {
686        QNetworkRequest request;
687        request.setUrl( myUrl );
688        request.setRawHeader( "User-Agent", QString( QCoreApplication::instance()->applicationName() + "/" + LONG_VERSION_STRING ).toAscii() );
689        request.setRawHeader( "Content-Type", "application/json; charset=UTF-8" );
690        if( !mySessionId.isEmpty( ) )
691            request.setRawHeader( TR_RPC_SESSION_ID_HEADER, mySessionId.toAscii() );
692
693        const QByteArray requestData( json );
694        QNetworkReply * reply = networkAccessManager()->post( request, requestData );
695        reply->setProperty( REQUEST_DATA_PROPERTY_KEY, requestData );
696        connect( reply, SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(dataReadProgress()));
697        connect( reply, SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(dataSendProgress()));
698
699#ifdef DEBUG_HTTP
700        std::cerr << "sending " << "POST " << qPrintable( myUrl.path() ) << std::endl;
701        foreach( QByteArray b, request.rawHeaderList() )
702            std::cerr << b.constData()
703                      << ": "
704                      << request.rawHeader( b ).constData()
705                      << std::endl;
706        std::cerr << "Body:\n" << json << std::endl;
707#endif
708    }
709}
710
711void
712Session :: onFinished( QNetworkReply * reply )
713{
714#ifdef DEBUG_HTTP
715    std::cerr << "http response header: " << std::endl;
716    foreach( QByteArray b, reply->rawHeaderList() )
717        std::cerr << b.constData()
718                  << ": "
719                  << reply->rawHeader( b ).constData()
720                  << std::endl;
721    std::cerr << "json:\n" << reply->peek( reply->bytesAvailable() ).constData() << std::endl;
722#endif
723
724    if( ( reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ).toInt() == 409 )
725        && ( reply->hasRawHeader( TR_RPC_SESSION_ID_HEADER ) ) )
726    {
727        // we got a 409 telling us our session id has expired.
728        // update it and resubmit the request.
729        mySessionId = QString( reply->rawHeader( TR_RPC_SESSION_ID_HEADER ) );
730        exec( reply->property( REQUEST_DATA_PROPERTY_KEY ).toByteArray( ).constData( ) );
731    }
732    else if( reply->error() != QNetworkReply::NoError )
733    {
734        std::cerr << "http error: " << qPrintable( reply->errorString() ) << std::endl;
735    }
736    else
737    {
738        const QByteArray response( reply->readAll() );
739        const char * json( response.constData( ) );
740        int jsonLength( response.size( ) );
741        if( jsonLength>0 && json[jsonLength-1] == '\n' ) --jsonLength;
742        parseResponse( json, jsonLength );
743    }
744
745    reply->deleteLater();
746}
747
748void
749Session :: parseResponse( const char * json, size_t jsonLength )
750{
751    tr_benc top;
752    const uint8_t * end( 0 );
753    const int err( tr_jsonParse( "rpc", json, jsonLength, &top, &end ) );
754    if( !err )
755    {
756        int64_t tag = -1;
757        const char * result = NULL;
758        tr_benc * args = NULL;
759
760        tr_bencDictFindInt ( &top, "tag", &tag );
761        tr_bencDictFindStr ( &top, "result", &result );
762        tr_bencDictFindDict( &top, "arguments", &args );
763
764        emit executed( tag, result, args );
765
766        tr_benc * torrents;
767        const char * str;
768
769        if( tr_bencDictFindInt( &top, "tag", &tag ) )
770        {
771            switch( tag )
772            {
773                case TAG_SOME_TORRENTS:
774                case TAG_ALL_TORRENTS:
775                    if( tr_bencDictFindDict( &top, "arguments", &args ) ) {
776                        if( tr_bencDictFindList( args, "torrents", &torrents ) )
777                            emit torrentsUpdated( torrents, tag==TAG_ALL_TORRENTS );
778                        if( tr_bencDictFindList( args, "removed", &torrents ) )
779                            emit torrentsRemoved( torrents );
780                    }
781                    break;
782
783                case TAG_SESSION_STATS:
784                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
785                        updateStats( args );
786                    break;
787
788                case TAG_SESSION_INFO:
789                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
790                        updateInfo( args );
791                    break;
792
793                case TAG_BLOCKLIST_UPDATE: {
794                    int64_t intVal = 0;
795                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
796                        if( tr_bencDictFindInt( args, "blocklist-size", &intVal ) )
797                            setBlocklistSize( intVal );
798                    break;
799                }
800
801                case TAG_PORT_TEST: {
802                    bool isOpen = 0;
803                    if( tr_bencDictFindDict( &top, "arguments", &args ) )
804                        tr_bencDictFindBool( args, "port-is-open", &isOpen );
805                    emit portTested( (bool)isOpen );
806                }
807
808                case TAG_MAGNET_LINK: {
809                    tr_benc * args;
810                    tr_benc * torrents;
811                    tr_benc * child;
812                    const char * str;
813                    if( tr_bencDictFindDict( &top, "arguments", &args )
814                        && tr_bencDictFindList( args, "torrents", &torrents )
815                        && (( child = tr_bencListChild( torrents, 0 )))
816                        && tr_bencDictFindStr( child, "magnetLink", &str ) )
817                            QApplication::clipboard()->setText( str );
818                    break;
819                }
820
821                case TAG_ADD_TORRENT:
822                    str = "";
823                    if( tr_bencDictFindStr( &top, "result", &str ) && strcmp( str, "success" ) ) {
824                        QMessageBox * d = new QMessageBox( QMessageBox::Information,
825                                                           tr( "Add Torrent" ),
826                                                           QString::fromUtf8(str),
827                                                           QMessageBox::Close,
828                                                           QApplication::activeWindow());
829                        connect( d, SIGNAL(rejected()), d, SLOT(deleteLater()) );
830                        d->show( );
831                    }
832                    break;
833
834                default:
835                    break;
836            }
837        }
838        tr_bencFree( &top );
839    }
840}
841
842void
843Session :: updateStats( tr_benc * d, struct tr_session_stats * stats )
844{
845    int64_t i;
846
847    if( tr_bencDictFindInt( d, "uploadedBytes", &i ) )
848        stats->uploadedBytes = i;
849    if( tr_bencDictFindInt( d, "downloadedBytes", &i ) )
850        stats->downloadedBytes = i;
851    if( tr_bencDictFindInt( d, "filesAdded", &i ) )
852        stats->filesAdded = i;
853    if( tr_bencDictFindInt( d, "sessionCount", &i ) )
854        stats->sessionCount = i;
855    if( tr_bencDictFindInt( d, "secondsActive", &i ) )
856        stats->secondsActive = i;
857
858    stats->ratio = tr_getRatio( stats->uploadedBytes, stats->downloadedBytes );
859
860}
861
862void
863Session :: updateStats( tr_benc * d )
864{
865    tr_benc * c;
866
867    if( tr_bencDictFindDict( d, "current-stats", &c ) )
868        updateStats( c, &myStats );
869
870    if( tr_bencDictFindDict( d, "cumulative-stats", &c ) )
871        updateStats( c, &myCumulativeStats );
872
873    emit statsUpdated( );
874}
875
876void
877Session :: updateInfo( tr_benc * d )
878{
879    int64_t i;
880    const char * str;
881    disconnect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) );
882
883    for( int i=Prefs::FIRST_CORE_PREF; i<=Prefs::LAST_CORE_PREF; ++i )
884    {
885        const tr_benc * b( tr_bencDictFind( d, myPrefs.keyStr( i ) ) );
886
887        if( !b )
888            continue;
889
890        if( i == Prefs :: ENCRYPTION )
891        {
892            const char * val;
893            if( tr_bencGetStr( b, &val ) )
894            {
895                if( !qstrcmp( val , "required" ) )
896                    myPrefs.set( i, 2 );
897                else if( !qstrcmp( val , "preferred" ) )
898                    myPrefs.set( i, 1 );
899                else if( !qstrcmp( val , "tolerated" ) )
900                    myPrefs.set( i, 0 );
901            }
902            continue;
903        }
904
905        switch( myPrefs.type( i ) )
906        {
907            case QVariant :: Int: {
908                int64_t val;
909                if( tr_bencGetInt( b, &val ) )
910                    myPrefs.set( i, (int)val );
911                break;
912            }
913            case QVariant :: Double: {
914                double val;
915                if( tr_bencGetReal( b, &val ) )
916                    myPrefs.set( i, val );
917                break;
918            }
919            case QVariant :: Bool: {
920                bool val;
921                if( tr_bencGetBool( b, &val ) )
922                    myPrefs.set( i, (bool)val );
923                break;
924            }
925            case TrTypes :: FilterModeType:
926            case TrTypes :: SortModeType:
927            case QVariant :: String: {
928                const char * val;
929                if( tr_bencGetStr( b, &val ) )
930                    myPrefs.set( i, QString(val) );
931                break;
932            }
933            default:
934                break;
935        }
936    }
937
938    bool b;
939    double x;
940    if( tr_bencDictFindBool( d, "seedRatioLimited", &b ) )
941        myPrefs.set( Prefs::RATIO_ENABLED, b ? true : false );
942    if( tr_bencDictFindReal( d, "seedRatioLimit", &x ) )
943        myPrefs.set( Prefs::RATIO, x );
944
945    /* Use the C API to get settings that, for security reasons, aren't supported by RPC */
946    if( mySession != 0 )
947    {
948        myPrefs.set( Prefs::RPC_ENABLED,           tr_sessionIsRPCEnabled           ( mySession ) );
949        myPrefs.set( Prefs::RPC_AUTH_REQUIRED,     tr_sessionIsRPCPasswordEnabled   ( mySession ) );
950        myPrefs.set( Prefs::RPC_PASSWORD,          tr_sessionGetRPCPassword         ( mySession ) );
951        myPrefs.set( Prefs::RPC_PORT,              tr_sessionGetRPCPort             ( mySession ) );
952        myPrefs.set( Prefs::RPC_USERNAME,          tr_sessionGetRPCUsername         ( mySession ) );
953        myPrefs.set( Prefs::RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled ( mySession ) );
954        myPrefs.set( Prefs::RPC_WHITELIST,         tr_sessionGetRPCWhitelist        ( mySession ) );
955    }
956
957    if( tr_bencDictFindInt( d, "blocklist-size", &i ) && i!=blocklistSize( ) )
958        setBlocklistSize( i );
959
960    if( tr_bencDictFindStr( d, "version", &str ) && ( mySessionVersion != str ) )
961        mySessionVersion = str;
962
963    //std::cerr << "Session :: updateInfo end" << std::endl;
964    connect( &myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)) );
965
966    emit sessionUpdated( );
967}
968
969void
970Session :: setBlocklistSize( int64_t i )
971{
972    myBlocklistSize = i;
973
974    emit blocklistUpdated( i );
975}
976
977void
978Session :: addTorrent( const AddData& addMe )
979{
980    const QByteArray b64 = addMe.toBase64();
981
982    tr_benc top, *args;
983    tr_bencInitDict( &top, 2 );
984    tr_bencDictAddStr( &top, "method", "torrent-add" );
985    args = tr_bencDictAddDict( &top, "arguments", 2 );
986    tr_bencDictAddBool( args, "paused", !myPrefs.getBool( Prefs::START ) );
987    switch( addMe.type ) {
988        case AddData::MAGNET:   tr_bencDictAddStr( args, "filename", addMe.magnet.toUtf8().constData() ); break;
989        case AddData::URL:      tr_bencDictAddStr( args, "filename", addMe.url.toString().toUtf8().constData() ); break;
990        case AddData::FILENAME: /* fall-through */
991        case AddData::METAINFO: tr_bencDictAddRaw( args, "metainfo", b64.constData(), b64.size() ); break;
992        default: std::cerr << "Unhandled AddData type: " << addMe.type << std::endl;
993    }
994    exec( &top );
995    tr_bencFree( &top );
996}
997
998void
999Session :: addNewlyCreatedTorrent( const QString& filename, const QString& localPath )
1000{
1001    const QByteArray b64 = AddData(filename).toBase64();
1002
1003    tr_benc top, *args;
1004    tr_bencInitDict( &top, 2 );
1005    tr_bencDictAddStr( &top, "method", "torrent-add" );
1006    args = tr_bencDictAddDict( &top, "arguments", 3 );
1007    tr_bencDictAddStr( args, "download-dir", qPrintable(localPath) );
1008    tr_bencDictAddBool( args, "paused", !myPrefs.getBool( Prefs::START ) );
1009    tr_bencDictAddRaw( args, "metainfo", b64.constData(), b64.size() );
1010    exec( &top );
1011    tr_bencFree( &top );
1012}
1013
1014void
1015Session :: removeTorrents( const QSet<int>& ids, bool deleteFiles )
1016{
1017    if( !ids.isEmpty( ) )
1018    {
1019        tr_benc top, *args;
1020        tr_bencInitDict( &top, 2 );
1021        tr_bencDictAddStr( &top, "method", "torrent-remove" );
1022        args = tr_bencDictAddDict( &top, "arguments", 2 );
1023        addOptionalIds( args, ids );
1024        tr_bencDictAddInt( args, "delete-local-data", deleteFiles );
1025        exec( &top );
1026        tr_bencFree( &top );
1027    }
1028}
1029
1030void
1031Session :: verifyTorrents( const QSet<int>& ids )
1032{
1033    if( !ids.isEmpty( ) )
1034    {
1035        tr_benc top, *args;
1036        tr_bencInitDict( &top, 2 );
1037        tr_bencDictAddStr( &top, "method", "torrent-verify" );
1038        args = tr_bencDictAddDict( &top, "arguments", 1 );
1039        addOptionalIds( args, ids );
1040        exec( &top );
1041        tr_bencFree( &top );
1042    }
1043}
1044
1045void
1046Session :: reannounceTorrents( const QSet<int>& ids )
1047{
1048    if( !ids.isEmpty( ) )
1049    {
1050        tr_benc top, *args;
1051        tr_bencInitDict( &top, 2 );
1052        tr_bencDictAddStr( &top, "method", "torrent-reannounce" );
1053        args = tr_bencDictAddDict( &top, "arguments", 1 );
1054        addOptionalIds( args, ids );
1055        exec( &top );
1056        tr_bencFree( &top );
1057    }
1058}
1059
1060/***
1061****
1062***/
1063
1064void
1065Session :: launchWebInterface( )
1066{
1067    QUrl url;
1068    if( !mySession ) // remote session
1069        url = myUrl;
1070    else { // local session
1071        url.setScheme( "http" );
1072        url.setHost( "localhost" );
1073        url.setPort( myPrefs.getInt( Prefs::RPC_PORT ) );
1074    }
1075    QDesktopServices :: openUrl( url );
1076}
Note: See TracBrowser for help on using the repository browser.