Changeset 7552


Ignore:
Timestamp:
Dec 30, 2008, 10:07:39 PM (12 years ago)
Author:
charles
Message:

(trunk libT) have tr_bencSaveAsJSON() use an evbuffer

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/daemon.c

    r7547 r7552  
    2323#include <signal.h>
    2424#include <unistd.h> /* daemon */
     25
     26#include <event.h>
    2527
    2628#include <libtransmission/transmission.h>
     
    246248    if( dumpSettings )
    247249    {
    248         char * str = tr_bencSaveAsJSON( &settings, NULL );
    249         fprintf( stderr, "%s", str );
    250         tr_free( str );
     250        struct evbuffer * buf = tr_getBuffer( );
     251
     252        tr_bencSaveAsJSON( &settings, buf );
     253        fprintf( stderr, "%s", (char*)EVBUFFER_DATA(buf) );
     254
     255        tr_releaseBuffer( buf );
    251256        return 0;
    252257    }
  • trunk/daemon/remote.c

    r7404 r7552  
    525525
    526526        if( addArg )
    527             reqs[reqCount++] = tr_bencSaveAsJSON( &top, NULL );
     527        {
     528            struct evbuffer * buf = tr_getBuffer( );
     529            reqs[reqCount++] = tr_strdup( tr_bencSaveAsJSON( &top, buf ) );
     530            tr_releaseBuffer( buf );
     531        }
     532
    528533        tr_bencFree( &top );
    529534    }
  • trunk/gtk/main.c

    r7464 r7552  
    13851385    tr_session * session = tr_core_session( data->core );
    13861386    const char * cmd = "{ \"method\": \"torrent-stop\" }";
    1387     char * response = tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL );
    1388     tr_free( response );
     1387    tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL );
    13891388}
    13901389
  • trunk/libtransmission/bencode-test.c

    r7359 r7552  
    33#include <stdio.h>
    44#include <string.h>
     5
     6#include "event.h"
     7
    58#include "transmission.h"
    69#include "bencode.h"
     
    310313{
    311314    tr_benc top;
    312     char *  serialized;
     315    struct evbuffer * buf = tr_getBuffer( );
     316    char * serialized;
    313317
    314318    tr_bencLoad( benc_str, strlen( benc_str ), &top, NULL );
    315     serialized = tr_bencSaveAsJSON( &top, NULL );
     319    serialized = tr_bencSaveAsJSON( &top, buf );
    316320    stripWhitespace( serialized );
    317321#if 0
     
    321325#endif
    322326    check( !strcmp( serialized, expected ) );
    323     tr_free( serialized );
    324327    tr_bencFree( &top );
     328    tr_releaseBuffer( buf );
    325329    return 0;
    326330}
  • trunk/libtransmission/bencode.c

    r7549 r7552  
    13121312
    13131313char*
    1314 tr_bencSaveAsJSON( const tr_benc * top,
    1315                    int *           len )
    1316 {
    1317     char *           ret;
     1314tr_bencSaveAsJSON( const tr_benc * top, struct evbuffer * out )
     1315{
    13181316    struct WalkFuncs walkFuncs;
    13191317    struct jsonWalk  data;
    13201318
    1321     data.out = tr_getBuffer( );
     1319    evbuffer_drain( out, EVBUFFER_LENGTH( out ) );
     1320
     1321    data.out = out;
    13221322    data.parents = NULL;
    13231323
     
    13301330    bencWalk( top, &walkFuncs, &data );
    13311331
    1332     if( EVBUFFER_LENGTH( data.out ) )
    1333         evbuffer_add_printf( data.out, "\n" );
    1334     if( len )
    1335         *len = EVBUFFER_LENGTH( data.out );
    1336     ret = tr_strndup( EVBUFFER_DATA( data.out ), EVBUFFER_LENGTH( data.out ) );
    1337 
    1338     tr_releaseBuffer( data.out );
    1339     return ret;
     1332    if( EVBUFFER_LENGTH( out ) )
     1333        evbuffer_add_printf( out, "\n" );
     1334
     1335    return (char*) EVBUFFER_DATA( out );
    13401336}
    13411337
     
    14661462                     const tr_benc * b )
    14671463{
    1468     int       len;
    1469     char *    content = tr_bencSaveAsJSON( b, &len );
    1470     const int err = saveFile( filename, content, len );
    1471 
    1472     tr_free( content );
     1464    struct evbuffer * buf = tr_getBuffer( );
     1465    const char * json = tr_bencSaveAsJSON( b, buf );
     1466    const int err = saveFile( filename, json, EVBUFFER_LENGTH( buf ) );
     1467    tr_releaseBuffer( buf );
    14731468    return err;
    14741469}
  • trunk/libtransmission/bencode.h

    r7404 r7552  
    1515
    1616#include <inttypes.h> /* for int64_t */
     17
     18struct evbuffer;
    1719
    1820enum
     
    7375char*     tr_bencSave( const tr_benc * val, int * len );
    7476
    75 char*     tr_bencSaveAsJSON( const tr_benc * top, int * len );
     77char*     tr_bencSaveAsJSON( const tr_benc * top, struct evbuffer * out );
    7678
    7779int       tr_bencSaveFile( const char * filename, const tr_benc * );
  • trunk/libtransmission/json-test.c

    r6795 r7552  
    2929test_utf8( void )
    3030{
    31     const char * in = "{ \"key\": \"Letöltések\" }";
    32     tr_benc      top;
    33     const char * str;
    34     char *      json;
    35     int          json_len;
    36     int          err;
     31    const char      * in = "{ \"key\": \"Letöltések\" }";
     32    tr_benc           top;
     33    const char      * str;
     34    char            * json;
     35    int               err;
     36    struct evbuffer * buf = tr_getBuffer( );
    3737
    3838    err = tr_jsonParse( in, strlen( in ), &top, NULL );
     
    6767    check( tr_bencDictFindStr( &top, "key", &str ) );
    6868    check( !strcmp( str, "Letöltések" ) );
    69     json = tr_bencSaveAsJSON( &top, &json_len );
     69    json = tr_bencSaveAsJSON( &top, buf );
    7070    if( !err )
    7171        tr_bencFree( &top );
     
    7373    check( strstr( json, "\\u00f6" ) != NULL );
    7474    check( strstr( json, "\\u00e9" ) != NULL );
    75     err = tr_jsonParse( json, json_len, &top, NULL );
     75    err = tr_jsonParse( json, strlen( json ), &top, NULL );
    7676    check( !err );
    7777    check( tr_bencIsDict( &top ) );
  • trunk/libtransmission/rpc-server.c

    r7550 r7552  
    156156                    if( body )
    157157                    {
    158                         char *  b64, *json, *freeme;
    159                         int     json_len;
     158                        char * b64;
    160159                        size_t  body_len;
    161160                        tr_benc top, *args;
     161                        struct evbuffer * json = tr_getBuffer( );
    162162
    163163                        body += 4; /* walk past the \r\n\r\n */
     
    173173                        tr_bencDictAddStr( args, "metainfo", b64 );
    174174                        tr_bencDictAddInt( args, "paused", paused );
    175                         json = tr_bencSaveAsJSON( &top, &json_len );
    176                         freeme = tr_rpc_request_exec_json( server->session,
    177                                                            json, json_len,
    178                                                            NULL );
    179 
    180                         tr_free( freeme );
    181                         tr_free( json );
     175                        tr_bencSaveAsJSON( &top, json );
     176                        tr_rpc_request_exec_json( server->session,
     177                                                  EVBUFFER_DATA( json ),
     178                                                  EVBUFFER_LENGTH( json ),
     179                                                  NULL );
     180
     181                        tr_releaseBuffer( json );
    182182                        tr_free( b64 );
    183183                        tr_bencFree( &top );
     
    377377static void
    378378handle_rpc( struct evhttp_request * req,
    379             struct tr_rpc_server *  server )
    380 {
    381     int               len = 0;
    382     char *            out = NULL;
    383     struct evbuffer * buf;
     379            struct tr_rpc_server  * server )
     380{
     381    struct evbuffer * response = tr_getBuffer( );
    384382
    385383    if( req->type == EVHTTP_REQ_GET )
     
    387385        const char * q;
    388386        if( ( q = strchr( req->uri, '?' ) ) )
    389             out = tr_rpc_request_exec_uri( server->session,
    390                                            q + 1,
    391                                            strlen( q + 1 ),
    392                                            &len );
     387            tr_rpc_request_exec_uri( server->session, q + 1, strlen( q + 1 ), response );
    393388    }
    394389    else if( req->type == EVHTTP_REQ_POST )
    395390    {
    396         out = tr_rpc_request_exec_json( server->session,
    397                                         EVBUFFER_DATA( req->input_buffer ),
    398                                         EVBUFFER_LENGTH( req->input_buffer ),
    399                                         &len );
    400     }
    401 
    402     buf = tr_getBuffer( );
    403     add_response( req, server, buf, out, len );
    404     evhttp_add_header( req->output_headers, "Content-Type",
    405                        "application/json; charset=UTF-8" );
    406     evhttp_send_reply( req, HTTP_OK, "OK", buf );
     391        tr_rpc_request_exec_json( server->session,
     392                                  EVBUFFER_DATA( req->input_buffer ),
     393                                  EVBUFFER_LENGTH( req->input_buffer ),
     394                                  response );
     395    }
     396
     397    {
     398        struct evbuffer * buf = tr_getBuffer( );
     399        add_response( req, server, buf,
     400                      EVBUFFER_DATA( response ),
     401                      EVBUFFER_LENGTH( response ) );
     402        evhttp_add_header( req->output_headers, "Content-Type",
     403                                                "application/json; charset=UTF-8" );
     404        evhttp_send_reply( req, HTTP_OK, "OK", buf );
     405        tr_releaseBuffer( buf );
     406    }
    407407
    408408    /* cleanup */
    409     tr_releaseBuffer( buf );
    410     tr_free( out );
     409    tr_releaseBuffer( response );
    411410}
    412411
  • trunk/libtransmission/rpcimpl.c

    r7473 r7552  
    762762};
    763763
    764 static char*
    765 request_exec( tr_session * session,
    766               tr_benc    * request,
    767               int        * response_len )
     764static void
     765request_exec( tr_session       * session,
     766              tr_benc          * request,
     767              struct evbuffer  * response_buf )
    768768{
    769769    int64_t      i;
    770770    const char * str;
    771     char *       out;
    772771    tr_benc      response;
    773772    tr_benc *    args_in = tr_bencDictFind( request, "arguments" );
     
    799798    if( tr_bencDictFindInt( request, "tag", &i ) )
    800799        tr_bencDictAddInt( &response, "tag", i );
    801     out = tr_bencSaveAsJSON( &response, response_len );
     800    if( response_buf != NULL )
     801        tr_bencSaveAsJSON( &response, response_buf );
    802802    tr_bencFree( &response );
    803     return out;
    804 }
    805 
    806 char*
    807 tr_rpc_request_exec_json( tr_session * session,
    808                           const void * request_json,
    809                           int          request_len,
    810                           int        * response_len )
     803}
     804
     805void
     806tr_rpc_request_exec_json( tr_session      * session,
     807                          const void      * request_json,
     808                          int               request_len,
     809                          struct evbuffer * response )
    811810{
    812811    tr_benc top;
    813     int     have_content;
    814     char *  ret;
     812    int have_content;
    815813
    816814    if( request_len < 0 )
     
    818816
    819817    have_content = !tr_jsonParse( request_json, request_len, &top, NULL );
    820     ret = request_exec( session, have_content ? &top : NULL, response_len );
     818    request_exec( session, have_content ? &top : NULL, response );
    821819
    822820    if( have_content )
    823821        tr_bencFree( &top );
    824     return ret;
    825822}
    826823
     
    904901}
    905902
    906 char*
    907 tr_rpc_request_exec_uri( tr_session * session,
    908                          const void * request_uri,
    909                          int          request_len,
    910                          int        * response_len )
    911 {
    912     char *       ret = NULL;
     903void
     904tr_rpc_request_exec_uri( tr_session      * session,
     905                         const void      * request_uri,
     906                         int               request_len,
     907                         struct evbuffer * response )
     908{
    913909    tr_benc      top, * args;
    914910    char *       request = tr_strndup( request_uri, request_len );
     
    939935    }
    940936
    941     ret = request_exec( session, &top, response_len );
     937    request_exec( session, &top, response );
    942938
    943939    /* cleanup */
    944940    tr_bencFree( &top );
    945941    tr_free( request );
    946     return ret;
    947 }
    948 
     942}
  • trunk/libtransmission/rpcimpl.h

    r7404 r7552  
    1818***/
    1919
     20struct evbuffer;
    2021struct tr_benc;
    2122
    2223/* http://www.json.org/ */
    23 char*tr_rpc_request_exec_json( tr_session  * session,
    24                                const void  * request_json,
    25                                int           request_len,
    26                                int         * response_len );
     24void tr_rpc_request_exec_json( tr_session       * session,
     25                               const void       * request_json,
     26                               int                request_len,
     27                               struct evbuffer  * setme_response );
    2728
    2829/* see the RPC spec's "Request URI Notation" section */
    29 char*tr_rpc_request_exec_uri( tr_session  * session,
    30                               const void  * request_uri,
    31                               int           request_len,
    32                               int         * response_len );
     30void tr_rpc_request_exec_uri( tr_session        * session,
     31                              const void        * request_uri,
     32                               int                request_len,
     33                              struct evbuffer   * setme_response );
    3334
    3435void tr_rpc_parse_list_str( struct tr_benc * setme,
Note: See TracChangeset for help on using the changeset viewer.