Changeset 6801


Ignore:
Timestamp:
Sep 26, 2008, 4:41:13 AM (13 years ago)
Author:
charles
Message:

a little more cleanup of the rpc server stuff.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/tr-prefs.c

    r6798 r6801  
    680680    struct remote_page * page = gpage;
    681681    GtkTreeModel *       model = GTK_TREE_MODEL( page->store );
    682     tr_handle *          session = tr_core_handle( page->core );
    683682    GtkTreePath *        path = gtk_tree_path_new_from_string( path_string );
    684683
  • trunk/libtransmission/rpc-server.c

    r6800 r6801  
    4040    unsigned int         isEnabled         : 1;
    4141    unsigned int         isPasswordEnabled : 1;
    42     int                  port;
    43     time_t               lastRequestTime;
     42    uint16_t             port;
    4443    struct evhttp *      httpd;
    4544    tr_handle *          session;
     
    106105    const char * code_text = tr_webGetResponseStr( code );
    107106    struct evbuffer * body = evbuffer_new( );
    108     evbuffer_add_printf( body, "<h1>%s</h1>", text ? text : code_text );
     107    evbuffer_add_printf( body, "<h1>%s</h1>", code_text );
     108    if( text )
     109        evbuffer_add_printf( body, "<h2>%s</h2>", text );
    109110    evhttp_send_reply( req, code, code_text, body );
    110111    evbuffer_free( body );
     
    129130        size_t inlen = EVBUFFER_LENGTH( req->input_buffer );
    130131
    131         char * boundary =
    132             tr_strdup_printf( "--%s", strstr( content_type,
    133                                               "boundary=" ) +
    134                              strlen( "boundary=" ) );
     132        const char * boundary_key = "boundary=";
     133        const char * boundary_key_begin = strstr( content_type, boundary_key );
     134        const char * boundary_val = boundary_key_begin ? boundary_key_begin + strlen( boundary_key ) : "arglebargle";
     135
     136        char * boundary = tr_strdup_printf( "--%s", boundary_val );
    135137        const size_t boundary_len = strlen( boundary );
    136138
    137139        const char * delim = tr_memmem( in, inlen, boundary, boundary_len );
    138140        while( delim )
     141        {
     142            size_t       part_len;
     143            const char * part = delim + boundary_len;
     144            inlen -= ( part - in );
     145            in = part;
     146            delim = tr_memmem( in, inlen, boundary, boundary_len );
     147            part_len = delim ? (size_t)( delim - part ) : inlen;
     148
     149            if( part_len )
    139150            {
    140                 size_t       part_len;
    141                 const char * part = delim + boundary_len;
    142                 inlen -= ( part - in );
    143                 in = part;
    144                 delim = tr_memmem( in, inlen, boundary, boundary_len );
    145                 part_len = delim ? (size_t)( delim - part ) : inlen;
    146 
    147                 if( part_len )
     151                char * text = tr_strndup( part, part_len );
     152                if( strstr( text, "filename=\"" ) )
    148153                {
    149                     char * text = tr_strndup( part, part_len );
    150                     if( strstr( text, "filename=\"" ) )
     154                    const char * body = strstr( text, "\r\n\r\n" );
     155                    if( body )
    151156                    {
    152                         const char * body = strstr( text, "\r\n\r\n" );
    153                         if( body )
    154                         {
    155                             char *  b64, *json, *freeme;
    156                             int     json_len;
    157                             size_t  body_len;
    158                             tr_benc top, *args;
    159 
    160                             body += 4;
    161                             body_len = part_len - ( body - text );
    162                             if( body_len >= 2
     157                        char *  b64, *json, *freeme;
     158                        int     json_len;
     159                        size_t  body_len;
     160                        tr_benc top, *args;
     161
     162                        body += 4;
     163                        body_len = part_len - ( body - text );
     164                        if( body_len >= 2
    163165                              && !memcmp( &body[body_len - 2], "\r\n", 2 ) )
    164166                                body_len -= 2;
    165167
    166                             tr_bencInitDict( &top, 2 );
    167                             args = tr_bencDictAddDict( &top, "arguments", 2 );
    168                             tr_bencDictAddStr( &top, "method",
    169                                                "torrent-add" );
    170                             b64 = tr_base64_encode( body, body_len, NULL );
    171                             tr_bencDictAddStr( args, "metainfo", b64 );
    172                             tr_bencDictAddInt( args, "paused", paused );
    173                             json = tr_bencSaveAsJSON( &top, &json_len );
    174                             freeme =
    175                                 tr_rpc_request_exec_json( server->session,
    176                                                           json, json_len,
    177                                                           NULL );
    178 
    179                             tr_free( freeme );
    180                             tr_free( json );
    181                             tr_free( b64 );
    182                             tr_bencFree( &top );
    183                         }
     168                        tr_bencInitDict( &top, 2 );
     169                        args = tr_bencDictAddDict( &top, "arguments", 2 );
     170                        tr_bencDictAddStr( &top, "method", "torrent-add" );
     171                        b64 = tr_base64_encode( body, body_len, NULL );
     172                        tr_bencDictAddStr( args, "metainfo", b64 );
     173                        tr_bencDictAddInt( args, "paused", paused );
     174                        json = tr_bencSaveAsJSON( &top, &json_len );
     175                        freeme = tr_rpc_request_exec_json( server->session,
     176                                                           json, json_len,
     177                                                           NULL );
     178
     179                        tr_free( freeme );
     180                        tr_free( json );
     181                        tr_free( b64 );
     182                        tr_bencFree( &top );
    184183                    }
    185                     tr_free( text );
    186184                }
     185                tr_free( text );
    187186            }
     187        }
    188188
    189189        tr_free( boundary );
     
    379379
    380380    if( !server->httpd )
    381         if( ( server->httpd = evhttp_start( "0.0.0.0", server->port ) ) )
     381        if( ( server->httpd = evhttp_start( NULL, server->port ) ) )
    382382            evhttp_set_gencb( server->httpd, handle_request, server );
    383383}
     
    413413void
    414414tr_rpcSetPort( tr_rpc_server * server,
    415                int             port )
     415               uint16_t        port )
    416416{
    417417    if( server->port != port )
     
    427427}
    428428
    429 int
     429uint16_t
    430430tr_rpcGetPort( const tr_rpc_server * server )
    431431{
     
    516516tr_rpcInit( tr_handle *  session,
    517517            int          isEnabled,
    518             int          port,
     518            uint16_t     port,
    519519            const char * acl,
    520520            int          isPasswordEnabled,
  • trunk/libtransmission/rpc-server.h

    r6798 r6801  
    1818tr_rpc_server * tr_rpcInit( struct tr_handle * session,
    1919                            int                isEnabled,
    20                             int                port,
     20                            uint16_t           port,
    2121                            const char *       acl,
    2222                            int                isPasswordEnabled,
     
    3232
    3333void            tr_rpcSetPort( tr_rpc_server * server,
    34                                int             port );
     34                               uint16_t        port );
    3535
    36 int             tr_rpcGetPort( const tr_rpc_server * server );
     36uint16_t        tr_rpcGetPort( const tr_rpc_server * server );
    3737
    3838int             tr_rpcSetTest( const tr_rpc_server * server,
  • trunk/libtransmission/session.c

    r6798 r6801  
    216216                    int                peerSocketTOS,
    217217                    int                rpcIsEnabled,
    218                     int                rpcPort,
     218                    uint16_t           rpcPort,
    219219                    const char *       rpcACL,
    220220                    int                rpcAuthIsEnabled,
     
    983983void
    984984tr_sessionSetRPCPort( tr_session * session,
    985                       int          port )
     985                      uint16_t     port )
    986986{
    987987    tr_rpcSetPort( session->rpcServer, port );
    988988}
    989989
    990 int
     990uint16_t
    991991tr_sessionGetRPCPort( const tr_session * session )
    992992{
  • trunk/libtransmission/transmission.h

    r6798 r6801  
    267267                                int                peerSocketTOS,
    268268                                int                rpcIsEnabled,
    269                                 int                rpcPort,
     269                                uint16_t           rpcPort,
    270270                                const char *       rpcAccessControlList,
    271271                                int                rpcPasswordIsEnabled,
     
    338338    @see tr_sessionInitFull()
    339339    @see tr_sessionGetRPCPort */
    340 void tr_sessionSetRPCPort(                     tr_handle *,
    341                                            int port );
     340void tr_sessionSetRPCPort( tr_handle * session,
     341                           uint16_t port );
    342342
    343343/** @brief Get which port to listen for RPC requests on.
    344344    @see tr_sessionInitFull()
    345345    @see tr_sessionSetRPCPort */
    346 int  tr_sessionGetRPCPort( const tr_handle * );
     346uint16_t  tr_sessionGetRPCPort( const tr_handle * );
    347347
    348348/**
Note: See TracChangeset for help on using the changeset viewer.