Changeset 8588


Ignore:
Timestamp:
Jun 2, 2009, 1:48:48 AM (13 years ago)
Author:
charles
Message:

(trunk) #2131: clean up benc read/write API

Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/daemon.c

    r8414 r8588  
    299299    if( dumpSettings )
    300300    {
    301         struct evbuffer * buf = tr_getBuffer( );
    302 
    303         tr_bencSaveAsJSON( &settings, buf, TRUE );
    304         fprintf( stderr, "%s", (char*)EVBUFFER_DATA(buf) );
    305 
    306         tr_releaseBuffer( buf );
     301        char * str = tr_bencToStr( &settings, TR_FMT_JSON, NULL );
     302        fprintf( stderr, "%s", str );
     303        tr_free( str );
    307304        return 0;
    308305    }
  • trunk/daemon/remote.c

    r8585 r8588  
    633633        if( addArg )
    634634        {
    635             struct evbuffer * buf = tr_getBuffer( );
    636             reqs[reqCount++] = tr_strdup( tr_bencSaveAsJSON( &top, buf, FALSE ) );
    637             tr_releaseBuffer( buf );
     635            reqs[reqCount++] = tr_bencToStr( &top, TR_FMT_JSON_LEAN, NULL );
    638636        }
    639637
  • trunk/gtk/conf.c

    r8580 r8588  
    429429
    430430    g_key_file_free( keyfile );
    431     tr_bencSaveJSONFile( new_file, &dict );
     431    tr_bencToFile( &dict, TR_FMT_JSON, new_file );
    432432    tr_bencFree( &dict );
    433433}
  • trunk/gtk/tr-core.c

    r8585 r8588  
    14451445tr_core_exec( TrCore * core, const tr_benc * top )
    14461446{
    1447     char * json = tr_bencToJSON( top, FALSE );
     1447    char * json = tr_bencToStr( top, TR_FMT_JSON_LEAN, NULL );
    14481448    tr_core_exec_json( core, json );
    14491449    tr_free( json );
  • trunk/libtransmission/bencode-test.c

    r8414 r8588  
    174174#endif
    175175        check( end == (const uint8_t*)str + len );
    176         saved = tr_bencSave( &val, &savedLen );
     176        saved = tr_bencToStr( &val, TR_FMT_BENC, &savedLen );
    177177        check( !strcmp( saved, str ) );
    178178        check( len == (size_t)savedLen );
     
    215215    check( tr_bencGetInt( &val.val.l.vals[2], &i ) );
    216216    check( i == 16 );
    217     saved = tr_bencSave( &val, &len );
     217    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
    218218    check( !strcmp( saved, (char*)buf ) );
    219219    tr_free( saved );
     
    231231    check( !err );
    232232    check( end == buf + 2 );
    233     saved = tr_bencSave( &val, &len );
     233    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
    234234    check( !strcmp( saved, "le" ) );
    235235    tr_free( saved );
     
    274274    check( ( child = tr_bencListChild( &val, 0 ) ) );
    275275    check( ( child2 = tr_bencListChild( child, 0 ) ) );
    276     saved = tr_bencSave( &val, &len );
     276    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
    277277    check( !strcmp( saved, "lld1:ai64e1:bi32eeee" ) );
    278278    tr_free( saved );
     
    285285    check( !err );
    286286    check( end == buf + 2 );
    287     saved = tr_bencSave( &val, &len );
     287    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
    288288    check( !strcmp( saved, "le" ) );
    289289    tr_free( saved );
     
    325325
    326326    tr_bencLoad( benc_str, strlen( benc_str ), &top, NULL );
    327     serialized = tr_bencSaveAsJSON( &top, buf, TRUE );
     327    tr_bencToBuf( &top, TR_FMT_JSON, buf );
     328    serialized = (char*) EVBUFFER_DATA( buf );
    328329    stripWhitespace( serialized );
    329330#if 0
     
    444445    check( !err );
    445446    check( end == in + ( depth * 2 ) );
    446     saved = tr_bencSave( &val, &len );
     447    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
    447448    check( !strcmp( saved, (char*)in ) );
    448449    tr_free( in );
     
    505506    tr_bencDictAddStr( &top, "this-is-a-string", "this-is-a-string" );
    506507
    507     benc = tr_bencSave( &top, &len );
     508    benc = tr_bencToStr( &top, TR_FMT_BENC, &len );
    508509    check( !strcmp( benc, "d14:this-is-a-booli1e14:this-is-a-real8:0.50000016:this-is-a-string16:this-is-a-string14:this-is-an-inti1234ee" ) )
    509510    check( !tr_bencParse( benc, benc+len, &top2, &end ) )
  • trunk/libtransmission/bencode.c

    r8586 r8588  
    1818#include <stdlib.h>
    1919#include <string.h>
     20#include <unistd.h> /* close() */
    2021
    2122#include <locale.h>
     
    11351136                                            saveContainerEndFunc };
    11361137
    1137 char*
    1138 tr_bencSave( const tr_benc * top,
    1139              int *           len )
    1140 {
    1141     char * ret;
    1142     struct evbuffer * out = tr_getBuffer( );
    1143 
    1144     bencWalk( top, &saveFuncs, out );
    1145 
    1146     if( len )
    1147         *len = EVBUFFER_LENGTH( out );
    1148     ret = tr_strndup( EVBUFFER_DATA( out ), EVBUFFER_LENGTH( out ) );
    1149 
    1150     tr_releaseBuffer( out );
    1151     return ret;
    1152 }
    1153 
    11541138/***
    11551139****
     
    12411225                if( !( i % 2 ) )
    12421226                    evbuffer_add( data->out, ": ", data->doIndent ? 2 : 1 );
    1243                 else
    1244                 {
     1227                else {
     1228                    const tr_bool isLast = parentState->childIndex == parentState->childCount;
     1229                    if( !isLast ) {
     1230                        evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
     1231                        jsonIndent( data );
     1232                    }
     1233                }
     1234                break;
     1235            }
     1236
     1237            case TR_TYPE_LIST:
     1238            {
     1239                const tr_bool isLast = ++parentState->childIndex == parentState->childCount;
     1240                if( !isLast ) {
    12451241                    evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
    12461242                    jsonIndent( data );
    12471243                }
    1248                 break;
    1249             }
    1250 
    1251             case TR_TYPE_LIST:
    1252             {
    1253                 ++parentState->childIndex;
    1254                 evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
    1255                 jsonIndent( data );
    12561244                break;
    12571245            }
     
    13961384                      void *          vdata )
    13971385{
    1398     size_t            i;
    13991386    struct jsonWalk * data = vdata;
    1400     char *            str;
    14011387    int               emptyContainer = FALSE;
    1402 
    1403     /* trim out the trailing comma, if any */
    1404     str = (char*) EVBUFFER_DATA( data->out );
    1405     for( i = EVBUFFER_LENGTH( data->out ) - 1; i > 0; --i )
    1406     {
    1407         if( isspace( str[i] ) ) continue;
    1408         if( str[i] == ',' )
    1409             EVBUFFER_LENGTH( data->out ) = i;
    1410         if( str[i] == '{' || str[i] == '[' )
    1411             emptyContainer = TRUE;
    1412         break;
    1413     }
    14141388
    14151389    jsonPopParent( data );
     
    14301404                                                jsonListBeginFunc,
    14311405                                                jsonContainerEndFunc };
    1432 
    1433 static void
    1434 tr_bencSaveAsJSONImpl( const tr_benc * top, struct evbuffer * out, tr_bool doIndent )
    1435 {
    1436     struct jsonWalk data;
    1437 
    1438     evbuffer_drain( out, EVBUFFER_LENGTH( out ) );
    1439 
    1440     data.doIndent = doIndent;
    1441     data.out = out;
    1442     data.parents = NULL;
    1443 
    1444     bencWalk( top, &jsonWalkFuncs, &data );
    1445 
    1446     if( EVBUFFER_LENGTH( out ) )
    1447         evbuffer_add_printf( out, "\n" );
    1448 }
    1449 
    1450 char*
    1451 tr_bencSaveAsJSON( const tr_benc * top, struct evbuffer * out, tr_bool doIndent )
    1452 {
    1453     tr_bencSaveAsJSONImpl( top, out, doIndent );
    1454     return (char*) EVBUFFER_DATA( out );
    1455 }
    1456 
    1457 char*
    1458 tr_bencToJSON( const tr_benc * top, tr_bool doIndent )
    1459 {
    1460     char * ret;
    1461     struct evbuffer * buf = evbuffer_new( );
    1462     tr_bencSaveAsJSON( top, buf, doIndent );
    1463     ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
    1464     evbuffer_free( buf );
    1465     return ret;
    1466 }
    14671406
    14681407/***
     
    15521491}
    15531492
    1554 /***
    1555 ****
    1556 ***/
    1557 
    1558 static int
    1559 saveFile( const char * filename, struct evbuffer * buf )
     1493/***
     1494****
     1495***/
     1496
     1497void
     1498tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode, struct evbuffer * buf )
     1499{
     1500    evbuffer_drain( buf, EVBUFFER_LENGTH( buf ) );
     1501
     1502    switch( mode )
     1503    {
     1504        case TR_FMT_BENC:
     1505            bencWalk( top, &saveFuncs, buf );
     1506            break;
     1507
     1508        case TR_FMT_JSON:
     1509        case TR_FMT_JSON_LEAN: {
     1510            struct jsonWalk data;
     1511            data.doIndent = mode==TR_FMT_JSON;
     1512            data.out = buf;
     1513            data.parents = NULL;
     1514            bencWalk( top, &jsonWalkFuncs, &data );
     1515            if( EVBUFFER_LENGTH( buf ) )
     1516                evbuffer_add_printf( buf, "\n" );
     1517            break;
     1518        }
     1519    }
     1520}
     1521
     1522char*
     1523tr_bencToStr( const tr_benc * top, tr_fmt_mode mode, int * len )
     1524{
     1525    char * ret;
     1526    struct evbuffer * buf = evbuffer_new( );
     1527    tr_bencToBuf( top, mode, buf );
     1528    ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
     1529    if( len != NULL )
     1530        *len = (int) EVBUFFER_LENGTH( buf );
     1531    evbuffer_free( buf );
     1532    return ret;
     1533}
     1534
     1535int
     1536tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
    15601537{
    15611538    int err = 0;
     
    15681545                filename, tr_strerror( errno ) );
    15691546    }
    1570     else if( evbuffer_write( buf, fd ) == -1 )
    1571     {
    1572         err = errno;
    1573         tr_err( _( "Couldn't save file \"%1$s\": %2$s" ),
    1574                filename, tr_strerror( errno ) );
    1575     }
    1576 
    1577     if( !err )
    1578         tr_dbg( "tr_bencSaveFile saved \"%s\"", filename );
    1579     if( fd >= 0 )
     1547    else
     1548    {
     1549        struct evbuffer * buf = evbuffer_new( );
     1550        tr_bencToBuf( top, mode, buf );
     1551        if( evbuffer_write( buf, fd ) == -1 )
     1552        {
     1553            err = errno;
     1554            tr_err( _( "Couldn't save file \"%1$s\": %2$s" ),
     1555                   filename, tr_strerror( errno ) );
     1556        }
     1557
     1558        if( !err )
     1559            tr_dbg( "tr_bencToFile saved \"%s\"", filename );
    15801560        close( fd );
    1581 
    1582     return err;
    1583 }
    1584 
    1585 int
    1586 tr_bencSaveFile( const char * filename, const tr_benc * top )
    1587 {
    1588     int err;
    1589     struct evbuffer * buf = evbuffer_new( );
    1590     bencWalk( top, &saveFuncs, buf );
    1591     err = saveFile( filename, buf );
    1592     evbuffer_free( buf );
    1593     return err;
    1594 }
    1595 
    1596 int
    1597 tr_bencSaveJSONFile( const char * filename, const tr_benc * top )
    1598 {
    1599     int err;
    1600     struct evbuffer * buf = evbuffer_new( );
    1601     tr_bencSaveAsJSONImpl( top, buf, TRUE );
    1602     err = saveFile( filename, buf );
    1603     evbuffer_free( buf );
     1561    }
     1562
    16041563    return err;
    16051564}
     
    16101569
    16111570int
    1612 tr_bencLoadFile( const char * filename, tr_benc * b )
    1613 {
    1614     int       err;
    1615     size_t    contentLen;
     1571tr_bencLoadFile( tr_benc * setme, tr_fmt_mode mode, const char * filename )
     1572{
     1573    int err;
     1574    size_t contentLen;
    16161575    uint8_t * content;
    16171576
     
    16211580    else if( !content )
    16221581        err = ENODATA;
    1623     else
    1624         err = tr_bencLoad( content, contentLen, b, NULL );
     1582    else {
     1583        if( mode == TR_FMT_BENC )
     1584            err = tr_bencLoad( content, contentLen, setme, NULL );
     1585        else
     1586            err = tr_jsonParse( filename, content, contentLen, setme, NULL );
     1587    }
    16251588
    16261589    tr_free( content );
    16271590    return err;
    16281591}
    1629 
    1630 int
    1631 tr_bencLoadJSONFile( const char * filename, tr_benc * b )
    1632 {
    1633     int        err;
    1634     size_t     contentLen;
    1635     uint8_t  * content;
    1636 
    1637     content = tr_loadFile( filename, &contentLen );
    1638     if( !content && errno )
    1639         err = errno;
    1640     else if( !content )
    1641         err = ENODATA;
    1642     else
    1643         err = tr_jsonParse( filename, content, contentLen, b, NULL );
    1644 
    1645     tr_free( content );
    1646     return err;
    1647 }
  • trunk/libtransmission/bencode.h

    r8586 r8588  
    9292                       char        ** setme_end );
    9393
    94 int       tr_bencLoadFile( const char * filename, tr_benc * setme );
    95 
    96 int       tr_bencLoadJSONFile( const char * filename, tr_benc * setme );
    97 
    9894void      tr_bencFree( tr_benc * );
    9995
    100 char*     tr_bencSave( const tr_benc * val, int * len );
    101 
    102 char*     tr_bencSaveAsJSON( const tr_benc * top, struct evbuffer * out, tr_bool doIndent );
    103 
    104 char*     tr_bencToJSON( const tr_benc * top, tr_bool doIndent );
    105 
    106 int       tr_bencSaveFile( const char * filename, const tr_benc * );
    107 
    108 int       tr_bencSaveJSONFile( const char * filename, const tr_benc * );
    109 
    11096void      tr_bencInitStr( tr_benc *, const void * str, int str_len );
    11197
     
    126112***/
    127113
    128 int       tr_bencListReserve( tr_benc *, size_t reserveCount );
     114typedef enum
     115{
     116    TR_FMT_BENC,
     117    TR_FMT_JSON,
     118    TR_FMT_JSON_LEAN /* saves bandwidth by omitting all whitespace. */
     119}
     120tr_fmt_mode;
     121
     122int tr_bencToFile( const tr_benc *, tr_fmt_mode, const char * filename );
     123
     124char* tr_bencToStr( const tr_benc *, tr_fmt_mode, int * len );
     125
     126void  tr_bencToBuf( const tr_benc *, tr_fmt_mode, struct evbuffer * );
     127
     128/* TR_FMT_JSON_LEAN and TR_FMT_JSON are equivalent in this function. */
     129int tr_bencLoadFile( tr_benc * setme, tr_fmt_mode, const char * filename );
     130
     131/***
     132****
     133***/
     134
     135int tr_bencListReserve( tr_benc *, size_t reserveCount );
    129136
    130137tr_benc * tr_bencListAdd( tr_benc * );
  • trunk/libtransmission/json-test.c

    r8585 r8588  
    4242    char            * json;
    4343    int               err;
    44     struct evbuffer * buf = tr_getBuffer( );
    4544
    4645    err = tr_jsonParse( NULL, in, strlen( in ), &top, NULL );
     
    7574    check( tr_bencDictFindStr( &top, "key", &str ) );
    7675    check( !strcmp( str, "Letöltések" ) );
    77     json = tr_bencSaveAsJSON( &top, buf, TRUE );
     76    json = tr_bencToStr( &top, TR_FMT_JSON, NULL );
    7877    if( !err )
    7978        tr_bencFree( &top );
     
    9089    tr_free( json );
    9190
    92     tr_releaseBuffer( buf );
    9391    return 0;
    9492}
  • trunk/libtransmission/makemeta.c

    r8181 r8588  
    418418    if( !builder->result && !builder->abortFlag )
    419419    {
    420         if( tr_bencSaveFile( builder->outputFile, &top ) )
     420        if( tr_bencToFile( &top, TR_FMT_BENC, builder->outputFile ) )
    421421        {
    422422            builder->my_errno = errno;
  • trunk/libtransmission/metainfo.c

    r8465 r8588  
    367367    else
    368368    {
    369         int    len;
    370         char * bstr = tr_bencSave( beInfo, &len );
     369        int len;
     370        char * bstr = tr_bencToStr( beInfo, TR_FMT_BENC, &len );
    371371        tr_sha1( inf->hash, bstr, len, NULL );
    372372        tr_sha1_to_hex( inf->hashString, inf->hash );
  • trunk/libtransmission/peer-msgs.c

    r8576 r8588  
    992992    if( pex )
    993993        tr_bencDictAddInt( m, "ut_pex", TR_LTEP_PEX );
    994     buf = tr_bencSave( &val, &len );
     994    buf = tr_bencToStr( &val, TR_FMT_BENC, &len );
    995995
    996996    tr_peerIoWriteUint32( msgs->peer->io, out, 2 * sizeof( uint8_t ) + len );
     
    20672067
    20682068            /* write the pex message */
    2069             benc = tr_bencSave( &val, &bencLen );
     2069            benc = tr_bencToStr( &val, TR_FMT_BENC, &bencLen );
    20702070            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + bencLen );
    20712071            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
  • trunk/libtransmission/resume.c

    r8254 r8588  
    513513
    514514    filename = getResumeFilename( tor );
    515     tr_bencSaveFile( filename, &top );
     515    tr_bencToFile( &top, TR_FMT_BENC, filename );
    516516    tr_free( filename );
    517517
     
    532532    filename = getResumeFilename( tor );
    533533
    534     if( tr_bencLoadFile( filename, &top ) )
     534    if( tr_bencLoadFile( &top, TR_FMT_BENC, filename ) )
    535535    {
    536536        tr_tordbg( tor, "Couldn't read \"%s\"; trying old format.",
  • trunk/libtransmission/rpc-server.c

    r8561 r8588  
    254254                tr_bencDictAddStr( args, "metainfo", b64 );
    255255                tr_bencDictAddBool( args, "paused", paused );
    256                 tr_bencSaveAsJSON( &top, json, FALSE );
     256                tr_bencToBuf( &top, TR_FMT_JSON_LEAN, json );
    257257                tr_rpc_request_exec_json( server->session,
    258258                                          EVBUFFER_DATA( json ),
  • trunk/libtransmission/rpcimpl.c

    r8585 r8588  
    8787tr_idle_function_done( struct tr_rpc_idle_data * data, const char * result )
    8888{
    89     struct evbuffer * buf = tr_getBuffer( );
     89    struct evbuffer * buf = evbuffer_new( );
    9090
    9191    if( result == NULL )
     
    9393    tr_bencDictAddStr( data->response, "result", result );
    9494
    95     tr_bencSaveAsJSON( data->response, buf, FALSE );
     95    tr_bencToBuf( data->response, TR_FMT_JSON_LEAN, buf );
    9696    (*data->callback)( data->session, (const char*)EVBUFFER_DATA(buf),
    9797                       EVBUFFER_LENGTH(buf), data->callback_user_data );
    9898
    99     tr_releaseBuffer( buf );
     99    evbuffer_free( buf );
    100100    tr_bencFree( data->response );
    101101    tr_free( data->response );
     
    13331333        int64_t tag;
    13341334        tr_benc response;
    1335         struct evbuffer * buf = tr_getBuffer( );
     1335        struct evbuffer * buf = evbuffer_new( );
    13361336
    13371337        tr_bencInitDict( &response, 3 );
     
    13401340        if( tr_bencDictFindInt( request, "tag", &tag ) )
    13411341            tr_bencDictAddInt( &response, "tag", tag );
    1342         tr_bencSaveAsJSON( &response, buf, FALSE );
     1342        tr_bencToBuf( &response, TR_FMT_JSON_LEAN, buf );
    13431343        (*callback)( session, (const char*)EVBUFFER_DATA(buf),
    13441344                     EVBUFFER_LENGTH( buf ), callback_user_data );
    13451345
    1346         tr_releaseBuffer( buf );
     1346        evbuffer_free( buf );
    13471347        tr_bencFree( &response );
    13481348    }
     
    13621362        if( tr_bencDictFindInt( request, "tag", &tag ) )
    13631363            tr_bencDictAddInt( &response, "tag", tag );
    1364         tr_bencSaveAsJSON( &response, buf, FALSE );
     1364        tr_bencToBuf( &response, TR_FMT_JSON_LEAN, buf );
    13651365        (*callback)( session, (const char*)EVBUFFER_DATA(buf),
    13661366                     EVBUFFER_LENGTH(buf), callback_user_data );
  • trunk/libtransmission/session.c

    r8555 r8588  
    477477    /* file settings override the defaults */
    478478    filename = tr_buildPath( configDir, "settings.json", NULL );
    479     if( !tr_bencLoadJSONFile( filename, &fileSettings ) ) {
     479    if( !tr_bencLoadFile( &fileSettings, TR_FMT_JSON, filename ) ) {
    480480        tr_bencMergeDicts( d, &fileSettings );
    481481        tr_bencFree( &fileSettings );
     
    502502    {
    503503        tr_benc fileSettings;
    504         if( !tr_bencLoadJSONFile( filename, &fileSettings ) )
     504        if( !tr_bencLoadFile( &fileSettings, TR_FMT_JSON, filename ) )
    505505        {
    506506            tr_bencMergeDicts( &settings, &fileSettings );
     
    522522
    523523    /* save the result */
    524     tr_bencSaveJSONFile( filename, &settings );
     524    tr_bencToFile( &settings, TR_FMT_JSON, filename );
    525525    tr_inf( "Saved \"%s\"", filename );
    526526
  • trunk/libtransmission/stats.c

    r7658 r8588  
    5252
    5353    filename = getFilename( session );
    54     loaded = !tr_bencLoadJSONFile( filename, &top );
     54    loaded = !tr_bencLoadFile( &top, TR_FMT_JSON, filename );
    5555    tr_free( filename );
    5656
     
    5858    {
    5959        filename = getOldFilename( session );
    60         loaded = !tr_bencLoadFile( filename, &top );
     60        loaded = !tr_bencLoadFile( &top, TR_FMT_BENC, filename );
    6161        tr_free( filename );
    6262    }
     
    9797    filename = getFilename( session );
    9898    tr_deepLog( __FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename );
    99     tr_bencSaveJSONFile( filename, &top );
     99    tr_bencToFile( &top, TR_FMT_JSON, filename );
    100100
    101101    tr_free( filename );
  • trunk/libtransmission/torrent.c

    r8559 r8588  
    661661        {
    662662            const char * filename = tor->info.torrent;
    663             tr_bencSaveFile( filename, val );
    664             tr_sessionSetTorrentFile( tor->session, tor->info.hashString,
    665                                       filename );
     663            tr_bencToFile( val, TR_FMT_BENC, filename );
     664            tr_sessionSetTorrentFile( tor->session, tor->info.hashString, filename );
    666665        }
    667666    }
     
    19481947
    19491948    /* save to the .torrent file */
    1950     if( !tr_bencLoadFile( tor->info.torrent, &metainfo ) )
     1949    if( !tr_bencLoadFile( &metainfo, TR_FMT_BENC, tor->info.torrent ) )
    19511950    {
    19521951        int       i;
     
    19861985
    19871986            tr_metainfoFree( &tmpInfo );
    1988             tr_bencSaveFile( tor->info.torrent, &metainfo );
     1987            tr_bencToFile( &metainfo, TR_FMT_BENC, tor->info.torrent );
    19891988        }
    19901989
  • trunk/libtransmission/tr-dht.c

    r8584 r8588  
    136136
    137137    dat_file = tr_buildPath( ss->configDir, "dht.dat", NULL );
    138     rc = tr_bencLoadFile(dat_file, &benc);
     138    rc = tr_bencLoadFile( &benc, TR_FMT_BENC, dat_file );
    139139    tr_free( dat_file );
    140140    if(rc == 0) {
     
    216216        tr_bencDictAddRaw( &benc, "nodes", compact, j );
    217217        dat_file = tr_buildPath( ss->configDir, "dht.dat", NULL );
    218         tr_bencSaveFile( dat_file, &benc );
     218        tr_bencToFile( &benc, TR_FMT_BENC, dat_file );
    219219        tr_free( dat_file );
    220220    }
  • trunk/qt/prefs.cc

    r8585 r8588  
    219219
    220220    /* write back out the serialized preferences */
    221     char * json = tr_bencToJSON( &top, TRUE );
    222     if( json && *json ) {
    223         file.open( QIODevice::WriteOnly | QIODevice::Text );
    224         file.write( json );
    225         file.close( );
    226     }
    227     tr_free( json );
     221    tr_bencToFile( &top, TR_FMT_JSON, file.fileName().toUtf8().constData() );
    228222    tr_bencFree( &top );
    229223}
  • trunk/qt/session.cc

    r8585 r8588  
    533533Session :: exec( const tr_benc * request )
    534534{
    535     char * str( tr_bencToJSON( request, FALSE ) );
     535    char * str = tr_bencToStr( request, TR_FMT_JSON_LEAN, NULL );
    536536    exec( str );
    537537    tr_free( str );
  • trunk/third-party/dht/dht.c

    r8482 r8588  
    321321
    322322/* Determine whether id1 or id2 is closer to ref */
    323 int
     323static int
    324324xorcmp(const unsigned char *id1, const unsigned char *id2,
    325325       const unsigned char *ref)
Note: See TracChangeset for help on using the changeset viewer.