Changeset 8155


Ignore:
Timestamp:
Apr 5, 2009, 6:02:11 PM (13 years ago)
Author:
charles
Message:

(trunk) change the bencode type enum to prevent OS-level collision

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/conf.c

    r8108 r8155  
    412412    if( g_file_get_contents( oldfile, &contents, &contents_len, NULL )
    413413      && !tr_bencLoad( contents, contents_len, &top, NULL )
    414       && top.type == TYPE_DICT )
     414      && tr_bencIsDict( &top ) )
    415415    {
    416416        unsigned int i;
  • trunk/libtransmission/bencode.c

    r8154 r8155  
    158158          size_t    count )
    159159{
    160     assert( TYPE_LIST == val->type || TYPE_DICT == val->type );
     160    assert( TR_TYPE_LIST == val->type || TR_TYPE_DICT == val->type );
    161161
    162162    if( val->val.l.count + count > val->val.l.alloc )
     
    194194
    195195    /* dictionary keys must be strings */
    196     if( ( parent->type == TYPE_DICT )
    197       && ( type != TYPE_STR )
     196    if( ( parent->type == TR_TYPE_DICT )
     197      && ( type != TR_TYPE_STR )
    198198      && ( !( parent->val.l.count % 2 ) ) )
    199199        return NULL;
     
    235235                return err;
    236236
    237             node = getNode( top, parentStack, TYPE_INT );
     237            node = getNode( top, parentStack, TR_TYPE_INT );
    238238            if( !node )
    239239                return EILSEQ;
     
    247247        else if( *buf == 'l' ) /* list */
    248248        {
    249             tr_benc * node = getNode( top, parentStack, TYPE_LIST );
     249            tr_benc * node = getNode( top, parentStack, TR_TYPE_LIST );
    250250            if( !node )
    251251                return EILSEQ;
    252             tr_bencInit( node, TYPE_LIST );
     252            tr_bencInit( node, TR_TYPE_LIST );
    253253            tr_ptrArrayAppend( parentStack, node );
    254254            ++buf;
     
    256256        else if( *buf == 'd' ) /* dict */
    257257        {
    258             tr_benc * node = getNode( top, parentStack, TYPE_DICT );
     258            tr_benc * node = getNode( top, parentStack, TR_TYPE_DICT );
    259259            if( !node )
    260260                return EILSEQ;
    261             tr_bencInit( node, TYPE_DICT );
     261            tr_bencInit( node, TR_TYPE_DICT );
    262262            tr_ptrArrayAppend( parentStack, node );
    263263            ++buf;
     
    292292                return err;
    293293
    294             node = getNode( top, parentStack, TYPE_STR );
     294            node = getNode( top, parentStack, TR_TYPE_STR );
    295295            if( !node )
    296296                return EILSEQ;
     
    366366            const tr_benc * child = val->val.l.vals + i;
    367367
    368             if( ( child->type == TYPE_STR )
     368            if( ( child->type == TR_TYPE_STR )
    369369              && ( child->val.s.i == len )
    370370              && !memcmp( child->val.s.s, key, len ) )
     
    515515{
    516516    tr_bool found = FALSE;
    517     tr_benc * child = tr_bencDictFindType( dict, key, TYPE_LIST );
     517    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_LIST );
    518518
    519519    if( child )
     
    531531{
    532532    tr_bool found = FALSE;
    533     tr_benc * child = tr_bencDictFindType( dict, key, TYPE_DICT );
     533    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_DICT );
    534534
    535535    if( child )
     
    547547{
    548548    tr_bool found = FALSE;
    549     tr_benc * child = tr_bencDictFindType( dict, key, TYPE_STR );
     549    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_STR );
    550550
    551551    if( child )
     
    566566{
    567567    tr_bool found = FALSE;
    568     tr_benc * child = tr_bencDictFindType( dict, key, TYPE_STR );
     568    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_STR );
    569569
    570570    if( child )
     
    587587                size_t       byteCount )
    588588{
    589     tr_bencInit( val, TYPE_STR );
     589    tr_bencInit( val, TR_TYPE_STR );
    590590    val->val.s.i = byteCount;
    591591    val->val.s.s = tr_memdup( src, byteCount );
     
    597597                int          len )
    598598{
    599     tr_bencInit( val, TYPE_STR );
     599    tr_bencInit( val, TR_TYPE_STR );
    600600
    601601    val->val.s.s = tr_strndup( str, len );
     
    612612tr_bencInitBool( tr_benc * b, int value )
    613613{
    614     tr_bencInit( b, TYPE_BOOL );
     614    tr_bencInit( b, TR_TYPE_BOOL );
    615615    b->val.b = value != 0;
    616616}
     
    619619tr_bencInitReal( tr_benc * b, double value )
    620620{
    621     tr_bencInit( b, TYPE_REAL );
     621    tr_bencInit( b, TR_TYPE_REAL );
    622622    b->val.d = value;
    623623}
     
    626626tr_bencInitInt( tr_benc * b, int64_t value )
    627627{
    628     tr_bencInit( b, TYPE_INT );
     628    tr_bencInit( b, TR_TYPE_INT );
    629629    b->val.i = value;
    630630}
     
    633633tr_bencInitList( tr_benc * b, size_t reserveCount )
    634634{
    635     tr_bencInit( b, TYPE_LIST );
     635    tr_bencInit( b, TR_TYPE_LIST );
    636636    return tr_bencListReserve( b, reserveCount );
    637637}
     
    647647tr_bencInitDict( tr_benc * b, size_t reserveCount )
    648648{
    649     tr_bencInit( b, TYPE_DICT );
     649    tr_bencInit( b, TR_TYPE_DICT );
    650650    return tr_bencDictReserve( b, reserveCount );
    651651}
     
    672672    item = &list->val.l.vals[list->val.l.count];
    673673    list->val.l.count++;
    674     tr_bencInit( item, TYPE_INT );
     674    tr_bencInit( item, TR_TYPE_INT );
    675675
    676676    return item;
     
    732732
    733733    itemval = dict->val.l.vals + dict->val.l.count++;
    734     tr_bencInit( itemval, TYPE_INT );
     734    tr_bencInit( itemval, TR_TYPE_INT );
    735735
    736736    return itemval;
     
    762762                   int64_t      val )
    763763{
    764     tr_benc * child = dictFindOrAdd( dict, key, TYPE_INT );
     764    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_INT );
    765765    tr_bencInitInt( child, val );
    766766    return child;
     
    770770tr_bencDictAddBool( tr_benc * dict, const char * key, tr_bool val )
    771771{
    772     tr_benc * child = dictFindOrAdd( dict, key, TYPE_BOOL );
     772    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_BOOL );
    773773    tr_bencInitBool( child, val );
    774774    return child;
     
    778778tr_bencDictAddReal( tr_benc * dict, const char * key, double val )
    779779{
    780     tr_benc * child = dictFindOrAdd( dict, key, TYPE_REAL );
     780    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_REAL );
    781781    tr_bencInitReal( child, val );
    782782    return child;
     
    10461046        if( val ) switch( val->type )
    10471047            {
    1048                 case TYPE_INT:
     1048                case TR_TYPE_INT:
    10491049                    walkFuncs->intFunc( val, user_data );
    10501050                    break;
    10511051
    1052                 case TYPE_BOOL:
     1052                case TR_TYPE_BOOL:
    10531053                    walkFuncs->boolFunc( val, user_data );
    10541054                    break;
    10551055
    1056                 case TYPE_REAL:
     1056                case TR_TYPE_REAL:
    10571057                    walkFuncs->realFunc( val, user_data );
    10581058                    break;
    10591059
    1060                 case TYPE_STR:
     1060                case TR_TYPE_STR:
    10611061                    walkFuncs->stringFunc( val, user_data );
    10621062                    break;
    10631063
    1064                 case TYPE_LIST:
     1064                case TR_TYPE_LIST:
    10651065                    if( val != node->val )
    10661066                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
     
    10691069                    break;
    10701070
    1071                 case TYPE_DICT:
     1071                case TR_TYPE_DICT:
    10721072                    if( val != node->val )
    10731073                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
     
    12561256        switch( parentState->bencType )
    12571257        {
    1258             case TYPE_DICT:
     1258            case TR_TYPE_DICT:
    12591259            {
    12601260                const int i = parentState->childIndex++;
     
    12691269            }
    12701270
    1271             case TYPE_LIST:
     1271            case TR_TYPE_LIST:
    12721272            {
    12731273                ++parentState->childIndex;
  • trunk/libtransmission/bencode.h

    r8154 r8155  
    2424enum
    2525{
    26     TYPE_INT  = 1,
    27     TYPE_STR  = 2,
    28     TYPE_LIST = 4,
    29     TYPE_DICT = 8,
    30     TYPE_BOOL = 16,
    31     TYPE_REAL = 32
     26    TR_TYPE_INT  = 1,
     27    TR_TYPE_STR  = 2,
     28    TR_TYPE_LIST = 4,
     29    TR_TYPE_DICT = 8,
     30    TR_TYPE_BOOL = 16,
     31    TR_TYPE_REAL = 32
    3232};
    3333
     
    181181
    182182static TR_INLINE tr_bool tr_bencIsType  ( const tr_benc * b, int type ) { return ( b != NULL ) && ( b->type == type ); }
    183 static TR_INLINE tr_bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_INT ); }
    184 static TR_INLINE tr_bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_DICT ); }
    185 static TR_INLINE tr_bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_LIST ); }
    186 static TR_INLINE tr_bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TYPE_STR ); }
    187 static TR_INLINE tr_bool tr_bencIsBool  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_BOOL ); }
    188 static TR_INLINE tr_bool tr_bencIsReal  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_REAL ); }
     183static TR_INLINE tr_bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_INT ); }
     184static TR_INLINE tr_bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_DICT ); }
     185static TR_INLINE tr_bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_LIST ); }
     186static TR_INLINE tr_bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_STR ); }
     187static TR_INLINE tr_bool tr_bencIsBool  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_BOOL ); }
     188static TR_INLINE tr_bool tr_bencIsReal  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_REAL ); }
    189189
    190190/**
  • trunk/libtransmission/tracker.c

    r8091 r8155  
    345345    const int peerCount = bePeers->val.l.count;
    346346
    347     assert( bePeers->type == TYPE_LIST );
     347    assert( tr_bencIsList( bePeers ) );
    348348
    349349    array = tr_new( uint8_t, peerCount * ( sizeof( tr_address ) + 2 ) );
     
    482482                const int allAreSeeds = incomplete == 0;
    483483
    484                 if( tmp->type == TYPE_STR ) /* "compact" extension */
     484                if( tr_bencIsString( tmp ) ) /* "compact" extension */
    485485                {
    486486                    publishNewPeersCompact( t, allAreSeeds, tmp->val.s.s,
    487487                                            tmp->val.s.i );
    488488                }
    489                 else if( tmp->type == TYPE_LIST ) /* original protocol */
     489                else if( tr_bencIsList( tmp ) ) /* original protocol */
    490490                {
    491491                    size_t    byteCount = 0;
     
    500500                const int allAreSeeds = incomplete == 0;
    501501               
    502                 if( tmp->type == TYPE_STR ) /* "compact" extension */
     502                if( tmp->type == TR_TYPE_STR ) /* "compact" extension */
    503503                {
    504504                    publishNewPeersCompact6( t, allAreSeeds, tmp->val.s.s,
Note: See TracChangeset for help on using the changeset viewer.