Changeset 5127


Ignore:
Timestamp:
Feb 26, 2008, 9:58:58 PM (14 years ago)
Author:
charles
Message:

more housekeeping: benc_val_t --> tr_benc

Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/client.c

    r3578 r5127  
    4040#include <libtransmission/ipcparse.h>
    4141#include <libtransmission/trcompat.h>
     42#include <libtransmission/version.h>
    4243
    4344#include "bsdqueue.h"
  • trunk/gtk/conf.c

    r4404 r5127  
    301301    gchar * contents = NULL;
    302302    gsize contents_len = 0;
    303     benc_val_t top;
    304 
    305     memset( &top, 0, sizeof(benc_val_t) );
     303    tr_benc top;
     304
     305    memset( &top, 0, sizeof(tr_benc) );
    306306
    307307    if( g_file_get_contents( oldfile, &contents, &contents_len, NULL )
     
    312312        g_string_append( out, "\n[general]\n" );
    313313        for ( i=0; i<G_N_ELEMENTS(pref_table); ++i ) {
    314             const benc_val_t * val = tr_bencDictFind( &top, pref_table[i].oldkey );
     314            const tr_benc * val = tr_bencDictFind( &top, pref_table[i].oldkey );
    315315            if( val != NULL ) {
    316316                const char * valstr = val->val.s.s;
  • trunk/gtk/conf.h

    r4404 r5127  
    4848**/
    4949
    50 struct benc_val_s;
    51 
    5250gboolean
    5351cf_init(const char *confdir, char **errstr);
  • trunk/gtk/ipc.c

    r5125 r5127  
    112112
    113113static void
    114 all_default( enum ipc_msg id, benc_val_t * val UNUSED, int64_t tag, void * arg )
     114all_default( enum ipc_msg id, tr_benc * val UNUSED, int64_t tag, void * arg )
    115115{
    116116    switch( id )
     
    165165    uint8_t                * buf;
    166166    size_t                   size;
    167     benc_val_t               packet, * val;
     167    tr_benc               packet, * val;
    168168    int                      saved;
    169169
     
    492492
    493493static void
    494 smsg_add( enum ipc_msg id UNUSED, benc_val_t * val, int64_t tag, void * arg )
     494smsg_add( enum ipc_msg id UNUSED, tr_benc * val, int64_t tag, void * arg )
    495495{
    496496    struct constate      * con = arg;
    497497    struct constate_serv * srv = &con->u.serv;
    498     benc_val_t           * path;
     498    tr_benc           * path;
    499499    int                    ii;
    500500    tr_ctor              * ctor;
     
    530530
    531531static void
    532 smsg_addone( enum ipc_msg id UNUSED, benc_val_t * val, int64_t tag,
     532smsg_addone( enum ipc_msg id UNUSED, tr_benc * val, int64_t tag,
    533533             void * arg )
    534534{
    535535    struct constate      * con = arg;
    536536    struct constate_serv * srv = &con->u.serv;
    537     benc_val_t           * file, * data, * dir, * start;
     537    tr_benc           * file, * data, * dir, * start;
    538538    tr_ctor              * ctor;
    539539
     
    577577
    578578static void
    579 smsg_quit( enum ipc_msg id UNUSED, benc_val_t * val UNUSED, int64_t tag UNUSED,
     579smsg_quit( enum ipc_msg id UNUSED, tr_benc * val UNUSED, int64_t tag UNUSED,
    580580           void * arg UNUSED )
    581581{
     
    587587
    588588static void
    589 smsg_noop( enum ipc_msg id UNUSED, benc_val_t * val UNUSED, int64_t tag,
     589smsg_noop( enum ipc_msg id UNUSED, tr_benc * val UNUSED, int64_t tag,
    590590           void * arg )
    591591{
     
    627627static int
    628628addinfo( TrTorrent * tor, enum ipc_msg msgid, int torid, int types,
    629          benc_val_t * val )
     629         tr_benc * val )
    630630{
    631631    if( IPC_MSG_INFO == msgid )
     
    642642
    643643static void
    644 smsg_info( enum ipc_msg id, benc_val_t * val, int64_t tag, void * arg )
     644smsg_info( enum ipc_msg id, tr_benc * val, int64_t tag, void * arg )
    645645{
    646646    struct constate      * con = arg;
    647647    struct constate_serv * srv = &con->u.serv;
    648648    enum ipc_msg           respid;
    649     benc_val_t           * ids, * types, * idval, packet, * pkval;
     649    tr_benc           * ids, * types, * idval, packet, * pkval;
    650650    int                    typeflags, ii;
    651651    TrTorrent            * tor;
     
    705705
    706706static void
    707 smsg_infoall( enum ipc_msg id, benc_val_t * val, int64_t tag, void * arg )
     707smsg_infoall( enum ipc_msg id, tr_benc * val, int64_t tag, void * arg )
    708708{
    709709    struct constate      * con = arg;
    710710    struct constate_serv * srv = &con->u.serv;
    711711    enum ipc_msg           respid;
    712     benc_val_t             packet, * pkval;
     712    tr_benc             packet, * pkval;
    713713    int                    typeflags;
    714714    GtkTreeModel         * model;
     
    794794
    795795static void
    796 smsg_look( enum ipc_msg id UNUSED, benc_val_t * val, int64_t tag,
     796smsg_look( enum ipc_msg id UNUSED, tr_benc * val, int64_t tag,
    797797             void * arg )
    798798{
    799799    struct constate      * con = arg;
    800800    struct constate_serv * srv = &con->u.serv;
    801     benc_val_t             packet, * pkval, * hash;
     801    tr_benc             packet, * pkval, * hash;
    802802    int                    ii, torid;
    803803    TrTorrent            * tor;
     
    850850
    851851static void
    852 smsg_tor( enum ipc_msg id, benc_val_t * val, int64_t tag, void * arg )
     852smsg_tor( enum ipc_msg id, tr_benc * val, int64_t tag, void * arg )
    853853{
    854854    struct constate      * con = arg;
    855855    struct constate_serv * srv = &con->u.serv;
    856     benc_val_t           * idval;
     856    tr_benc           * idval;
    857857    TrTorrent            * tor;
    858858    GtkTreeIter            iter;
     
    897897
    898898static void
    899 smsg_torall( enum ipc_msg id, benc_val_t * val UNUSED, int64_t tag,
     899smsg_torall( enum ipc_msg id, tr_benc * val UNUSED, int64_t tag,
    900900             void * arg )
    901901{
     
    942942
    943943static void
    944 smsg_pref( enum ipc_msg id, benc_val_t * val UNUSED, int64_t tag, void * arg )
     944smsg_pref( enum ipc_msg id, tr_benc * val UNUSED, int64_t tag, void * arg )
    945945{
    946946    struct constate         * con = arg;
     
    10001000
    10011001static void
    1002 smsg_int( enum ipc_msg id, benc_val_t * val, int64_t tag, void * arg )
     1002smsg_int( enum ipc_msg id, tr_benc * val, int64_t tag, void * arg )
    10031003{
    10041004    struct constate      * con = arg;
     
    10541054
    10551055static void
    1056 smsg_str( enum ipc_msg id, benc_val_t * val, int64_t tag, void * arg )
     1056smsg_str( enum ipc_msg id, tr_benc * val, int64_t tag, void * arg )
    10571057{
    10581058    struct constate      * con = arg;
     
    10771077
    10781078static void
    1079 smsg_sup( enum ipc_msg id UNUSED, benc_val_t * val, int64_t tag, void * arg )
     1079smsg_sup( enum ipc_msg id UNUSED, tr_benc * val, int64_t tag, void * arg )
    10801080{
    10811081    struct constate      * con = arg;
    1082     benc_val_t             packet, * pkval, * name;
     1082    tr_benc                packet, * pkval, * name;
    10831083    int                    ii;
    10841084    enum ipc_msg           found;
  • trunk/libtransmission/bencode-test.c

    r5126 r5127  
    140140testString( const char * str, int isGood )
    141141{
    142     benc_val_t val;
     142    tr_benc val;
    143143    const uint8_t * end = NULL;
    144144    char * saved;
     
    163163testParse( void )
    164164{
    165     benc_val_t val;
    166     benc_val_t * child;
    167     benc_val_t * child2;
     165    tr_benc val;
     166    tr_benc * child;
     167    tr_benc * child2;
    168168    uint8_t buf[512];
    169169    const uint8_t * end;
     
    275275    uint8_t * in;
    276276    const uint8_t * end;
    277     benc_val_t val;
     277    tr_benc val;
    278278    char * saved;
    279279
  • trunk/libtransmission/bencode.c

    r4899 r5127  
    4242
    4343static int
    44 isType( const benc_val_t * val, int type )
     44isType( const tr_benc * val, int type )
    4545{
    4646    return ( ( val != NULL ) && ( val->type == type ) );
     
    5353
    5454static int
    55 isContainer( const benc_val_t * val )
     55isContainer( const tr_benc * val )
    5656{
    5757    return isList(val) || isDict(val);
    5858}
    5959static int
    60 isSomething( const benc_val_t * val )
     60isSomething( const tr_benc * val )
    6161{
    6262    return isContainer(val) || isInt(val) || isString(val);
     
    159159
    160160static int
    161 makeroom( benc_val_t * val, int count )
     161makeroom( tr_benc * val, int count )
    162162{
    163163    assert( TYPE_LIST == val->type || TYPE_DICT == val->type );
     
    168168        const int len = val->val.l.alloc + count +
    169169            ( count % LIST_SIZE ? LIST_SIZE - ( count % LIST_SIZE ) : 0 );
    170         void * new = realloc( val->val.l.vals, len * sizeof( benc_val_t ) );
     170        void * new = realloc( val->val.l.vals, len * sizeof( tr_benc ) );
    171171        if( NULL == new )
    172172            return 1;
     
    179179}
    180180
    181 static benc_val_t*
    182 getNode( benc_val_t * top, tr_ptrArray * parentStack, int type )
    183 {
    184     benc_val_t * parent;
     181static tr_benc*
     182getNode( tr_benc * top, tr_ptrArray * parentStack, int type )
     183{
     184    tr_benc * parent;
    185185
    186186    assert( top != NULL );
     
    211211tr_bencParse( const void     * buf_in,
    212212              const void     * bufend_in,
    213               benc_val_t     * top,
     213              tr_benc     * top,
    214214              const uint8_t ** setme_end )
    215215{
     
    231231            const uint8_t * end;
    232232            int err;
    233             benc_val_t * node;
     233            tr_benc * node;
    234234
    235235            if(( err = tr_bencParseInt( buf, bufend, &end, &val )))
     
    248248        else if( *buf=='l' ) /* list */
    249249        {
    250             benc_val_t * node = getNode( top, parentStack, TYPE_LIST );
     250            tr_benc * node = getNode( top, parentStack, TYPE_LIST );
    251251            if( !node )
    252252                return TR_ERROR;
     
    257257        else if( *buf=='d' ) /* dict */
    258258        {
    259             benc_val_t * node = getNode( top, parentStack, TYPE_DICT );
     259            tr_benc * node = getNode( top, parentStack, TYPE_DICT );
    260260            if( !node )
    261261                return TR_ERROR;
     
    266266        else if( *buf=='e' ) /* end of list or dict */
    267267        {
    268             benc_val_t * node;
     268            tr_benc * node;
    269269            ++buf;
    270270            if( tr_ptrArrayEmpty( parentStack ) )
     
    285285            size_t str_len;
    286286            int err;
    287             benc_val_t * node;
     287            tr_benc * node;
    288288
    289289            if(( err = tr_bencParseStr( buf, bufend, &end, &str, &str_len )))
     
    318318tr_bencLoad( const void  * buf_in,
    319319             int           buflen,
    320              benc_val_t  * setme_benc,
     320             tr_benc  * setme_benc,
    321321             char       ** setme_end )
    322322{
     
    333333***/
    334334
    335 benc_val_t *
    336 tr_bencDictFind( benc_val_t * val, const char * key )
     335tr_benc *
     336tr_bencDictFind( tr_benc * val, const char * key )
    337337{
    338338    int len, ii;
     
    357357}
    358358
    359 benc_val_t*
    360 tr_bencDictFindType( benc_val_t * val, const char * key, int type )
    361 {
    362     benc_val_t * ret = tr_bencDictFind( val, key );
     359tr_benc*
     360tr_bencDictFindType( tr_benc * val, const char * key, int type )
     361{
     362    tr_benc * ret = tr_bencDictFind( val, key );
    363363    return ret && ret->type == type ? ret : NULL;
    364364}
    365365
    366 benc_val_t *
    367 tr_bencDictFindFirst( benc_val_t * val, ... )
     366tr_benc *
     367tr_bencDictFindFirst( tr_benc * val, ... )
    368368{
    369369    const char * key;
    370     benc_val_t * ret;
     370    tr_benc * ret;
    371371    va_list      ap;
    372372
     
    381381}
    382382
    383 benc_val_t*
    384 tr_bencListGetNthChild( benc_val_t * val, int i )
    385 {
    386     benc_val_t * ret = NULL;
     383tr_benc*
     384tr_bencListGetNthChild( tr_benc * val, int i )
     385{
     386    tr_benc * ret = NULL;
    387387    if( isList( val ) && ( i >= 0 ) && ( i < val->val.l.count ) )
    388388        ret = val->val.l.vals + i;
     
    391391
    392392int64_t
    393 tr_bencGetInt ( const benc_val_t * val )
     393tr_bencGetInt ( const tr_benc * val )
    394394{
    395395    assert( isInt( val ) );
     
    398398
    399399char *
    400 tr_bencStealStr( benc_val_t * val )
     400tr_bencStealStr( tr_benc * val )
    401401{
    402402    assert( isString( val ) );
     
    410410
    411411void
    412 _tr_bencInitStr( benc_val_t * val, char * str, int len, int nofree )
     412_tr_bencInitStr( tr_benc * val, char * str, int len, int nofree )
    413413{
    414414    tr_bencInit( val, TYPE_STR );
     
    423423
    424424int
    425 tr_bencInitStrDup( benc_val_t * val, const char * str )
     425tr_bencInitStrDup( tr_benc * val, const char * str )
    426426{
    427427    char * newStr = tr_strdup( str );
     
    434434
    435435void
    436 tr_bencInitInt( benc_val_t * val, int64_t num )
     436tr_bencInitInt( tr_benc * val, int64_t num )
    437437{
    438438    tr_bencInit( val, TYPE_INT );
     
    441441
    442442int
    443 tr_bencListReserve( benc_val_t * val, int count )
     443tr_bencListReserve( tr_benc * val, int count )
    444444{
    445445    assert( isList( val ) );
     
    449449
    450450int
    451 tr_bencDictReserve( benc_val_t * val, int count )
     451tr_bencDictReserve( tr_benc * val, int count )
    452452{
    453453    assert( isDict( val ) );
     
    456456}
    457457
    458 benc_val_t *
    459 tr_bencListAdd( benc_val_t * list )
    460 {
    461     benc_val_t * item;
     458tr_benc *
     459tr_bencListAdd( tr_benc * list )
     460{
     461    tr_benc * item;
    462462
    463463    assert( isList( list ) );
     
    471471}
    472472
    473 benc_val_t *
    474 tr_bencDictAdd( benc_val_t * dict, const char * key )
    475 {
    476     benc_val_t * keyval, * itemval;
     473tr_benc *
     474tr_bencDictAdd( tr_benc * dict, const char * key )
     475{
     476    tr_benc * keyval, * itemval;
    477477
    478478    assert( isDict( dict ) );
     
    508508struct SaveNode
    509509{
    510     const benc_val_t * val;
     510    const tr_benc * val;
    511511    int valIsVisited;
    512512    int childCount;
     
    516516
    517517static struct SaveNode*
    518 nodeNewDict( const benc_val_t * val )
     518nodeNewDict( const tr_benc * val )
    519519{
    520520    int i, j;
     
    549549
    550550static struct SaveNode*
    551 nodeNewList( const benc_val_t * val )
     551nodeNewList( const tr_benc * val )
    552552{
    553553    int i, n;
     
    568568
    569569static struct SaveNode*
    570 nodeNewLeaf( const benc_val_t * val )
     570nodeNewLeaf( const tr_benc * val )
    571571{
    572572    struct SaveNode * node;
     
    580580
    581581static struct SaveNode*
    582 nodeNew( const benc_val_t * val )
     582nodeNew( const tr_benc * val )
    583583{
    584584    struct SaveNode * node;
     
    594594}
    595595
    596 typedef void (*BencWalkFunc)( const benc_val_t * val, void * user_data );
     596typedef void (*BencWalkFunc)( const tr_benc * val, void * user_data );
    597597
    598598struct WalkFuncs
     
    611611 */
    612612static void
    613 bencWalk( const benc_val_t   * top,
     613bencWalk( const tr_benc   * top,
    614614          struct WalkFuncs   * walkFuncs,
    615615          void               * user_data )
     
    621621    {
    622622        struct SaveNode * node = tr_ptrArrayBack( stack );
    623         const benc_val_t * val;
     623        const tr_benc * val;
    624624
    625625        if( !node->valIsVisited )
     
    682682
    683683static void
    684 saveIntFunc( const benc_val_t * val, void * evbuf )
     684saveIntFunc( const tr_benc * val, void * evbuf )
    685685{
    686686    evbuffer_add_printf( evbuf, "i%"PRId64"e", tr_bencGetInt(val) );
    687687}
    688688static void
    689 saveStringFunc( const benc_val_t * val, void * vevbuf )
     689saveStringFunc( const tr_benc * val, void * vevbuf )
    690690{
    691691    struct evbuffer * evbuf = vevbuf;
     
    694694}
    695695static void
    696 saveDictBeginFunc( const benc_val_t * val UNUSED, void * evbuf )
     696saveDictBeginFunc( const tr_benc * val UNUSED, void * evbuf )
    697697{
    698698    evbuffer_add_printf( evbuf, "d" );
    699699}
    700700static void
    701 saveListBeginFunc( const benc_val_t * val UNUSED, void * evbuf )
     701saveListBeginFunc( const tr_benc * val UNUSED, void * evbuf )
    702702{
    703703    evbuffer_add_printf( evbuf, "l" );
    704704}
    705705static void
    706 saveContainerEndFunc( const benc_val_t * val UNUSED, void * evbuf )
     706saveContainerEndFunc( const tr_benc * val UNUSED, void * evbuf )
    707707{
    708708    evbuffer_add_printf( evbuf, "e" );
    709709}
    710710char*
    711 tr_bencSave( const benc_val_t * top, int * len )
     711tr_bencSave( const tr_benc * top, int * len )
    712712{
    713713    char * ret;
     
    734734
    735735static void
    736 freeDummyFunc( const benc_val_t * val UNUSED, void * buf UNUSED  )
    737 {
    738 }
    739 static void
    740 freeStringFunc( const benc_val_t * val, void * freeme )
     736freeDummyFunc( const tr_benc * val UNUSED, void * buf UNUSED  )
     737{
     738}
     739static void
     740freeStringFunc( const tr_benc * val, void * freeme )
    741741{
    742742    if( !val->val.s.nofree )
     
    744744}
    745745static void
    746 freeContainerBeginFunc( const benc_val_t * val, void * freeme )
     746freeContainerBeginFunc( const tr_benc * val, void * freeme )
    747747{
    748748    tr_ptrArrayAppend( freeme, val->val.l.vals );
    749749}
    750750void
    751 tr_bencFree( benc_val_t * val )
     751tr_bencFree( tr_benc * val )
    752752{
    753753    if( val != NULL )
     
    783783}
    784784static void
    785 printIntFunc( const benc_val_t * val, void * vdata )
     785printIntFunc( const tr_benc * val, void * vdata )
    786786{
    787787    struct WalkPrint * data = vdata;
     
    790790}
    791791static void
    792 printStringFunc( const benc_val_t * val, void * vdata )
     792printStringFunc( const tr_benc * val, void * vdata )
    793793{
    794794    int ii;
     
    810810}
    811811static void
    812 printListBeginFunc( const benc_val_t * val UNUSED, void * vdata )
     812printListBeginFunc( const tr_benc * val UNUSED, void * vdata )
    813813{
    814814    struct WalkPrint * data = vdata;
     
    818818}
    819819static void
    820 printDictBeginFunc( const benc_val_t * val UNUSED, void * vdata )
     820printDictBeginFunc( const tr_benc * val UNUSED, void * vdata )
    821821{
    822822    struct WalkPrint * data = vdata;
     
    826826}
    827827static void
    828 printContainerEndFunc( const benc_val_t * val UNUSED, void * vdata )
     828printContainerEndFunc( const tr_benc * val UNUSED, void * vdata )
    829829{
    830830    struct WalkPrint * data = vdata;
     
    832832}
    833833void
    834 tr_bencPrint( benc_val_t * val )
     834tr_bencPrint( const tr_benc * val )
    835835{
    836836    struct WalkFuncs walkFuncs;
  • trunk/libtransmission/bencode.h

    r4898 r5127  
    2929#include <string.h> /* for memset */
    3030
    31 typedef struct benc_val_s
     31typedef struct tr_benc
    3232{
    3333#define TYPE_INT  1
     
    4949            int alloc;
    5050            int count;
    51             struct benc_val_s * vals;
     51            struct tr_benc * vals;
    5252        } l;
    5353    } val;
    54 } benc_val_t;
     54} tr_benc;
    5555
     56/* backwards compatability */
     57typedef tr_benc benc_val_t;
    5658
    57 int          tr_bencParse( const void      * buf,
    58                            const void      * bufend,
    59                            benc_val_t      * setme_benc,
    60                            const uint8_t  ** setme_end );
     59int tr_bencParse( const void      * buf,
     60                  const void      * bufend,
     61                  tr_benc         * setme_benc,
     62                  const uint8_t  ** setme_end );
    6163
    62 int          tr_bencLoad( const void  * buf,
    63                           int           buflen,
    64                           benc_val_t  * setme_benc,
    65                           char       ** setme_end );
     64int tr_bencLoad( const void  * buf,
     65                 int           buflen,
     66                 tr_benc     * setme_benc,
     67                 char       ** setme_end );
    6668
    67 void         tr_bencPrint( benc_val_t * val );
    68 void         tr_bencFree( benc_val_t * val );
    69 benc_val_t * tr_bencDictFind( benc_val_t * val, const char * key );
    70 benc_val_t * tr_bencDictFindType( benc_val_t * val, const char * key, int type );
    71 benc_val_t * tr_bencDictFindFirst( benc_val_t * val, ... );
     69void      tr_bencPrint( const tr_benc * );
     70void      tr_bencFree( tr_benc * );
     71tr_benc * tr_bencDictFind( tr_benc * dict, const char * key );
     72tr_benc * tr_bencDictFindType( tr_benc * dict, const char * key, int type );
     73tr_benc * tr_bencDictFindFirst( tr_benc * dict, ... );
    7274
    7375/* marks a string as 'do not free' and returns it */
    74 char *       tr_bencStealStr( benc_val_t * val );
     76char * tr_bencStealStr( tr_benc * val );
    7577
    76 /* convenience functions for building benc_val_t structures */
     78/* convenience functions for building tr_benc    structures */
    7779
    78 static inline void tr_bencInit( benc_val_t * val, int type )
     80static inline void tr_bencInit( tr_benc    * val, int type )
    7981{
    8082    memset( val, 0, sizeof( *val ) );
     
    8486#define tr_bencInitStr( a, b, c, d ) \
    8587    _tr_bencInitStr( (a), ( char * )(b), (c), (d) )
    86 void   _tr_bencInitStr( benc_val_t * val, char * str, int len, int nofree );
    87 int    tr_bencInitStrDup( benc_val_t * val, const char * str );
    88 void   tr_bencInitInt( benc_val_t * val, int64_t num );
    89 int   tr_bencListReserve( benc_val_t * list, int count );
     88void   _tr_bencInitStr( tr_benc * val, char * str, int len, int nofree );
     89int    tr_bencInitStrDup( tr_benc * val, const char * str );
     90void   tr_bencInitInt( tr_benc * val, int64_t num );
     91int   tr_bencListReserve( tr_benc * list, int count );
    9092/* note that for one key-value pair, count should be 1, not 2 */
    91 int   tr_bencDictReserve( benc_val_t * dict, int count );
    92 benc_val_t * tr_bencListAdd( benc_val_t * list );
     93int   tr_bencDictReserve( tr_benc * dict, int count );
     94tr_benc    * tr_bencListAdd( tr_benc * list );
    9395/* note: key must not be freed or modified while val is in use */
    94 benc_val_t * tr_bencDictAdd( benc_val_t * dict, const char * key );
     96tr_benc    * tr_bencDictAdd( tr_benc * dict, const char * key );
    9597
    96 char*  tr_bencSave( const benc_val_t * val, int * len );
     98char*  tr_bencSave( const tr_benc * val, int * len );
    9799
    98 int64_t  tr_bencGetInt ( const benc_val_t * val );
     100int64_t tr_bencGetInt( const tr_benc * val );
    99101
    100102
     
    119121**/
    120122
    121 benc_val_t* tr_bencListGetNthChild( benc_val_t * val, int i );
    122 
    123 
     123tr_benc * tr_bencListGetNthChild( tr_benc * list, int n );
    124124
    125125
  • trunk/libtransmission/ipcparse.c

    r4734 r5127  
    3131
    3232#include "transmission.h"
     33#include "bencode.h"
    3334#include "utils.h"
    3435
     
    219220};
    220221
    221 static int          handlevers ( struct ipc_info *, benc_val_t * );
    222 static int          handlemsgs ( struct ipc_info *, benc_val_t *, void * );
    223 static int          gotmsg     ( struct ipc_info *, benc_val_t *, benc_val_t *,
    224                                  benc_val_t *, void * );
     222static int          handlevers ( struct ipc_info *, tr_benc * );
     223static int          handlemsgs ( struct ipc_info *, tr_benc *, void * );
     224static int          gotmsg     ( struct ipc_info *, tr_benc *, tr_benc *,
     225                                 tr_benc *, void * );
    225226static int          msgcmp     ( struct msg *, struct msg * );
    226227static int          infcmp     ( struct inf *, struct inf * );
    227228static struct msg * msglookup  ( const char * );
    228 static int          filltracker( benc_val_t *, const tr_tracker_info * );
     229static int          filltracker( tr_benc *, const tr_tracker_info * );
    229230static int          handlercmp ( struct msgfunc *, struct msgfunc * );
    230231
     
    321322}
    322323
    323 benc_val_t *
     324tr_benc *
    324325ipc_initval( struct ipc_info * info, enum ipc_msg id, int64_t tag,
    325              benc_val_t * pk, int type )
    326 {
    327     benc_val_t * ret;
     326             tr_benc * pk, int type )
     327{
     328    tr_benc * ret;
    328329
    329330    assert( MSGVALID( id ) );
     
    365366
    366367uint8_t *
    367 ipc_mkval( benc_val_t * pk, size_t * setmeSize )
     368ipc_mkval( tr_benc * pk, size_t * setmeSize )
    368369{
    369370    int bencSize = 0;
     
    389390             int64_t tag )
    390391{
    391     benc_val_t pk;
     392    tr_benc pk;
    392393    uint8_t  * ret;
    393394
     
    407408           int64_t num )
    408409{
    409     benc_val_t pk, * val;
     410    tr_benc pk, * val;
    410411    uint8_t  * ret;
    411412
     
    427428           const char * str )
    428429{
    429     benc_val_t pk, * val;
     430    tr_benc pk, * val;
    430431    uint8_t  * ret;
    431432
     
    446447ipc_mkvers( size_t * len, const char * label )
    447448{
    448     benc_val_t pk, * dict;
     449    tr_benc pk, * dict;
    449450    uint8_t  * ret;
    450451 
     
    477478               int64_t tag, int types, const int * ids )
    478479{
    479     benc_val_t   pk, * top, * idlist, * typelist;
     480    tr_benc   pk, * top, * idlist, * typelist;
    480481    size_t       ii, typecount, used;
    481482    struct inf * typearray;
     
    572573
    573574int
    574 ipc_addinfo( benc_val_t * list, int tor, const tr_info * inf, int types )
    575 {
    576     benc_val_t * dict, * item, * file, * tier;
     575ipc_addinfo( tr_benc * list, int tor, const tr_info * inf, int types )
     576{
     577    tr_benc * dict, * item, * file, * tier;
    577578    int          ii, jj, kk;
    578579
     
    708709
    709710int
    710 ipc_addstat( benc_val_t * list, int tor,
     711ipc_addstat( tr_benc * list, int tor,
    711712             const tr_stat * st, int types )
    712713{
    713     benc_val_t  * dict, * item;
     714    tr_benc  * dict, * item;
    714715    int           ii, used;
    715716    tr_errno      error;
     
    916917    char        hex[IPC_MIN_MSG_LEN+1], * end;
    917918    ssize_t     off, len;
    918     benc_val_t  benc;
     919    tr_benc  benc;
    919920
    920921    for( off = 0; off + IPC_MIN_MSG_LEN < total; off += IPC_MIN_MSG_LEN + len )
     
    956957
    957958static int
    958 handlevers( struct ipc_info * info, benc_val_t * dict )
    959 {
    960     benc_val_t * vers, * num;
     959handlevers( struct ipc_info * info, tr_benc * dict )
     960{
     961    tr_benc * vers, * num;
    961962    int64_t      min, max;
    962963
     
    10161017
    10171018static int
    1018 handlemsgs( struct ipc_info * info, benc_val_t * pay, void * arg )
    1019 {
    1020     benc_val_t * name, * val, * tag;
     1019handlemsgs( struct ipc_info * info, tr_benc * pay, void * arg )
     1020{
     1021    tr_benc * name, * val, * tag;
    10211022    int          ii;
    10221023
     
    10631064
    10641065static int
    1065 gotmsg( struct ipc_info * info, benc_val_t * name, benc_val_t * val,
    1066         benc_val_t * tagval, void * arg )
     1066gotmsg( struct ipc_info * info, tr_benc * name, tr_benc * val,
     1067        tr_benc * tagval, void * arg )
    10671068{
    10681069    struct msgfunc key, * handler;
     
    11531154
    11541155int
    1155 ipc_infotypes( enum ipc_msg id, benc_val_t * list )
     1156ipc_infotypes( enum ipc_msg id, tr_benc * list )
    11561157{
    11571158    static struct inftree infotree = RB_INITIALIZER( &tree );
    11581159    static struct inftree stattree = RB_INITIALIZER( &tree );
    11591160    struct inftree * tree;
    1160     benc_val_t     * name;
     1161    tr_benc     * name;
    11611162    struct inf     * array, * inf, key;
    11621163    size_t           len, ii;
     
    12871288
    12881289static int
    1289 filltracker( benc_val_t * val, const tr_tracker_info * tk )
     1290filltracker( tr_benc * val, const tr_tracker_info * tk )
    12901291{
    12911292    tr_bencInit( val, TYPE_DICT );
  • trunk/libtransmission/ipcparse.h

    r4404 r5127  
    2828#include <inttypes.h>
    2929#include <unistd.h> /* for ssize_t */
    30 
    31 /* yay for typedefs, we can't forward declare benc_val_t or tr_info
    32    like with structs */
    33 #include "bencode.h"
    34 #include "transmission.h"
    3530
    3631#define IPC_MIN_MSG_LEN         ( 8 )
     
    126121struct ipc_info;
    127122struct strlist;
     123struct tr_info;
     124struct tr_benc;
     125struct tr_stat;
    128126
    129127struct ipc_info
     
    139137#define TORRENT_ID_VALID( id )  ( 0 < (id) && INT_MAX > (id) )
    140138
    141 typedef void ( *trd_msgfunc )( enum ipc_msg, benc_val_t *, int64_t, void * );
     139typedef void ( *trd_msgfunc )( enum ipc_msg, struct tr_benc *, int64_t, void * );
    142140
    143141/* any of these functions that can fail may set errno for any of the
     
    154152/* message creation */
    155153/* sets errno to EPERM if requested message not supported by protocol vers */
    156 benc_val_t * ipc_initval  ( struct ipc_info *, enum ipc_msg, int64_t,
    157                             benc_val_t *, int );
    158 uint8_t *    ipc_mkval    ( benc_val_t *, size_t * );
     154struct tr_benc * ipc_initval  ( struct ipc_info *, enum ipc_msg, int64_t,
     155                            struct tr_benc *, int );
     156uint8_t *    ipc_mkval    ( struct tr_benc *, size_t * );
    159157uint8_t *    ipc_mkempty  ( struct ipc_info *, size_t *, enum ipc_msg,
    160158                            int64_t );
     
    166164uint8_t *    ipc_mkgetinfo( struct ipc_info *, size_t *, enum ipc_msg, int64_t,
    167165                            int, const int * );
    168 int          ipc_addinfo  ( benc_val_t *, int, const tr_info *, int );
    169 int          ipc_addstat  ( benc_val_t *, int, const tr_stat *, int );
     166int          ipc_addinfo  ( struct tr_benc *, int, const struct tr_info *, int );
     167int          ipc_addstat  ( struct tr_benc *, int, const struct tr_stat *, int );
    170168
    171169/* sets errno to EINVAL on parse error or
     
    178176int          ipc_ishandled( struct ipc_info *, enum ipc_msg );
    179177int          ipc_havetags ( struct ipc_info * );
    180 int          ipc_infotypes( enum ipc_msg, benc_val_t * );
     178int          ipc_infotypes( enum ipc_msg, struct tr_benc * );
    181179const char * ipc_infoname ( enum ipc_msg, int );
    182180
  • trunk/libtransmission/makemeta.c

    r5085 r5127  
    259259getFileInfo( const char                      * topFile,
    260260             const tr_metainfo_builder_file  * file,
    261              benc_val_t                      * uninitialized_length,
    262              benc_val_t                      * uninitialized_path )
    263 {
    264     benc_val_t *sub;
     261             tr_benc                         * uninitialized_length,
     262             tr_benc                         * uninitialized_path )
     263{
     264    tr_benc *sub;
    265265    const char *pch, *prev;
    266266    const size_t topLen = strlen(topFile) + 1; /* +1 for '/' */
     
    297297
    298298static void
    299 makeFilesList( benc_val_t                 * list,
     299makeFilesList( tr_benc                    * list,
    300300               const tr_metainfo_builder  * builder )
    301301{
     
    306306    for( i=0; i<builder->fileCount; ++i )
    307307    {
    308         benc_val_t * dict = tr_bencListAdd( list );
    309         benc_val_t *length, *pathVal;
     308        tr_benc * dict = tr_bencListAdd( list );
     309        tr_benc *length, *pathVal;
    310310
    311311        tr_bencInit( dict, TYPE_DICT );
     
    318318
    319319static void
    320 makeInfoDict ( benc_val_t           * dict,
     320makeInfoDict ( tr_benc              * dict,
    321321               tr_metainfo_builder  * builder )
    322322{
    323323    uint8_t * pch;
    324     benc_val_t * val;
     324    tr_benc * val;
    325325    char base[MAX_PATH_LENGTH];
    326326
     
    357357{
    358358    int n = 5;
    359     benc_val_t top, *val;
     359    tr_benc top, *val;
    360360
    361361    tr_bencInit ( &top, TYPE_DICT );
  • trunk/libtransmission/metainfo.c

    r5112 r5127  
    7070 * Local prototypes
    7171 **********************************************************************/
    72 static int getannounce( tr_info * inf, benc_val_t * meta );
     72static int getannounce( tr_info * inf, tr_benc * meta );
    7373static char * announceToScrape( const char * announce );
    74 static int parseFiles( tr_info * inf, benc_val_t * name,
    75                        benc_val_t * files, benc_val_t * length );
     74static int parseFiles( tr_info * inf, tr_benc * name,
     75                       tr_benc * files, tr_benc * length );
    7676
    7777/***
     
    170170
    171171int
    172 tr_metainfoParse( tr_info * inf, const benc_val_t * meta_in, const char * tag )
     172tr_metainfoParse( tr_info * inf, const tr_benc * meta_in, const char * tag )
    173173{
    174174    int i;
    175     benc_val_t * beInfo, * val, * val2;
    176     benc_val_t * meta = (benc_val_t *) meta_in;
     175    tr_benc * beInfo, * val, * val2;
     176    tr_benc * meta = (tr_benc *) meta_in;
    177177    char buf[4096];
    178178
     
    326326}
    327327
    328 static int getfile( char ** setme,
    329                     const char * prefix, benc_val_t * name )
    330 {
    331     benc_val_t  * dir;
     328static int
     329getfile( char ** setme, const char * prefix, tr_benc * name )
     330{
     331    tr_benc     * dir;
    332332    const char ** list;
    333333    int           ii, jj;
     
    387387}
    388388
    389 static int getannounce( tr_info * inf, benc_val_t * meta )
    390 {
    391     benc_val_t        * val, * subval, * urlval;
     389static int getannounce( tr_info * inf, tr_benc * meta )
     390{
     391    tr_benc           * val, * subval, * urlval;
    392392    char              * address, * announce;
    393393    int                 ii, jj, port, random, subcount;
     
    627627
    628628static int
    629 parseFiles( tr_info * inf, benc_val_t * name,
    630             benc_val_t * files, benc_val_t * length )
    631 {
    632     benc_val_t * item, * path;
     629parseFiles( tr_info * inf, tr_benc * name,
     630            tr_benc * files, tr_benc * length )
     631{
     632    tr_benc * item, * path;
    633633    int ii;
    634634
  • trunk/libtransmission/metainfo.h

    r4404 r5127  
    2828#include "transmission.h"
    2929
    30 struct benc_val_t;
     30struct tr_benc;
    3131
    32 int tr_metainfoParse( tr_info *, const struct benc_val_s *, const char * tag );
     32int tr_metainfoParse( tr_info *, const struct tr_benc *, const char * tag );
    3333void tr_metainfoFree( tr_info * inf );
    3434void tr_metainfoRemoveSaved( const char * hashString, const char * tag );
  • trunk/libtransmission/peer-msgs.c

    r5065 r5127  
    768768sendLtepHandshake( tr_peermsgs * msgs )
    769769{
    770     benc_val_t val, *m;
     770    tr_benc val, *m;
    771771    char * buf;
    772772    int len;
     
    827827parseLtepHandshake( tr_peermsgs * msgs, int len, struct evbuffer * inbuf )
    828828{
    829     benc_val_t val, * sub;
     829    tr_benc val, * sub;
    830830    uint8_t * tmp = tr_new( uint8_t, len );
    831831
     
    876876    int gotval = 0;
    877877    uint8_t * tmp = tr_new( uint8_t, msglen );
    878     benc_val_t val, *sub;
     878    tr_benc val, *sub;
    879879    tr_peerIoReadBytes( msgs->io, inbuf, tmp, msglen );
    880880
     
    17351735        const int newCount = tr_peerMgrGetPeers( msgs->handle->peerMgr, msgs->torrent->info.hash, &newPex );
    17361736        PexDiffs diffs;
    1737         benc_val_t val, *added, *dropped, *flags;
     1737        tr_benc val, *added, *dropped, *flags;
    17381738        uint8_t *tmp, *walk;
    17391739        char * benc;
  • trunk/libtransmission/stats.c

    r5126 r5127  
    3434                      size_t              len )
    3535{
    36     benc_val_t top;
     36    tr_benc top;
    3737
    3838    if( !tr_bencLoad( content, len, &top, NULL ) )
    3939    {
    40         const benc_val_t * val;
     40        const tr_benc * val;
    4141
    4242        if(( val = tr_bencDictFindType( &top, "uploaded-bytes", TYPE_INT )))
     
    8888    char filename[MAX_PATH_LENGTH];
    8989    int len;
    90     benc_val_t top;
     90    tr_benc top;
    9191
    9292    tr_bencInit( &top, TYPE_DICT );
  • trunk/libtransmission/torrent-ctor.c

    r5126 r5127  
    88 * the Transmission project.
    99 *
    10  * $Id:$
     10 * $Id$
    1111 */
    1212
     
    3939    unsigned int isSet_metainfo : 1;
    4040    unsigned int isSet_delete : 1;
    41     benc_val_t metainfo;
     41    tr_benc metainfo;
    4242    char * sourceFile;
    4343
     
    105105    /* if no `name' field was set, then set it from the filename */
    106106    if( ctor->isSet_metainfo ) {
    107         benc_val_t * info = tr_bencDictFindType( &ctor->metainfo, "info", TYPE_DICT );
     107        tr_benc * info = tr_bencDictFindType( &ctor->metainfo, "info", TYPE_DICT );
    108108        if( info != NULL ) {
    109             benc_val_t * name = tr_bencDictFindFirst( info, "name.utf-8", "name", NULL );
     109            tr_benc * name = tr_bencDictFindFirst( info, "name.utf-8", "name", NULL );
    110110            if( name == NULL )
    111111                name = tr_bencDictAdd( info, "name" );
     
    266266
    267267int
    268 tr_ctorGetMetainfo( const tr_ctor              * ctor,
    269                     const struct benc_val_s   ** setme )
     268tr_ctorGetMetainfo( const tr_ctor    * ctor,
     269                    const tr_benc   ** setme )
    270270{
    271271    int err = 0;
  • trunk/libtransmission/torrent.c

    r5086 r5127  
    377377    /* maybe save our own copy of the metainfo */
    378378    if( tr_ctorGetSave( ctor ) ) {
    379         const benc_val_t * val;
     379        const tr_benc * val;
    380380        if( !tr_ctorGetMetainfo( ctor, &val ) ) {
    381381            int len;
     
    413413    int doFree;
    414414    tr_info tmp;
    415     const benc_val_t * metainfo;
     415    const tr_benc * metainfo;
    416416
    417417    if( setmeInfo == NULL )
  • trunk/libtransmission/tracker.c

    r5086 r5127  
    282282
    283283static int
    284 parseBencResponse( struct evhttp_request * req, benc_val_t * setme )
     284parseBencResponse( struct evhttp_request * req, tr_benc * setme )
    285285{
    286286    const unsigned char * body = EVBUFFER_DATA( req->input_buffer );
     
    363363/* Convert to compact form */
    364364static uint8_t *
    365 parseOldPeers( benc_val_t * bePeers, int * setmePeerCount )
     365parseOldPeers( tr_benc * bePeers, int * setmePeerCount )
    366366{
    367367    int i;
     
    377377        struct in_addr addr;
    378378        tr_port_t port;
    379         benc_val_t * val;
    380         benc_val_t * peer = &bePeers->val.l.vals[i];
     379        tr_benc * val;
     380        tr_benc * peer = &bePeers->val.l.vals[i];
    381381
    382382        val = tr_bencDictFind( peer, "ip" );
     
    429429    if( req && ( req->response_code == HTTP_OK ) )
    430430    {
    431         benc_val_t benc;
     431        tr_benc benc;
    432432        const int bencLoaded = !parseBencResponse( req, &benc );
    433433
     
    436436        if( bencLoaded && benc.type==TYPE_DICT )
    437437        {
    438             benc_val_t * tmp;
     438            tr_benc * tmp;
    439439
    440440            if(( tmp = tr_bencDictFind( &benc, "failure reason" ))) {
     
    595595    if( req && ( req->response_code == HTTP_OK ) )
    596596    {
    597         benc_val_t benc, *files;
     597        tr_benc benc, *files;
    598598        const int bencLoaded = !parseBencResponse( req, &benc );
    599599
     
    607607                const uint8_t* hash =
    608608                        (const uint8_t*) files->val.l.vals[i].val.s.s;
    609                 benc_val_t *tmp, *flags;
    610                 benc_val_t *tordict = &files->val.l.vals[i+1];
     609                tr_benc *tmp, *flags;
     610                tr_benc *tordict = &files->val.l.vals[i+1];
    611611                if( memcmp( t->hash, hash, SHA_DIGEST_LENGTH ) )
    612612                    continue;
  • trunk/libtransmission/transmission.h

    r5089 r5127  
    356356
    357357typedef struct tr_ctor tr_ctor;
    358 struct benc_val_s;
     358struct tr_benc;
    359359
    360360tr_ctor* tr_ctorNew                    ( const tr_handle  * handle);
     
    403403
    404404int      tr_ctorGetMetainfo            ( const tr_ctor  * ctor,
    405                                          const struct benc_val_s ** setme );
     405                                         const struct tr_benc ** setme );
    406406
    407407int      tr_ctorGetSave                ( const tr_ctor  * ctor );
Note: See TracChangeset for help on using the changeset viewer.