source: trunk/qt/session.cc @ 12607

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

(trunk) #671 "torrent queuing" -- Preliminary implementation. Covers libtransmission; GTK+ and Qt clients, and rudimentary web client support.

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