Changeset 5643


Ignore:
Timestamp:
Apr 18, 2008, 4:23:59 PM (14 years ago)
Author:
charles
Message:

benc cleanup

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/torrents.c

    r5639 r5643  
    661661    const char * str;
    662662    int64_t      tmp;
    663     uint8_t   *  buf;
    664     size_t       len;
    665663    benc_val_t   top, * list;
    666664    int          ii;
    667665    struct tor * tor;
    668666
    669     buf = readfile( gl_state, &len );
    670     if( NULL == buf )
    671     {
    672         return -1;
    673     }
    674 
    675     if( tr_bencLoad( buf, len, &top, NULL ) )
    676     {
    677         free( buf );
     667    if( tr_bencLoadFile( gl_state, &top ) )
     668    {
    678669        errmsg( "failed to load bencoded data from %s", gl_state );
    679670        return -1;
    680671    }
    681     free( buf );
    682672
    683673    if( tr_bencDictFindInt( &top, "autostart", &tmp ) )
     
    752742savestate( void )
    753743{
    754     benc_val_t   top, * list, * tor;
     744    benc_val_t   top, * list;
    755745    struct tor * ii;
    756     uint8_t    * buf;
    757     int          len;
    758 
    759     tr_bencInit( &top, TYPE_DICT );
    760     if( tr_bencDictReserve( &top, 9 ) )
    761     {
    762       nomem:
    763         tr_bencFree( &top );
    764         errmsg( "failed to save state: failed to allocate memory" );
     746    int          torrentCount;
     747 
     748    torrentCount = 0;
     749    RB_FOREACH( ii, tortree, &gl_tree )
     750        ++torrentCount;
     751
     752    tr_bencInitDict( &top, 9 );
     753    tr_bencDictAddInt( &top, "autostart",         gl_autostart );
     754    tr_bencDictAddInt( &top, "port",              gl_port );
     755    tr_bencDictAddInt( &top, "default-pex",       gl_pex );
     756    tr_bencDictAddInt( &top, "port-mapping",      gl_mapping );
     757    tr_bencDictAddInt( &top, "upload-limit",      gl_uplimit );
     758    tr_bencDictAddInt( &top, "download-limit",    gl_downlimit );
     759    tr_bencDictAddStr( &top, "default-directory", gl_dir );
     760    tr_bencDictAddStr( &top, "encryption-mode",   TR_ENCRYPTION_REQUIRED == gl_crypto
     761                                                  ? "required" : "preferred" );
     762    list = tr_bencDictAddList( &top, "torrents", torrentCount );
     763
     764    RB_FOREACH( ii, tortree, &gl_tree )
     765    {
     766        const tr_info * inf = tr_torrentInfo( ii->tor );
     767        const tr_stat * st  = tr_torrentStat( ii->tor );
     768        tr_benc * tor = tr_bencListAddDict( list, 3 );
     769        tr_bencDictAddStr( tor, "hash", inf->hashString );
     770        tr_bencDictAddInt( tor, "paused", !TR_STATUS_IS_ACTIVE( st->status ) );
     771        tr_bencDictAddStr( tor, "directory", tr_torrentGetFolder( ii->tor ) );
     772    }
     773
     774    if( tr_bencSaveFile( gl_newstate, &top ) )
     775    {
     776        errnomsg( "failed to save state: failed to write to %s", gl_newstate );
    765777        return -1;
    766778    }
    767     tr_bencInitInt( tr_bencDictAdd( &top, "autostart" ),      gl_autostart );
    768     tr_bencInitInt( tr_bencDictAdd( &top, "port" ),           gl_port );
    769     tr_bencInitInt( tr_bencDictAdd( &top, "default-pex" ),    gl_pex );
    770     tr_bencInitInt( tr_bencDictAdd( &top, "port-mapping" ),   gl_mapping );
    771     tr_bencInitInt( tr_bencDictAdd( &top, "upload-limit" ),   gl_uplimit );
    772     tr_bencInitInt( tr_bencDictAdd( &top, "download-limit" ), gl_downlimit );
    773     tr_bencInitStr( tr_bencDictAdd( &top, "default-directory" ),
    774                     gl_dir, -1, 1 );
    775     if(TR_ENCRYPTION_REQUIRED == gl_crypto)
    776         tr_bencInitStr(tr_bencDictAdd(&top, "encryption-mode"), "required", -1, 1);
    777     else
    778         tr_bencInitStr(tr_bencDictAdd(&top, "encryption-mode"), "preferred", -1, 1);
    779     list = tr_bencDictAdd( &top, "torrents" );
    780     tr_bencInit( list, TYPE_LIST );
    781 
    782     len = 0;
    783     RB_FOREACH( ii, tortree, &gl_tree )
    784     {
    785         len++;
    786     }
    787     if( tr_bencListReserve( list, len ) )
    788     {
    789         goto nomem;
    790     }
    791 
    792     RB_FOREACH( ii, tortree, &gl_tree )
    793     {
    794         const tr_info * inf;
    795         const tr_stat * st;
    796         tor = tr_bencListAdd( list );
    797         assert( NULL != tor );
    798         tr_bencInit( tor, TYPE_DICT );
    799         inf    = tr_torrentInfo( ii->tor );
    800         st     = tr_torrentStat( ii->tor );
    801         if( tr_bencDictReserve( tor, 3 ) )
    802         {
    803             goto nomem;
    804         }
    805         tr_bencInitStr( tr_bencDictAdd( tor, "hash" ),
    806                         inf->hashString, 2 * SHA_DIGEST_LENGTH, 1 );
    807         tr_bencInitInt( tr_bencDictAdd( tor, "paused" ),
    808                         !TR_STATUS_IS_ACTIVE( st->status ) );
    809         tr_bencInitStr( tr_bencDictAdd( tor, "directory" ),
    810                         tr_torrentGetFolder( ii->tor ), -1, 1 );
    811     }
    812 
    813     buf = ( uint8_t * )tr_bencSave( &top, &len );
    814     SAFEBENCFREE( &top );
    815     if( NULL == buf )
    816     {
    817         errnomsg( "failed to save state: bencoding failed" );
    818         return -1;
    819     }
    820 
    821     if( 0 > writefile( gl_newstate, buf, len ) )
    822     {
    823         free( buf );
    824         return -1;
    825     }
    826     free( buf );
    827779
    828780    if( 0 > rename( gl_newstate, gl_state ) )
  • trunk/libtransmission/bencode.c

    r5627 r5643  
    451451}
    452452
    453 tr_benc*
    454 tr_bencDictAddInt( tr_benc * dict, const char * key, int64_t val )
    455 {
    456     tr_benc * child = tr_bencDictAdd( dict, key );
    457     tr_bencInitInt( child, val );
    458     return child;
    459 }
    460 
    461 tr_benc*
    462 tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
    463 {
    464     tr_benc * child = tr_bencDictAdd( dict, key );
    465     tr_bencInitStrDup( child, val );
    466     return child;
    467 }
    468 
    469 tr_benc*
    470 tr_bencDictAddList( tr_benc * dict, const char * key, int reserveCount )
    471 {
    472     tr_benc * child = tr_bencDictAdd( dict, key );
    473     tr_bencInitList( child, reserveCount );
    474     return child;
    475 }
    476 
    477 tr_benc*
    478 tr_bencDictAddDict( tr_benc * dict, const char * key, int reserveCount )
    479 {
    480     tr_benc * child = tr_bencDictAdd( dict, key );
    481     tr_bencInitDict( child, reserveCount );
    482     return child;
    483 }
    484 
    485453/***
    486454****
     
    574542    return item;
    575543}
    576 
    577544tr_benc *
    578 tr_bencListAddInt( tr_benc * list, int64_t i )
     545tr_bencListAddInt( tr_benc * list, int64_t val )
    579546{
    580547    tr_benc * node = tr_bencListAdd( list );
    581     tr_bencInitInt( node, i );
     548    tr_bencInitInt( node, val );
    582549    return node;
     550}
     551tr_benc *
     552tr_bencListAddStr( tr_benc * list, const char * val )
     553{
     554    tr_benc * node = tr_bencListAdd( list );
     555    tr_bencInitStrDup( node, val );
     556    return node;
     557}
     558tr_benc*
     559tr_bencListAddList( tr_benc * list, int reserveCount )
     560{
     561    tr_benc * child = tr_bencListAdd( list );
     562    tr_bencInitList( child, reserveCount );
     563    return child;
     564}
     565tr_benc*
     566tr_bencListAddDict( tr_benc * list, int reserveCount )
     567{
     568    tr_benc * child = tr_bencListAdd( list );
     569    tr_bencInitDict( child, reserveCount );
     570    return child;
    583571}
    584572
     
    598586
    599587    return itemval;
     588}
     589tr_benc*
     590tr_bencDictAddInt( tr_benc * dict, const char * key, int64_t val )
     591{
     592    tr_benc * child = tr_bencDictAdd( dict, key );
     593    tr_bencInitInt( child, val );
     594    return child;
     595}
     596tr_benc*
     597tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
     598{
     599    tr_benc * child = tr_bencDictAdd( dict, key );
     600    tr_bencInitStrDup( child, val );
     601    return child;
     602}
     603tr_benc*
     604tr_bencDictAddList( tr_benc * dict, const char * key, int reserveCount )
     605{
     606    tr_benc * child = tr_bencDictAdd( dict, key );
     607    tr_bencInitList( child, reserveCount );
     608    return child;
     609}
     610tr_benc*
     611tr_bencDictAddDict( tr_benc * dict, const char * key, int reserveCount )
     612{
     613    tr_benc * child = tr_bencDictAdd( dict, key );
     614    tr_bencInitDict( child, reserveCount );
     615    return child;
     616}
     617tr_benc*
     618tr_bencDictAddRaw( tr_benc * dict, const char * key, const void * src, size_t len )
     619{
     620    tr_benc * child = tr_bencDictAdd( dict, key );
     621    tr_bencInitRaw( child, src, len );
     622    return child;
    600623}
    601624
  • trunk/libtransmission/bencode.h

    r5627 r5643  
    102102tr_benc    * tr_bencListAdd( tr_benc  * list );
    103103tr_benc    * tr_bencListAddInt( tr_benc  * list, int64_t val );
     104tr_benc    * tr_bencListAddStr( tr_benc  * list, const char * val );
     105tr_benc    * tr_bencListAddList( tr_benc  * list, int reserveCount );
     106tr_benc    * tr_bencListAddDict( tr_benc  * list, int reserveCount );
    104107/* note: key must not be freed or modified while val is in use */
    105108tr_benc    * tr_bencDictAdd( tr_benc * dict, const char * key );
     
    108111tr_benc    * tr_bencDictAddList( tr_benc * dict, const char * key, int reserveCount );
    109112tr_benc    * tr_bencDictAddDict( tr_benc * dict, const char * key, int reserveCount );
     113tr_benc    * tr_bencDictAddRaw( tr_benc * dict, const char * key, const void *, size_t len );
    110114
    111115char*  tr_bencSave( const tr_benc * val, int * len );
  • trunk/libtransmission/ipcparse.c

    r5579 r5643  
    297297    {
    298298        tr_bencInitList( pk, 3 );
    299         tr_bencInitStr( tr_bencListAdd( pk ), MSGNAME( msg_id ), -1, 1 );
     299        tr_bencListAddStr( pk, MSGNAME( msg_id ) );
    300300        ret = tr_bencListAdd( pk );
    301301        if( 0 < tag )
    302             tr_bencInitInt( tr_bencListAdd( pk ), tag );
     302            tr_bencListAddInt( pk, tag );
    303303    }
    304304
     
    410410 
    411411    tr_bencInitDict( &pk, 1 );
    412     dict = tr_bencDictAdd( &pk, MSGNAME( IPC_MSG_VERSION ) );
    413 
    414     tr_bencInitDict( dict, 3 );
    415     tr_bencInitInt( tr_bencDictAdd( dict, "min" ), PROTO_VERS_MIN );
    416     tr_bencInitInt( tr_bencDictAdd( dict, "max" ), PROTO_VERS_MAX );
     412    dict = tr_bencDictAddDict( &pk, MSGNAME( IPC_MSG_VERSION ), 3 );
     413    tr_bencDictAddInt( dict, "min", PROTO_VERS_MIN );
     414    tr_bencDictAddInt( dict, "max", PROTO_VERS_MAX );
    417415    if( label )
    418         tr_bencInitStr( tr_bencDictAdd( dict, "label" ), label, -1, 1 );
     416        tr_bencDictAddStr( dict, "label", label );
    419417
    420418    ret = ipc_serialize( &pk, len );
     
    487485        tr_bencInitList( idlist, ii );
    488486        for( ii = 0; TORRENT_ID_VALID( ids[ii] ); ii++ )
    489             tr_bencInitInt( tr_bencListAdd( idlist ), ids[ii] );
     487            tr_bencListAddInt( idlist, ids[ii] );
    490488    }
    491489
     
    534532{
    535533    tr_bencInitDict( val, 4 );
    536     tr_bencInitStr( tr_bencDictAdd( val, "address" ),  tk->address,  -1, 1 );
    537     tr_bencInitInt( tr_bencDictAdd( val, "port" ),     tk->port );
    538     tr_bencInitStr( tr_bencDictAdd( val, "announce" ), tk->announce, -1, 1 );
     534    tr_bencDictAddStr( val, "address",  tk->address );
     535    tr_bencDictAddInt( val, "port",     tk->port );
     536    tr_bencDictAddStr( val, "announce", tk->announce );
    539537    if( tk->scrape )
    540         tr_bencInitStr( tr_bencDictAdd( val, "scrape" ), tk->scrape, -1, 1 );
     538        tr_bencDictAddStr( val, "scrape", tk->scrape );
    541539}
    542540
  • trunk/libtransmission/makemeta.c

    r5636 r5643  
    275275             tr_benc                         * uninitialized_path )
    276276{
    277     tr_benc *sub;
    278277    const char *pch, *prev;
    279278    const size_t topLen = strlen(topFile) + 1; /* +1 for '/' */
     
    299298        buf[pch-prev] = '\0';
    300299
    301         sub = tr_bencListAdd( uninitialized_path );
    302         tr_bencInitStrDup( sub, buf );
     300        tr_bencListAddStr( uninitialized_path, buf );
    303301
    304302        prev = pch + 1;
     
    309307
    310308static void
    311 makeFilesList( tr_benc                    * list,
    312                const tr_metainfo_builder  * builder )
    313 {
    314     uint32_t i = 0;
    315 
    316     tr_bencListReserve( list, builder->fileCount );
    317 
    318     for( i=0; i<builder->fileCount; ++i )
    319     {
    320         tr_benc * dict = tr_bencListAdd( list );
    321         tr_benc *length, *pathVal;
    322 
    323         tr_bencInitDict( dict, 2 );
    324         length = tr_bencDictAdd( dict, "length" );
    325         pathVal = tr_bencDictAdd( dict, "path" );
    326         getFileInfo( builder->top, &builder->files[i], length, pathVal );
    327     }
    328 }
    329 
    330 static void
    331309makeInfoDict ( tr_benc              * dict,
    332310               tr_metainfo_builder  * builder )
    333311{
    334312    uint8_t * pch;
    335     tr_benc * val;
    336313    char base[MAX_PATH_LENGTH];
    337314
     
    339316   
    340317    if ( builder->isSingleFile )
    341     {
    342         val = tr_bencDictAdd( dict, "length" );
    343         tr_bencInitInt( val, builder->files[0].size );
    344     }
    345     else
    346     {
    347         val = tr_bencDictAdd( dict, "files" );
    348         tr_bencInit( val, TYPE_LIST );
    349         makeFilesList( val, builder );
    350     }
    351 
    352     val = tr_bencDictAdd( dict, "name" );
     318        tr_bencDictAddInt( dict, "length", builder->files[0].size );
     319    else {
     320        uint32_t i;
     321        tr_benc * list = tr_bencDictAddList( dict, "files", builder->fileCount );
     322        for( i=0; i<builder->fileCount; ++i ) {
     323            tr_benc * dict = tr_bencListAddDict( list, 2 );
     324            tr_benc * length = tr_bencDictAdd( dict, "length" );
     325            tr_benc * pathVal = tr_bencDictAdd( dict, "path" );
     326            getFileInfo( builder->top, &builder->files[i], length, pathVal );
     327        }
     328    }
     329
    353330    strlcpy( base, builder->top, sizeof( base ) );
    354     tr_bencInitStrDup ( val, basename( base ) );
    355 
    356     val = tr_bencDictAdd( dict, "piece length" );
    357     tr_bencInitInt( val, builder->pieceSize );
    358 
    359     if( ( pch = getHashInfo( builder ) ) ) {
    360         val = tr_bencDictAdd( dict, "pieces" );
    361         tr_bencInitStr( val, pch, SHA_DIGEST_LENGTH * builder->pieceCount, 0 );
    362     }
    363 
    364     val = tr_bencDictAdd( dict, "private" );
    365     tr_bencInitInt( val, builder->isPrivate ? 1 : 0 );
     331    tr_bencDictAddStr( dict, "name", basename( base ) );
     332
     333    tr_bencDictAddInt( dict, "piece length", builder->pieceSize );
     334
     335    if(( pch = getHashInfo( builder ))) {
     336        tr_bencDictAddRaw( dict, "pieces", pch, SHA_DIGEST_LENGTH * builder->pieceCount );
     337        tr_free( pch );
     338    }
     339
     340    tr_bencDictAddInt( dict, "private", builder->isPrivate ? 1 : 0 );
    366341}
    367342
     
    370345{
    371346    int n = 5;
    372     tr_benc top, *val;
     347    tr_benc top;
    373348
    374349    if ( builder->comment && *builder->comment ) ++n;
    375350    tr_bencInitDict( &top, n );
    376351
    377     val = tr_bencDictAdd( &top, "announce" );
    378     tr_bencInitStrDup( val, builder->announce );
     352    tr_bencDictAddStr( &top, "announce", builder->announce );
     353
    379354    if( tr_httpParseURL( builder->announce, -1, NULL, NULL, NULL ) )
    380     {
    381355        builder->result = TR_MAKEMETA_URL;
    382     }
    383356   
    384357    if( !builder->result && !builder->abortFlag )
    385358    {
    386         if( builder->comment && *builder->comment ) {
    387             val = tr_bencDictAdd( &top, "comment" );
    388             tr_bencInitStrDup( val, builder->comment );
    389         }
    390 
    391         val = tr_bencDictAdd( &top, "created by" );
    392         tr_bencInitStrDup( val, TR_NAME "/" LONG_VERSION_STRING );
    393 
    394         val = tr_bencDictAdd( &top, "creation date" );
    395         tr_bencInitInt( val, time(0) );
    396 
    397         val = tr_bencDictAdd( &top, "encoding" );
    398         tr_bencInitStrDup( val, "UTF-8" );
    399 
    400         val = tr_bencDictAdd( &top, "info" );
    401         tr_bencInitDict( val, 666 );
    402         makeInfoDict( val, builder );
     359        if( builder->comment && *builder->comment )
     360            tr_bencDictAddStr( &top, "comment", builder->comment );
     361        tr_bencDictAddStr( &top, "created by", TR_NAME "/" LONG_VERSION_STRING );
     362        tr_bencDictAddInt( &top, "creation date", time(0) );
     363        tr_bencDictAddStr( &top, "encoding", "UTF-8" );
     364        makeInfoDict( tr_bencDictAddDict( &top, "info", 666 ), builder );
    403365    }
    404366
    405367    /* save the file */
    406368    if ( !builder->result && !builder->abortFlag ) {
    407         char * pch = tr_bencSave( &top, &n );
    408         FILE * fp = fopen( builder->outputFile, "wb+" );
    409         size_t nmemb = n;
    410         if( !fp || ( fwrite( pch, 1, nmemb, fp ) != nmemb ) ) {
     369        if( tr_bencSaveFile( builder->outputFile, &top ) ) {
    411370            builder->my_errno = errno;
    412371            strlcpy( builder->errfile, builder->outputFile, sizeof( builder->errfile ) );
    413372            builder->result = TR_MAKEMETA_IO_WRITE;
    414373        }
    415         if( fp )
    416             fclose( fp );
    417         tr_free( pch );
    418374    }
    419375
  • trunk/libtransmission/resume.c

    r5641 r5643  
    110110    list = tr_bencDictAddList( dict, KEY_DND, n );
    111111    for( i=0; i<n; ++i )
    112         tr_bencInitInt( tr_bencListAdd( list ), inf->files[i].dnd ? 1 : 0 );
     112        tr_bencListAddInt( list, inf->files[i].dnd ? 1 : 0 );
    113113}
    114114
     
    172172    list = tr_bencDictAddList( dict, KEY_PRIORITY, n );
    173173    for( i=0; i<n; ++i )
    174         tr_bencInitInt( tr_bencListAdd( list ), inf->files[i].priority );
     174        tr_bencListAddInt( list, inf->files[i].priority );
    175175}
    176176
  • trunk/libtransmission/stats.c

    r5611 r5643  
    2929};
    3030
     31static char*
     32getFilename( const tr_handle * handle, char * buf, size_t buflen )
     33{
     34    tr_buildPath( buf, buflen, tr_getConfigDir(handle), "stats.benc", NULL );
     35    return buf;
     36}
     37
    3138static void
    32 parseCumulativeStats( tr_session_stats  * setme,
    33                       const uint8_t     * content,
    34                       size_t              len )
     39loadCumulativeStats( const tr_handle * handle, tr_session_stats * setme )
    3540{
     41    char filename[MAX_PATH_LENGTH];
    3642    tr_benc top;
    3743
    38     if( !tr_bencLoad( content, len, &top, NULL ) )
     44    getFilename( handle, filename, sizeof(filename) );
     45    if( !tr_bencLoadFile( filename, &top ) )
    3946    {
    4047        int64_t i;
     
    5966}
    6067
    61 static char*
    62 getFilename( const tr_handle * handle, char * buf, size_t buflen )
    63 {
    64     tr_buildPath( buf, buflen, tr_getConfigDir(handle), "stats.benc", NULL );
    65     return buf;
    66 }
    67 
    68 static void
    69 loadCumulativeStats( const tr_handle * handle, tr_session_stats * setme )
    70 {
    71     size_t len;
    72     uint8_t * content;
    73     char filename[MAX_PATH_LENGTH];
    74 
    75     getFilename( handle, filename, sizeof(filename) );
    76     content = tr_loadFile( filename, &len );
    77     if( content != NULL )
    78         parseCumulativeStats( setme, content, len );
    79 
    80     tr_free( content );
    81 }
    82 
    8368static void
    8469saveCumulativeStats( const tr_handle * handle, const tr_session_stats * s )
     
    8873
    8974    tr_bencInitDict( &top, 5 );
    90     tr_bencInitInt( tr_bencDictAdd( &top, "uploaded-bytes" ), s->uploadedBytes );
    91     tr_bencInitInt( tr_bencDictAdd( &top, "downloaded-bytes" ), s->downloadedBytes );
    92     tr_bencInitInt( tr_bencDictAdd( &top, "files-added" ), s->filesAdded );
    93     tr_bencInitInt( tr_bencDictAdd( &top, "session-count" ), s->sessionCount );
    94     tr_bencInitInt( tr_bencDictAdd( &top, "seconds-active" ), s->secondsActive );
     75    tr_bencDictAddInt( &top, "uploaded-bytes",  s->uploadedBytes );
     76    tr_bencDictAddInt( &top, "downloaded-bytes", s->downloadedBytes );
     77    tr_bencDictAddInt( &top, "files-added",      s->filesAdded );
     78    tr_bencDictAddInt( &top, "session-count",    s->sessionCount );
     79    tr_bencDictAddInt( &top, "seconds-active",  s->secondsActive );
    9580
    9681    getFilename( handle, filename, sizeof(filename) );
Note: See TracChangeset for help on using the changeset viewer.