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

#1309: Web/RPC interface ACL ignored

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 );
Note: See TracChangeset for help on using the changeset viewer.