Changeset 11368


Ignore:
Timestamp:
Oct 31, 2010, 5:16:12 PM (11 years ago)
Author:
charles
Message:

(trunk) #3697 "make blocklist URL configurable" -- implemented in GTK+, Qt, and RPC

Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/extras/rpc-spec.txt

    r11228 r11368  
    410410   "alt-speed-time-day"             | number     | what day(s) to turn on alt speeds (look at tr_sched_day)
    411411   "alt-speed-up"                   | number     | max global upload speed (KBps)
     412   "blocklist-url"                  | string     | location of the blocklist to use for "blocklist-update"
    412413   "blocklist-enabled"              | boolean    | true means enabled
    413414   "blocklist-size"                 | number     | number of rules in the blocklist
     
    637638         |         | yes       | torrent-set    | new arg "seedIdleLimit"
    638639         |         | yes       | torrent-set    | new arg "seedIdleMode"
     640   ------+---------+-----------+----------------+-------------------------------
     641   11    | 2.12    | yes       | session-get    | new arg "blocklist-url"
     642         |         | yes       | session-set    | new arg "blocklist-url"
  • trunk/gtk/main.c

    r11367 r11368  
    11971197        tr_blocklistSetEnabled( tr, pref_flag_get( key ) );
    11981198    }
     1199    else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_URL ) )
     1200    {
     1201        tr_blocklistSetURL( tr, pref_string_get( key ) );
     1202    }
    11991203    else if( !strcmp( key, PREF_KEY_SHOW_TRAY_ICON ) )
    12001204    {
  • trunk/gtk/my-valgrind.sh

    r11239 r11368  
    33export G_DEBUG=gc-friendly
    44export GLIBCXX_FORCE_NEW=1
    5 #valgrind --tool=cachegrind ./transmission -p -g /tmp/transmission-test/what 2>&1 | tee runlog
    6 valgrind --tool=memcheck --leak-check=full --leak-resolution=high --num-callers=48 --log-file=x-valgrind --show-reachable=yes ./transmission-gtk -p 2>&1 | tee runlog
     5#valgrind --tool=cachegrind ./transmission-gtk -p -g /tmp/transmission-test 2>&1 | tee runlog
     6valgrind --tool=memcheck --leak-check=full --leak-resolution=high --num-callers=48 --log-file=x-valgrind --show-reachable=yes ./transmission-gtk -g /tmp/transmission-test -p 2>&1 | tee runlog
  • trunk/gtk/tr-prefs.c

    r11358 r11368  
    246246
    247247static void
    248 target_cb( GtkWidget * tb,
    249            gpointer    target )
     248target_cb( GtkWidget * tb, gpointer target )
    250249{
    251250    const gboolean b = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( tb ) );
     
    384383    GtkWidget * updateBlocklistButton;
    385384    GtkWidget * updateBlocklistDialog;
     385    GtkWidget * label;
    386386    GtkWidget * check;
    387387    TrCore    * core;
     
    391391updateBlocklistText( GtkWidget * w, TrCore * core )
    392392{
     393    char buf1[512];
     394    char buf2[512];
    393395    const int n = tr_blocklistGetRuleCount( tr_core_session( core ) );
    394     char      buf[512];
    395     g_snprintf( buf, sizeof( buf ),
    396                 gtr_ngettext( "Enable _blocklist (contains %'d rule)",
    397                               "Enable _blocklist (contains %'d rules)", n ), n );
    398     gtk_button_set_label( GTK_BUTTON( w ), buf );
     396    g_snprintf( buf1, sizeof( buf1 ),
     397                gtr_ngettext( "Blocklist contains %'d rule",
     398                              "Blocklist contains %'d rules", n ), n );
     399    g_snprintf( buf2, sizeof( buf2 ), "<i>%s</i>", buf1 );
     400    gtk_label_set_markup( GTK_LABEL( w ), buf2 );
    399401}
    400402
     
    430432    gtk_message_dialog_set_markup( d, _( "<b>Update succeeded!</b>" ) );
    431433    gtk_message_dialog_format_secondary_text( d, s, n );
    432     updateBlocklistText( data->check, core );
     434    updateBlocklistText( data->label, core );
    433435}
    434436
     
    477479privacyPage( GObject * core )
    478480{
    479     int                     row = 0;
    480     const char *            s;
    481     GtkWidget *             t;
    482     GtkWidget *             w;
    483     GtkWidget *             b;
    484     GtkWidget *             h;
     481    int row = 0;
     482    const char * s;
     483    GtkWidget * t;
     484    GtkWidget * w;
     485    GtkWidget * b;
     486    GtkWidget * h;
     487    GtkWidget * e;
    485488    struct blocklist_data * data;
    486489
     
    491494    hig_workarea_add_section_title( t, &row, _( "Blocklist" ) );
    492495
    493     w = new_check_button( "", TR_PREFS_KEY_BLOCKLIST_ENABLED, core );
     496    b = new_check_button( _( "Enable _blocklist:" ), TR_PREFS_KEY_BLOCKLIST_ENABLED, core );
     497    e = new_entry( TR_PREFS_KEY_BLOCKLIST_URL, core );
     498    gtk_widget_set_size_request( e, 300, -1 );
     499    hig_workarea_add_row_w( t, &row, b, e, NULL );
     500    data->check = b;
     501    g_signal_connect( b, "toggled", G_CALLBACK( target_cb ), e );
     502    target_cb( b, e );
     503
     504    w = gtk_label_new( "" );
     505    gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
    494506    updateBlocklistText( w, TR_CORE( core ) );
     507    data->label = w;
    495508    h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
    496509    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
    497510    b = data->updateBlocklistButton = gtk_button_new_with_mnemonic( _( "_Update" ) );
    498     data->check = w;
    499     g_object_set_data( G_OBJECT( b ), "session",
    500                       tr_core_session( TR_CORE( core ) ) );
     511    g_object_set_data( G_OBJECT( b ), "session", tr_core_session( TR_CORE( core ) ) );
    501512    g_signal_connect( b, "clicked", G_CALLBACK( onBlocklistUpdate ), data );
     513    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), b ); target_cb( data->check, b );
    502514    gtk_box_pack_start( GTK_BOX( h ), b, FALSE, FALSE, 0 );
    503     g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), b );
    504     target_cb( w, b );
     515    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), w ); target_cb( data->check, w );
    505516    hig_workarea_add_wide_control( t, &row, h );
    506517
     
    508519    w = new_check_button( s, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, core );
    509520    hig_workarea_add_wide_control( t, &row, w );
    510     g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), w );
    511     target_cb( data->check, w );
     521    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), w ); target_cb( data->check, w );
    512522
    513523    hig_workarea_add_section_divider( t, &row );
  • trunk/libtransmission/blocklist.c

    r11144 r11368  
    232232
    233233/*
    234  * level1 format: "comment:x.x.x.x-y.y.y.y"
     234 * bluetack format: "comment:x.x.x.x-y.y.y.y"
    235235 */
    236236static tr_bool
  • trunk/libtransmission/rpcimpl.c

    r11236 r11368  
    1818#include <unistd.h> /* unlink */
    1919
     20#ifdef HAVE_ZLIB
     21 #include <zlib.h>
     22#endif
     23
    2024#include <event.h> /* evbuffer */
    2125
     
    2327#include "bencode.h"
    2428#include "completion.h"
     29#include "fdlimit.h"
    2530#include "json.h"
    2631#include "rpcimpl.h"
     
    11131118    else /* successfully fetched the blocklist... */
    11141119    {
     1120        int fd;
    11151121        const char * configDir = tr_sessionGetConfigDir( session );
    11161122        char * filename = tr_buildPath( configDir, "blocklist.tmp", NULL );
    1117         FILE * fp = fopen( filename, "wb+" );
    1118 
    1119         if( fp == NULL )
     1123
     1124        errno = 0;
     1125
     1126        if( !errno ) {
     1127            fd = tr_open_file_for_writing( filename );
     1128            if( fd < 0 )
     1129                tr_snprintf( result, sizeof( result ), _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( errno ) );
     1130        }
     1131
     1132        if( !errno ) {
     1133            const char * buf = response;
     1134            size_t buflen = response_byte_count;
     1135            while( buflen > 0 ) {
     1136                int n = write( fd, buf, buflen );
     1137                if( n < 0 ) {
     1138                    tr_snprintf( result, sizeof( result ), _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( errno ) );
     1139                    break;
     1140                }
     1141                buf += n;
     1142                buflen -= n;
     1143            }
     1144            tr_close_file( fd );
     1145        }
     1146
     1147#ifdef HAVE_ZLIB
     1148        if( !errno )
    11201149        {
    1121             tr_snprintf( result, sizeof( result ),
    1122                          _( "Couldn't save file \"%1$s\": %2$s" ),
    1123                          filename, tr_strerror( errno ) );
    1124         }
    1125         else
    1126         {
    1127             const size_t n = fwrite( response, 1, response_byte_count, fp );
    1128             fclose( fp );
    1129 
    1130             if( n != response_byte_count )
    1131             {
    1132                 tr_snprintf( result, sizeof( result ),
    1133                              _( "Couldn't save file \"%1$s\": %2$s" ),
    1134                              filename, tr_strerror( errno ) );
     1150            char * filename2 = tr_buildPath( configDir, "blocklist.txt.tmp", NULL );
     1151            fd = tr_open_file_for_writing( filename2 );
     1152            if( fd < 0 )
     1153                tr_snprintf( result, sizeof( result ), _( "Couldn't save file \"%1$s\": %2$s" ), filename2, tr_strerror( errno ) );
     1154            else {
     1155                gzFile gzf = gzopen( filename, "r" );
     1156                if( gzf ) {
     1157                    const size_t buflen = 1024 * 128; /* 128 KiB buffer */
     1158                    uint8_t * buf = tr_valloc( buflen );
     1159                    for( ;; ) {
     1160                        int n = gzread( gzf, buf, buflen );
     1161                        if( n < 0 ) /* error */
     1162                            tr_snprintf( result, sizeof( result ), _( "Error reading \"%1$s\": %2$s" ), filename, gzerror( gzf, NULL ) );
     1163                        if( n < 1 ) /* error or EOF */
     1164                            break;
     1165                        if( write( fd, buf, n ) < 0 )
     1166                            tr_snprintf( result, sizeof( result ), _( "Couldn't save file \"%1$s\": %2$s" ), filename2, tr_strerror( errno ) );
     1167                    }
     1168                    tr_free( buf );
     1169                    gzclose( gzf );
     1170                }
     1171                tr_close_file( fd );
    11351172            }
    1136             else
    1137             {
    1138                 /* feed it to the session */
    1139                 const int ruleCount = tr_blocklistSetContent( session, filename );
    1140 
    1141                 /* give the client a response */
    1142                 tr_bencDictAddInt( data->args_out, "blocklist-size", ruleCount );
    1143                 tr_snprintf( result, sizeof( result ), "success" );
    1144             }
    1145 
    1146             /* cleanup */
     1173
    11471174            unlink( filename );
    1148         }
    1149 
    1150         /* cleanup */
     1175            tr_free( filename );
     1176            filename = filename2;
     1177        }
     1178#endif
     1179
     1180        if( !errno ) {
     1181            /* feed it to the session and give the client a response */
     1182            const int rule_count = tr_blocklistSetContent( session, filename );
     1183            tr_bencDictAddInt( data->args_out, "blocklist-size", rule_count );
     1184            tr_snprintf( result, sizeof( result ), "success" );
     1185        }
     1186
     1187        unlink( filename );
    11511188        tr_free( filename );
    11521189    }
     
    11611198                 struct tr_rpc_idle_data  * idle_data )
    11621199{
    1163     const char * url = "http://update.transmissionbt.com/level1";
    1164     tr_webRun( session, url, NULL, gotNewBlocklist, idle_data );
     1200    tr_webRun( session, session->blocklist_url, NULL, gotNewBlocklist, idle_data );
    11651201    return NULL;
    11661202}
     
    14091445    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal ) )
    14101446        tr_blocklistSetEnabled( session, boolVal );
     1447    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_BLOCKLIST_URL, &str ) )
     1448        tr_blocklistSetURL( session, str );
    14111449    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
    14121450        tr_sessionSetDownloadDir( session, str );
     
    15361574    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
    15371575    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
     1576    tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL, tr_blocklistGetURL( s ) );
    15381577    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, tr_sessionGetCacheLimit_MB( s ) );
    15391578    tr_bencDictAddInt ( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
  • trunk/libtransmission/session.c

    r11367 r11368  
    249249    tr_bencDictReserve( d, 60 );
    250250    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
     251    tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL,            "http://www.example.com/blocklist" );
    251252    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,        DEFAULT_CACHE_SIZE_MB );
    252253    tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,              TRUE );
     
    310311    tr_bencDictReserve( d, 60 );
    311312    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );
     313    tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL,            tr_blocklistGetURL( s ) );
    312314    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,        tr_sessionGetCacheLimit_MB( s ) );
    313315    tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,              s->isDHTEnabled );
     
    686688    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal ) )
    687689        tr_blocklistSetEnabled( session, boolVal );
     690    if( tr_bencDictFindStr( settings, TR_PREFS_KEY_BLOCKLIST_URL, &str ) )
     691        tr_blocklistSetURL( session, str );
    688692    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_START, &boolVal ) )
    689693        tr_sessionSetPaused( session, !boolVal );
     
    17561760    tr_free( session->downloadDir );
    17571761    tr_free( session->incompleteDir );
     1762    tr_free( session->blocklist_url );
    17581763    tr_free( session->peer_congestion_algorithm );
    17591764    tr_free( session );
     
    21422147    int ruleCount;
    21432148    tr_blocklist * b;
    2144     const char * defaultName = "level1.bin";
     2149    const char * defaultName = "blocklist.bin";
    21452150    tr_sessionLock( session );
    21462151
     
    21762181    return FALSE;
    21772182}
     2183
     2184void
     2185tr_blocklistSetURL( tr_session * session, const char * url )
     2186{
     2187    if( session->blocklist_url != url )
     2188    {
     2189        tr_free( session->blocklist_url );
     2190        session->blocklist_url = tr_strdup( url );
     2191    }
     2192}
     2193
     2194const char *
     2195tr_blocklistGetURL ( const tr_session * session )
     2196{
     2197    return session->blocklist_url;
     2198}
     2199
    21782200
    21792201/***
  • trunk/libtransmission/session.h

    r11367 r11368  
    151151    char *                       incompleteDir;
    152152
     153    char *                       blocklist_url;
     154
    153155    struct tr_list *             blocklists;
    154156    struct tr_peerMgr *          peerMgr;
  • trunk/libtransmission/transmission.h

    r11367 r11368  
    158158#define TR_PREFS_KEY_BIND_ADDRESS_IPV6             "bind-address-ipv6"
    159159#define TR_PREFS_KEY_BLOCKLIST_ENABLED             "blocklist-enabled"
     160#define TR_PREFS_KEY_BLOCKLIST_URL                 "blocklist-url"
    160161#define TR_PREFS_KEY_MAX_CACHE_SIZE_MB             "cache-size-mb"
    161162#define TR_PREFS_KEY_DHT_ENABLED                   "dht-enabled"
     
    779780 * Specify a range of IPs for Transmission to block.
    780781 *
    781  * filename must be an uncompressed ascii file,
    782  * using the same format as the bluetack level1 file.
     782 * Filename must be an uncompressed ascii file.
    783783 *
    784784 * libtransmission does not keep a handle to `filename'
     
    786786 * keep or delete `filename' as it wishes.
    787787 * libtransmission makes its own copy of the file
    788  * massaged into a format easier to search.
     788 * massaged into a binary format easier to search.
    789789 *
    790790 * The caller only needs to invoke this when the blocklist
     
    804804void    tr_blocklistSetEnabled   ( tr_session       * session,
    805805                                   tr_bool            isEnabled );
     806
     807/** @brief The blocklist that ges updated when an RPC client
     808           invokes the "blocklist-update" method */
     809void tr_blocklistSetURL         ( tr_session *, const char * url );
     810
     811const char * tr_blocklistGetURL ( const tr_session * );
    806812
    807813
  • trunk/qt/prefs-dialog.cc

    r11185 r11368  
    459459PrefsDialog :: createPrivacyTab( )
    460460{
     461    QWidget * w;
    461462    HIG * hig = new HIG( this );
     463
    462464    hig->addSectionTitle( tr( "Blocklist" ) );
    463     QHBoxLayout * h = new QHBoxLayout( );
    464     QWidget * w = new QPushButton( tr( "&Update" ) );
     465
     466    QWidget * l = checkBoxNew( "Enable &blocklist:", Prefs::BLOCKLIST_ENABLED );
     467    QWidget * e = lineEditNew( Prefs::BLOCKLIST_URL );
     468    myBlockWidgets << e;
     469    hig->addRow( l, e );
     470
     471    l = myBlocklistLabel = new QLabel( "" );
     472    myBlockWidgets << l;
     473    w = new QPushButton( tr( "&Update" ) );
    465474    connect( w, SIGNAL(clicked(bool)), this, SLOT(onUpdateBlocklistClicked()));
    466475    myBlockWidgets << w;
    467     QWidget * l = checkBoxNew( "", Prefs::BLOCKLIST_ENABLED );
     476    QHBoxLayout * h = new QHBoxLayout( );
    468477    h->addWidget( l );
    469478    h->addStretch( 1 );
    470479    h->addWidget( w );
    471480    hig->addWideControl( h );
     481
    472482    l = checkBoxNew( tr( "Enable &automatic updates" ), Prefs::BLOCKLIST_UPDATES_ENABLED );
    473483    myBlockWidgets << l;
    474484    hig->addWideControl( l );
     485
     486    hig->addSectionDivider( );
     487    hig->addSectionTitle( tr( "Privacy" ) );
    475488
    476489    QComboBox * box = new QComboBox( );
     
    481494    connect( box, SIGNAL(activated(int)), this, SLOT(encryptionEdited(int)));
    482495
    483     hig->addSectionDivider( );
    484     hig->addSectionTitle( tr( "Privacy" ) );
    485496    hig->addRow( tr( "&Encryption mode:" ), box );
    486497    hig->addWideControl( w = checkBoxNew( tr( "Use PE&X to find more peers" ), Prefs::PEX_ENABLED ) );
     
    492503
    493504    hig->finish( );
    494     updateBlocklistCheckBox( );
     505    updateBlocklistLabel( );
    495506    return hig;
    496507}
     
    692703PrefsDialog :: sessionUpdated( )
    693704{
    694     updateBlocklistCheckBox( );
    695 }
    696 
    697 void
    698 PrefsDialog :: updateBlocklistCheckBox( )
    699 {
    700     QCheckBox * box = qobject_cast<QCheckBox*>( myWidgets[Prefs::BLOCKLIST_ENABLED] );
     705    updateBlocklistLabel( );
     706}
     707
     708void
     709PrefsDialog :: updateBlocklistLabel( )
     710{
    701711    const int n = mySession.blocklistSize( );
    702     if( n < 0 ) // unknown
    703         box->setText( tr( "Enable &blocklist" ) );
    704     else
    705         box->setText( tr( "Enable &blocklist (%Ln rules)", 0, n ) );
     712    myBlocklistLabel->setText( tr( "<i>Blocklist contains %Ln rules)", 0, n ) );
    706713}
    707714
  • trunk/qt/prefs-dialog.h

    r11096 r11368  
    7171        QLineEdit * lineEditNew( int key, int mode = 0 );
    7272        void enableBuddyWhenChecked( QCheckBox *, QWidget * );
    73         void updateBlocklistCheckBox( );
     73        void updateBlocklistLabel( );
    7474
    7575    public:
     
    115115        QHttp * myBlocklistHttp;
    116116        QMessageBox * myBlocklistDialog;
     117        QLabel * myBlocklistLabel;
    117118};
    118119
  • trunk/qt/prefs.cc

    r11092 r11368  
    7676    { ALT_SPEED_LIMIT_TIME_DAY, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, QVariant::Int },
    7777    { BLOCKLIST_ENABLED, TR_PREFS_KEY_BLOCKLIST_ENABLED, QVariant::Bool },
     78    { BLOCKLIST_URL, TR_PREFS_KEY_BLOCKLIST_URL, QVariant::String },
    7879    { DSPEED, TR_PREFS_KEY_DSPEED_KBps, QVariant::Int },
    7980    { DSPEED_ENABLED, TR_PREFS_KEY_DSPEED_ENABLED, QVariant::Bool },
  • trunk/qt/prefs.h

    r11092 r11368  
    8181            ALT_SPEED_LIMIT_TIME_DAY,
    8282            BLOCKLIST_ENABLED,
     83            BLOCKLIST_URL,
    8384            DSPEED,
    8485            DSPEED_ENABLED,
  • trunk/qt/session.cc

    r11289 r11368  
    142142        case Prefs :: BLOCKLIST_DATE:
    143143        case Prefs :: BLOCKLIST_ENABLED:
     144        case Prefs :: BLOCKLIST_URL:
    144145        case Prefs :: DHT_ENABLED:
    145146        case Prefs :: DOWNLOAD_DIR:
Note: See TracChangeset for help on using the changeset viewer.