Changeset 6823


Ignore:
Timestamp:
Oct 1, 2008, 8:23:57 PM (13 years ago)
Author:
charles
Message:

#1309: Web/RPC interface ACL ignored

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/cli.c

    r6795 r6823  
    311311        TR_DEFAULT_RPC_ENABLED,
    312312        TR_DEFAULT_RPC_PORT,
    313         TR_DEFAULT_RPC_ACL,
     313        TR_DEFAULT_RPC_WHITELIST,
    314314        FALSE, "fnord", "potzrebie",
    315315        TR_DEFAULT_PROXY_ENABLED,
  • trunk/daemon/daemon.c

    r6795 r6823  
    4545#define KEY_USERNAME         "rpc-username"
    4646#define KEY_PASSWORD         "rpc-password"
    47 #define KEY_ACL              "rpc-access-control-list"
     47#define KEY_WHITELIST        "rpc-whitelist"
    4848#define KEY_RPC_PORT         "rpc-port"
    4949#define KEY_DSPEED           "download-limit"
     
    100100                   tr_sessionGetRPCPassword(
    101101                       s ) );
    102     replaceStr( &d, KEY_ACL,             strs[n++] = tr_sessionGetRPCACL( s ) );
     102    replaceStr( &d, KEY_WHITELIST,       strs[n++] = tr_sessionGetRPCWhitelist( s ) );
    103103    replaceInt( &d, KEY_RPC_PORT,        tr_sessionGetRPCPort( s ) );
    104104    replaceInt( &d, KEY_AUTH_REQUIRED,   tr_sessionIsRPCPasswordEnabled( s ) );
     
    161161              const char * downloadDir,
    162162              int          rpcPort,
    163               const char * acl,
     163              const char * whitelist,
    164164              int          authRequired,
    165165              const char * username,
     
    209209    getConfigInt( dict, KEY_RPC_PORT,        &rpcPort,
    210210                  TR_DEFAULT_RPC_PORT );
    211     getConfigStr( dict, KEY_ACL,             &acl,
    212                   TR_DEFAULT_RPC_ACL );
     211    getConfigStr( dict, KEY_WHITELIST,       &whitelist,
     212                  TR_DEFAULT_RPC_WHITELIST );
    213213    getConfigInt( dict, KEY_AUTH_REQUIRED,   &authRequired,      FALSE );
    214214    getConfigStr( dict, KEY_USERNAME,        &username,          NULL );
     
    232232                                    blocklistEnabled,
    233233                                    TR_DEFAULT_PEER_SOCKET_TOS,
    234                                     TRUE, rpcPort, acl, authRequired,
     234                                    TRUE, rpcPort, whitelist, authRequired,
    235235                                    username, password,
    236236                                    TR_DEFAULT_PROXY_ENABLED,
     
    271271static const struct tr_option options[] =
    272272{
    273     { 'a', "acl",
    274       "Access Control List.  (Default: " TR_DEFAULT_RPC_ACL ")",       "a",
     273    { 'a', "allowed",
     274      "Allowed IP addresses.  (Default: " TR_DEFAULT_RPC_WHITELIST ")",       "a",
    275275      1, "<list>"     },
    276276    { 'b', "blocklist",    "Enable peer blocklists",
     
    313313          const char ** downloadDir,
    314314          int *         rpcPort,
    315           const char ** acl,
     315          const char ** whitelist,
    316316          int *         authRequired,
    317317          const char ** username,
     
    327327        {
    328328            case 'a':
    329                 *acl = optarg; break;
     329                *whitelist = optarg; break;
    330330
    331331            case 'b':
     
    458458    const char * configDir = NULL;
    459459    const char * downloadDir = NULL;
    460     const char * acl = NULL;
     460    const char * whitelist = NULL;
    461461    const char * username = NULL;
    462462    const char * password = NULL;
     
    469469
    470470    readargs( argc, (const char**)argv, &nofork, &configDir, &downloadDir,
    471               &rpcPort, &acl, &authRequired, &username, &password,
     471              &rpcPort, &whitelist, &authRequired, &username, &password,
    472472              &blocklistEnabled );
    473473    if( configDir == NULL )
     
    487487
    488488    session_init( configDir, downloadDir,
    489                   rpcPort, acl, authRequired, username, password,
     489                  rpcPort, whitelist, authRequired, username, password,
    490490                  blocklistEnabled );
    491491
  • trunk/daemon/transmission-daemon.1

    r6805 r6823  
    3131.Bl -tag -width Ds
    3232
    33 .It Fl a Fl -acl Ar (+|-)x.x.x.x,...
    34 Specify access control list (ACL) to control which hosts may submit RPC requests.
    35 This is a comma-separated list of IP addresses, each prepended by a '-' or '+'
    36 to denote that access should be denied or allowed to that address.
     33.It Fl a Fl -allowed Ar x.x.x.x,...
     34Allow RPC accecss to a comma-delimited whitelist of IP addresses.
    3735Wildcards can be specified in an address by using '*'.
    38 Default: +127.0.0.1
     36Default: "127.0.0.1"
     37Example: "127.0.0.*,192.168.1.*"
    3938
    4039.It Fl b Fl -blocklist
  • trunk/gtk/main.c

    r6798 r6823  
    485485            pref_flag_get( PREF_KEY_RPC_ENABLED ),
    486486            pref_int_get( PREF_KEY_RPC_PORT ),
    487             pref_string_get( PREF_KEY_RPC_ACL ),
     487            pref_string_get( PREF_KEY_RPC_WHITELIST ),
    488488            pref_flag_get( PREF_KEY_RPC_AUTH_ENABLED ),
    489489            pref_string_get( PREF_KEY_RPC_USERNAME ),
     
    11931193        tr_sessionSetRPCEnabled( tr, pref_flag_get( key ) );
    11941194    }
    1195     else if( !strcmp( key, PREF_KEY_RPC_ACL ) )
     1195    else if( !strcmp( key, PREF_KEY_RPC_WHITELIST ) )
    11961196    {
    11971197        const char * s = pref_string_get( key );
    1198         tr_sessionSetRPCACL( tr, s );
     1198        tr_sessionSetRPCWhitelist( tr, s );
    11991199    }
    12001200    else if( !strcmp( key, PREF_KEY_RPC_USERNAME ) )
  • trunk/gtk/tr-prefs.c

    r6807 r6823  
    128128    pref_flag_set_default   ( PREF_KEY_RPC_ENABLED, TR_DEFAULT_RPC_ENABLED );
    129129    pref_int_set_default    ( PREF_KEY_RPC_PORT, TR_DEFAULT_RPC_PORT );
    130     pref_string_set_default ( PREF_KEY_RPC_ACL, TR_DEFAULT_RPC_ACL );
     130    pref_string_set_default ( PREF_KEY_RPC_WHITELIST, TR_DEFAULT_RPC_WHITELIST );
    131131
    132132    rand = g_rand_new ( );
     
    557557****/
    558558
    559 static GtkTreeModel*
    560 allow_deny_model_new( void )
    561 {
    562     GtkTreeIter    iter;
    563     GtkListStore * store = gtk_list_store_new( 2, G_TYPE_STRING,
    564                                                G_TYPE_CHAR );
    565 
    566     gtk_list_store_append( store, &iter );
    567     gtk_list_store_set( store, &iter, 0, _( "Allow" ), 1, '+', -1 );
    568     gtk_list_store_append( store, &iter );
    569     gtk_list_store_set( store, &iter, 0, _( "Deny" ), 1, '-', -1 );
    570     return GTK_TREE_MODEL( store );
    571 }
    572 
    573559enum
    574560{
    575561    COL_ADDRESS,
    576     COL_PERMISSION,
    577562    N_COLS
    578563};
    579564
    580565static GtkTreeModel*
    581 acl_tree_model_new( const char * acl )
     566whitelist_tree_model_new( const char * whitelist )
    582567{
    583568    int            i;
     
    587572                                               G_TYPE_STRING );
    588573
    589     rules = g_strsplit( acl, ",", 0 );
     574    rules = g_strsplit( whitelist, ",", 0 );
    590575
    591576    for( i = 0; rules && rules[i]; ++i )
    592577    {
     578        GtkTreeIter iter;
    593579        const char * s = rules[i];
    594580        while( isspace( *s ) ) ++s;
    595 
    596         if( *s == '+' || *s == '-' )
    597         {
    598             GtkTreeIter iter;
    599             gtk_list_store_append( store, &iter );
    600             gtk_list_store_set( store, &iter,
    601                                 COL_PERMISSION, *s == '+' ? _(
    602                                     "Allow" ) : _( "Deny" ),
    603                                 COL_ADDRESS, s + 1,
    604                                 -1 );
    605         }
     581        gtk_list_store_append( store, &iter );
     582        gtk_list_store_set( store, &iter, COL_ADDRESS, s, -1 );
    606583    }
    607584
     
    623600
    624601static void
    625 refreshACL( struct remote_page * page )
     602refreshWhitelist( struct remote_page * page )
    626603{
    627604    GtkTreeIter    iter;
     
    631608    if( gtk_tree_model_get_iter_first( model, &iter ) ) do
    632609        {
    633             char * permission;
    634610            char * address;
    635             gtk_tree_model_get( model, &iter, COL_PERMISSION, &permission,
     611            gtk_tree_model_get( model, &iter,
    636612                                COL_ADDRESS, &address,
    637613                                -1 );
    638             g_string_append_c( gstr, strcmp( permission, _(
    639                                                 "Allow" ) ) ? '-' : '+' );
    640614            g_string_append( gstr, address );
    641             g_string_append( gstr, ", " );
     615            g_string_append( gstr, "," );
    642616            g_free( address );
    643             g_free( permission );
    644617        }
    645618        while( gtk_tree_model_iter_next( model, &iter ) );
    646619
    647     g_string_truncate( gstr, gstr->len - 2 ); /* remove the trailing ", " */
    648 
    649     tr_core_set_pref( page->core, PREF_KEY_RPC_ACL, gstr->str );
     620    g_string_truncate( gstr, gstr->len - 1 ); /* remove the trailing comma */
     621
     622    tr_core_set_pref( page->core, PREF_KEY_RPC_WHITELIST, gstr->str );
    650623
    651624    g_string_free( gstr, TRUE );
    652 }
    653 
    654 static void
    655 onPermissionEdited( GtkCellRendererText  * renderer UNUSED,
    656                     gchar *                         path_string,
    657                     gchar *                         new_text,
    658                     gpointer                        gpage )
    659 {
    660     GtkTreeIter          iter;
    661     GtkTreePath *        path = gtk_tree_path_new_from_string( path_string );
    662     struct remote_page * page = gpage;
    663     GtkTreeModel *       model = GTK_TREE_MODEL( page->store );
    664 
    665     if( gtk_tree_model_get_iter( model, &iter, path ) )
    666         gtk_list_store_set( page->store, &iter, COL_PERMISSION, new_text,
    667                             -1 );
    668     gtk_tree_path_free( path );
    669     refreshACL( page );
    670625}
    671626
     
    673628onAddressEdited( GtkCellRendererText  * r UNUSED,
    674629                 gchar *                  path_string,
    675                  gchar *                  new_text,
     630                 gchar *                  address,
    676631                 gpointer                 gpage )
    677632{
    678     char *               acl;
    679633    GtkTreeIter          iter;
    680634    struct remote_page * page = gpage;
     
    682636    GtkTreePath *        path = gtk_tree_path_new_from_string( path_string );
    683637
    684     acl = g_strdup_printf( "+%s", new_text );
    685638    if( gtk_tree_model_get_iter( model, &iter, path ) )
    686         gtk_list_store_set( page->store, &iter, COL_ADDRESS, new_text, -1 );
    687 
    688     g_free( acl );
     639        gtk_list_store_set( page->store, &iter, COL_ADDRESS, address, -1 );
     640
    689641    gtk_tree_path_free( path );
    690     refreshACL( page );
    691 }
    692 
    693 static void
    694 onAddACLClicked( GtkButton * b UNUSED,
     642    refreshWhitelist( page );
     643}
     644
     645static void
     646onAddWhitelistClicked( GtkButton * b UNUSED,
    695647                 gpointer      gpage )
    696648{
     
    701653    gtk_list_store_append( page->store, &iter );
    702654    gtk_list_store_set( page->store, &iter,
    703                         COL_PERMISSION, _( "Allow" ),
    704655                        COL_ADDRESS,  "0.0.0.0",
    705656                        -1 );
     
    714665
    715666static void
    716 onRemoveACLClicked( GtkButton * b UNUSED,
     667onRemoveWhitelistClicked( GtkButton * b UNUSED,
    717668                    gpointer      gpage )
    718669{
     
    724675    {
    725676        gtk_list_store_remove( page->store, &iter );
    726         refreshACL( page );
     677        refreshWhitelist( page );
    727678    }
    728679}
     
    762713
    763714static void
    764 onACLSelectionChanged( GtkTreeSelection * sel UNUSED,
     715onWhitelistSelectionChanged( GtkTreeSelection * sel UNUSED,
    765716                       gpointer               page )
    766717{
     
    841792    /* access control list */
    842793    {
    843         const char *        val = pref_string_get( PREF_KEY_RPC_ACL );
    844         GtkTreeModel *      m = acl_tree_model_new( val );
     794        const char *        val = pref_string_get( PREF_KEY_RPC_WHITELIST );
     795        GtkTreeModel *      m = whitelist_tree_model_new( val );
    845796        GtkTreeViewColumn * c;
    846797        GtkCellRenderer *   r;
     
    851802        GtkTooltips *       tips = gtk_tooltips_new( );
    852803
    853         s = _( "Access control list:" );
    854804        page->store = GTK_LIST_STORE( m );
    855805        w = gtk_tree_view_new_with_model( m );
     
    865815        sel = gtk_tree_view_get_selection( v );
    866816        g_signal_connect( sel, "changed",
    867                           G_CALLBACK( onACLSelectionChanged ), page );
     817                          G_CALLBACK( onWhitelistSelectionChanged ), page );
    868818        g_object_unref( G_OBJECT( m ) );
    869819        gtk_tree_view_set_headers_visible( v, TRUE );
     
    877827                          G_CALLBACK( onAddressEdited ), page );
    878828        g_object_set( G_OBJECT( r ), "editable", TRUE, NULL );
    879         c = gtk_tree_view_column_new_with_attributes( _( "IP Address" ), r,
     829        c = gtk_tree_view_column_new_with_attributes( NULL, r,
    880830                                                      "text", COL_ADDRESS,
    881831                                                      NULL );
    882832        gtk_tree_view_column_set_expand( c, TRUE );
    883833        gtk_tree_view_append_column( v, c );
    884 
     834        gtk_tree_view_set_headers_visible( v, FALSE );
     835
     836        s = _( "Allowed _IP Addresses:" );
    885837        w = hig_workarea_add_row( t, &row, s, w, NULL );
    886         gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.1f );
     838        gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.0f );
     839        gtk_misc_set_padding( GTK_MISC( w ), 0, GUI_PAD );
    887840        page->widgets = g_slist_append( page->widgets, w );
    888 
    889         /* permission column */
    890         m = allow_deny_model_new( );
    891         r = gtk_cell_renderer_combo_new( );
    892         g_object_set( G_OBJECT( r ), "model", m,
    893                       "editable", TRUE,
    894                       "has-entry", FALSE,
    895                       "text-column", 0,
    896                       NULL );
    897         c = gtk_tree_view_column_new_with_attributes( _(
    898                                                           "Permission" ), r,
    899                                                       "text",
    900                                                       COL_PERMISSION,
    901                                                       NULL );
    902         g_signal_connect( r, "edited",
    903                           G_CALLBACK( onPermissionEdited ), page );
    904         gtk_tree_view_append_column( v, c );
    905841
    906842        h = gtk_hbox_new( TRUE, GUI_PAD );
    907843        w = gtk_button_new_from_stock( GTK_STOCK_REMOVE );
    908844        g_signal_connect( w, "clicked", G_CALLBACK(
    909                               onRemoveACLClicked ), page );
     845                              onRemoveWhitelistClicked ), page );
    910846        page->remove_button = w;
    911         onACLSelectionChanged( sel, page );
     847        onWhitelistSelectionChanged( sel, page );
    912848        gtk_box_pack_start_defaults( GTK_BOX( h ), w );
    913849        w = gtk_button_new_from_stock( GTK_STOCK_ADD );
    914850        page->widgets = g_slist_append( page->widgets, w );
    915         g_signal_connect( w, "clicked", G_CALLBACK( onAddACLClicked ), page );
     851        g_signal_connect( w, "clicked", G_CALLBACK( onAddWhitelistClicked ), page );
    916852        gtk_box_pack_start_defaults( GTK_BOX( h ), w );
    917853        w = gtk_hbox_new( FALSE, 0 );
  • trunk/gtk/tr-prefs.h

    r6795 r6823  
    6666#define PREF_KEY_RPC_PORT               "rpc-port"
    6767#define PREF_KEY_RPC_ENABLED            "rpc-enabled"
    68 #define PREF_KEY_RPC_ACL                "rpc-access-control-list"
     68#define PREF_KEY_RPC_WHITELIST          "rpc-whitelist"
    6969#define PREF_KEY_RPC_AUTH_ENABLED       "rpc-authentication-required"
    7070#define PREF_KEY_RPC_PASSWORD           "rpc-password"
  • trunk/libtransmission/rpc-server.c

    r6820 r6823  
    2121
    2222#ifdef HAVE_LIBZ
    23 #include <zlib.h>
     23 #include <zlib.h>
    2424#endif
    2525
     
    4343struct tr_rpc_server
    4444{
    45     unsigned int     isEnabled         : 1;
    46     unsigned int     isPasswordEnabled : 1;
    47     uint16_t         port;
    48     struct evhttp *  httpd;
    49     tr_handle *      session;
    50     char *           username;
    51     char *           password;
    52     char *           acl;
     45    unsigned int       isEnabled         : 1;
     46    unsigned int       isPasswordEnabled : 1;
     47    uint16_t           port;
     48    struct evhttp *    httpd;
     49    tr_handle *        session;
     50    char *             username;
     51    char *             password;
     52    char *             whitelist;
    5353};
    5454
    55 #define dbgmsg( fmt... ) tr_deepLog( __FILE__, __LINE__, MY_NAME, ## fmt )
     55#define dbgmsg( fmt ... ) tr_deepLog( __FILE__, __LINE__, MY_NAME, ## fmt )
    5656
    5757/**
     
    188188    const struct
    189189    {
    190         const char *  suffix;
    191         const char *  mime_type;
     190        const char *    suffix;
     191        const char *    mime_type;
    192192    } types[] = {
    193193        /* these are just the ones we need for serving clutch... */
    194         { "css",  "text/css"                   },
    195         { "gif",  "image/gif"                  },
    196         { "html", "text/html"                  },
    197         { "ico",  "image/vnd.microsoft.icon"   },
    198         { "js",   "application/javascript"     },
    199         { "png",  "image/png"                  }
     194        { "css",  "text/css"                       },
     195        { "gif",  "image/gif"                      },
     196        { "html", "text/html"                      },
     197        { "ico",  "image/vnd.microsoft.icon"       },
     198        { "js",   "application/javascript"         },
     199        { "png",  "image/png"                      }
    200200    };
    201201    const char * dot = strrchr( path, '.' );
     
    212212compress_evbuf( struct evbuffer * evbuf )
    213213{
    214     static struct evbuffer *tmp;
    215     static z_stream stream;
    216     static unsigned char buffer[2048];
    217    
    218     if( !tmp ) {
     214    static struct evbuffer * tmp;
     215    static z_stream          stream;
     216    static unsigned char     buffer[2048];
     217
     218    if( !tmp )
     219    {
    219220        tmp = evbuffer_new( );
    220221        deflateInit( &stream, Z_BEST_COMPRESSION );
     
    222223
    223224    deflateReset( &stream );
    224     stream.next_in = EVBUFFER_DATA(evbuf);
    225     stream.avail_in = EVBUFFER_LENGTH(evbuf);
    226 
    227     do {
     225    stream.next_in = EVBUFFER_DATA( evbuf );
     226    stream.avail_in = EVBUFFER_LENGTH( evbuf );
     227
     228    do
     229    {
    228230        stream.next_out = buffer;
    229231        stream.avail_out = sizeof( buffer );
     
    232234        else
    233235            break;
    234     } while (stream.avail_out == 0);
    235 
    236 /*fprintf( stderr, "deflated response from %zu to %zu bytes\n", EVBUFFER_LENGTH( evbuf ), EVBUFFER_LENGTH( tmp ) );*/
    237     evbuffer_drain(evbuf, EVBUFFER_LENGTH(evbuf));
    238     evbuffer_add_buffer(evbuf, tmp);
    239 }
     236    }
     237    while( stream.avail_out == 0 );
     238
     239/*fprintf( stderr, "deflated response from %zu to %zu bytes\n", EVBUFFER_LENGTH(
     240  evbuf ), EVBUFFER_LENGTH( tmp ) );*/
     241    evbuffer_drain( evbuf, EVBUFFER_LENGTH( evbuf ) );
     242    evbuffer_add_buffer( evbuf, tmp );
     243}
     244
    240245#endif
    241246
    242247static void
    243 maybe_deflate_response( struct evhttp_request * req, struct evbuffer * response )
     248maybe_deflate_response( struct evhttp_request * req,
     249                        struct evbuffer *       response )
    244250{
    245251#ifdef HAVE_LIBZ
    246     const char * accept_encoding = evhttp_find_header( req->input_headers, "Accept-Encoding" );
    247     const int do_deflate = accept_encoding && strstr( accept_encoding, "deflate" );
    248     if( do_deflate ) {
    249         evhttp_add_header( req->output_headers, "Content-Encoding", "deflate" );
     252    const char * accept_encoding = evhttp_find_header( req->input_headers,
     253                                                       "Accept-Encoding" );
     254    const int    do_deflate = accept_encoding && strstr( accept_encoding,
     255                                                         "deflate" );
     256    if( do_deflate )
     257    {
     258        evhttp_add_header( req->output_headers, "Content-Encoding",
     259                           "deflate" );
    250260        compress_evbuf( response );
    251261    }
     
    316326}
    317327
    318 
    319328static void
    320329handle_rpc( struct evhttp_request * req,
     
    357366                  const char *          address )
    358367{
    359     const char * acl;
    360 
    361     for( acl = server->acl; acl && *acl; )
    362     {
    363         const char * delimiter = strchr( acl, ',' );
    364         const int    len = delimiter ? delimiter - acl : (int)strlen( acl );
    365         char *       token = tr_strndup( acl, len );
    366         const int    match = tr_wildmat( address, token + 1 );
     368    const char * str;
     369
     370    for( str = server->whitelist; str && *str; )
     371    {
     372        const char * delimiter = strchr( str, ',' );
     373        const int    len = delimiter ? delimiter - str : (int)strlen( str );
     374        char *       token = tr_strndup( str, len );
     375        const int    match = tr_wildmat( address, token );
    367376        tr_free( token );
    368377        if( match )
    369             return *acl == '+';
     378            return 1;
    370379        if( !delimiter )
    371380            break;
    372         acl = delimiter + 1;
     381        str = delimiter + 1;
    373382    }
    374383
     
    403412        }
    404413
    405         if( server->acl && !isAddressAllowed( server, req->remote_host ) )
     414        if( server->whitelist && !isAddressAllowed( server, req->remote_host ) )
    406415        {
    407416            send_simple_response( req, 401, "Unauthorized IP Address" );
     
    481490        startServer( server );
    482491}
    483    
    484492
    485493void
     
    530538
    531539void
    532 tr_rpcSetACL( tr_rpc_server * server,
    533               const char *    acl )
    534 {
    535     tr_free( server->acl );
    536     server->acl = tr_strdup( acl );
     540tr_rpcSetWhitelist( tr_rpc_server * server,
     541                    const char *    whitelist )
     542{
     543    tr_free( server->whitelist );
     544    server->whitelist = tr_strdup( whitelist );
    537545}
    538546
    539547char*
    540 tr_rpcGetACL( const tr_rpc_server * server )
    541 {
    542     return tr_strdup( server->acl ? server->acl : "" );
     548tr_rpcGetWhitelist( const tr_rpc_server * server )
     549{
     550    return tr_strdup( server->whitelist ? server->whitelist : "" );
    543551}
    544552
     
    599607{
    600608    tr_rpc_server * s = vserver;
     609
    601610    stopServer( s );
    602     tr_free( s->acl );
     611    tr_free( s->whitelist );
    603612    tr_free( s->username );
    604613    tr_free( s->password );
     
    609618tr_rpcClose( tr_rpc_server ** ps )
    610619{
    611     tr_runInEventThread( (*ps)->session, closeServer, *ps );
     620    tr_runInEventThread( ( *ps )->session, closeServer, *ps );
    612621    *ps = NULL;
    613622}
     
    617626            int          isEnabled,
    618627            uint16_t     port,
    619             const char * acl,
     628            const char * whitelist,
    620629            int          isPasswordEnabled,
    621630            const char * username,
     
    627636    s->session = session;
    628637    s->port = port;
    629     s->acl = tr_strdup( acl && *acl ? acl : TR_DEFAULT_RPC_ACL );
     638    s->whitelist = tr_strdup( whitelist && *whitelist ? whitelist : TR_DEFAULT_RPC_WHITELIST );
    630639    s->username = tr_strdup( username );
    631640    s->password = tr_strdup( password );
  • trunk/libtransmission/rpc-server.h

    r6801 r6823  
    1919                            int                isEnabled,
    2020                            uint16_t           port,
    21                             const char *       acl,
     21                            const char *       whitelist,
    2222                            int                isPasswordEnabled,
    2323                            const char *       username,
     
    3737
    3838int             tr_rpcSetTest( const tr_rpc_server * server,
    39                                const char *          acl,
     39                               const char *          whitelist,
    4040                               char **               allocme_errmsg );
    4141
    42 void            tr_rpcSetACL( tr_rpc_server * server,
    43                               const char *    acl );
     42void            tr_rpcSetWhitelist( tr_rpc_server * server,
     43                                    const char *    whitelist );
    4444
    45 char*           tr_rpcGetACL( const tr_rpc_server * server );
     45char*           tr_rpcGetWhitelist( const tr_rpc_server * server );
    4646
    4747void            tr_rpcSetPassword( tr_rpc_server * server,
     
    6060int             tr_rpcIsPasswordEnabled( const tr_rpc_server * session );
    6161
    62 /** (public for the unit tests) */
    63 char*           cidrize( const char * acl );
    64 
    6562
    6663#endif
  • trunk/libtransmission/session.c

    r6801 r6823  
    217217                    int                rpcIsEnabled,
    218218                    uint16_t           rpcPort,
    219                     const char *       rpcACL,
     219                    const char *       rpcWhitelist,
    220220                    int                rpcAuthIsEnabled,
    221221                    const char *       rpcUsername,
     
    295295
    296296    h->web = tr_webInit( h );
    297     h->rpcServer = tr_rpcInit( h, rpcIsEnabled, rpcPort, rpcACL,
     297    h->rpcServer = tr_rpcInit( h, rpcIsEnabled, rpcPort, rpcWhitelist,
    298298                               rpcAuthIsEnabled, rpcUsername, rpcPassword );
    299299
     
    327327                               TR_DEFAULT_RPC_ENABLED,
    328328                               TR_DEFAULT_RPC_PORT,
    329                                TR_DEFAULT_RPC_ACL,
     329                               TR_DEFAULT_RPC_WHITELIST,
    330330                               FALSE,
    331331                               "fnord",
     
    10041004
    10051005void
    1006 tr_sessionSetRPCACL( tr_session * session,
    1007                      const char * acl )
    1008 {
    1009     return tr_rpcSetACL( session->rpcServer, acl );
     1006tr_sessionSetRPCWhitelist( tr_session * session,
     1007                           const char * whitelist )
     1008{
     1009    return tr_rpcSetWhitelist( session->rpcServer, whitelist );
    10101010}
    10111011
    10121012char*
    1013 tr_sessionGetRPCACL( const tr_session * session )
    1014 {
    1015     return tr_rpcGetACL( session->rpcServer );
     1013tr_sessionGetRPCWhitelist( const tr_session * session )
     1014{
     1015    return tr_rpcGetWhitelist( session->rpcServer );
    10161016}
    10171017
  • trunk/libtransmission/transmission.h

    r6801 r6823  
    130130#define TR_DEFAULT_RPC_PORT_STR             "9091"
    131131/** @see tr_sessionInitFull */
    132 #define TR_DEFAULT_RPC_ACL                  "+127.0.0.1"
     132#define TR_DEFAULT_RPC_WHITELIST            "127.0.0.1"
    133133/** @see tr_sessionInitFull */
    134134#define TR_DEFAULT_PROXY_ENABLED            0
     
    237237 *  The port on which to listen for incoming RPC requests
    238238 *
    239  * @param rpcACL
    240  *  The access control list for allowing/denying RPC requests
    241  *  from specific IP ranges.
    242  *  @see tr_sessionSetRPCACL()
     239 * @param rpcWhitelist
     240 *  The list of IP addresses allowed to make RPC connections.
     241 *  @see tr_sessionSetRPCWhitelist()
    243242 *
    244243 * @see TR_DEFAULT_PEER_SOCKET_TOS
     
    246245 * @see TR_DEFAULT_RPC_ENABLED
    247246 * @see TR_DEFAULT_RPC_PORT
    248  * @see TR_DEFAULT_RPC_ACL
     247 * @see TR_DEFAULT_RPC_WHITELIST
    249248 * @see tr_sessionClose()
    250249 */
     
    268267                                int                rpcIsEnabled,
    269268                                uint16_t           rpcPort,
    270                                 const char *       rpcAccessControlList,
     269                                const char *       rpcWhitelist,
    271270                                int                rpcPasswordIsEnabled,
    272271                                const char *       rpcUsername,
     
    347346
    348347/**
    349  * @brief Specify access control list (ACL).
    350  *
    351  * ACL is a comma-delimited list of dotted-quad IP addresses, each preceded
    352  * by a '+' or '-' sign to denote 'allow' or 'deny'.  Wildmat notation is
    353  * supported, meaning that '?' is interpreted as a single-character wildcard
    354  * and '*' is interprted as a multi-character wildcard.
    355  */
    356 void   tr_sessionSetRPCACL( tr_session * session,
    357                             const char * acl );
     348 * @brief Specify a whitelist for remote RPC access
     349 *
     350 * The whitelist is a comma-separated list of dotted-quad IP addresses
     351 * to be allowed.  Wildmat notation is supported, meaning that
     352 * '?' is interpreted as a single-character wildcard and
     353 * '*' is interprted as a multi-character wildcard.
     354 */
     355void   tr_sessionSetRPCWhitelist( tr_session * session,
     356                                  const char * whitelist );
    358357
    359358/** @brief get the Access Control List for allowing/denying RPC requests.
    360     @return a comma-separated string of ACL rules.  tr_free() when done.
     359    @return a comma-separated string of whitelist domains.  tr_free() when done.
    361360    @see tr_sessionInitFull
    362     @see tr_sessionSetRPCACL */
    363 char* tr_sessionGetRPCACL( const tr_session * );
     361    @see tr_sessionSetRPCWhitelist */
     362char* tr_sessionGetRPCWhitelist( const tr_session * );
    364363
    365364void  tr_sessionSetRPCPassword( tr_session * session,
  • trunk/libtransmission/trevent.c

    r6819 r6823  
    162162               veh );
    163163    event_add( &eh->pipeEvent, NULL );
    164 
     164    event_set_log_callback( logFunc );
    165165    event_dispatch( );
    166166
Note: See TracChangeset for help on using the changeset viewer.