Changeset 8155

Timestamp:

Apr 5, 2009, 6:02:11 PM (14 years ago)

Author:

charles

Message:

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

Location:

trunk

Files:

• gtk/conf.c (modified) (1 diff)
• libtransmission/bencode.c (modified) (27 diffs)
• libtransmission/bencode.h (modified) (2 diffs)
• libtransmission/tracker.c (modified) (3 diffs)

trunk/gtk/conf.c

@@ -412 +412 @@
     if( g_file_get_contents( oldfile, &contents, &contents_len, NULL )
       && !tr_bencLoad( contents, contents_len, &top, NULL )
-      && top.type == TYPE_DICT )
+      && tr_bencIsDict( &top ) )
     {
         unsigned int i;

trunk/libtransmission/bencode.c

@@ -158 +158 @@
           size_t    count )
 {
-    assert( TYPE_LIST == val->type || TYPE_DICT == val->type );
+    assert( TR_TYPE_LIST == val->type || TR_TYPE_DICT == val->type );
 
     if( val->val.l.count + count > val->val.l.alloc )
@@ -194 +194 @@
 
     /* dictionary keys must be strings */
-    if( ( parent->type == TYPE_DICT )
-      && ( type != TYPE_STR )
+    if( ( parent->type == TR_TYPE_DICT )
+      && ( type != TR_TYPE_STR )
       && ( !( parent->val.l.count % 2 ) ) )
         return NULL;
@@ -235 +235 @@
                 return err;
 
-            node = getNode( top, parentStack, TYPE_INT );
+            node = getNode( top, parentStack, TR_TYPE_INT );
             if( !node )
                 return EILSEQ;
@@ -247 +247 @@
         else if( *buf == 'l' ) /* list */
         {
-            tr_benc * node = getNode( top, parentStack, TYPE_LIST );
+            tr_benc * node = getNode( top, parentStack, TR_TYPE_LIST );
             if( !node )
                 return EILSEQ;
-            tr_bencInit( node, TYPE_LIST );
+            tr_bencInit( node, TR_TYPE_LIST );
             tr_ptrArrayAppend( parentStack, node );
             ++buf;
@@ -256 +256 @@
         else if( *buf == 'd' ) /* dict */
         {
-            tr_benc * node = getNode( top, parentStack, TYPE_DICT );
+            tr_benc * node = getNode( top, parentStack, TR_TYPE_DICT );
             if( !node )
                 return EILSEQ;
-            tr_bencInit( node, TYPE_DICT );
+            tr_bencInit( node, TR_TYPE_DICT );
             tr_ptrArrayAppend( parentStack, node );
             ++buf;
@@ -292 +292 @@
                 return err;
 
-            node = getNode( top, parentStack, TYPE_STR );
+            node = getNode( top, parentStack, TR_TYPE_STR );
             if( !node )
                 return EILSEQ;
@@ -366 +366 @@
             const tr_benc * child = val->val.l.vals + i;
 
-            if( ( child->type == TYPE_STR )
+            if( ( child->type == TR_TYPE_STR )
               && ( child->val.s.i == len )
               && !memcmp( child->val.s.s, key, len ) )
@@ -515 +515 @@
 {
     tr_bool found = FALSE;
-    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_LIST );
+    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_LIST );
 
     if( child )
@@ -531 +531 @@
 {
     tr_bool found = FALSE;
-    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_DICT );
+    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_DICT );
 
     if( child )
@@ -547 +547 @@
 {
     tr_bool found = FALSE;
-    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_STR );
+    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_STR );
 
     if( child )
@@ -566 +566 @@
 {
     tr_bool found = FALSE;
-    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_STR );
+    tr_benc * child = tr_bencDictFindType( dict, key, TR_TYPE_STR );
 
     if( child )
@@ -587 +587 @@
                 size_t       byteCount )
 {
-    tr_bencInit( val, TYPE_STR );
+    tr_bencInit( val, TR_TYPE_STR );
     val->val.s.i = byteCount;
     val->val.s.s = tr_memdup( src, byteCount );
@@ -597 +597 @@
                 int          len )
 {
-    tr_bencInit( val, TYPE_STR );
+    tr_bencInit( val, TR_TYPE_STR );
 
     val->val.s.s = tr_strndup( str, len );
@@ -612 +612 @@
 tr_bencInitBool( tr_benc * b, int value )
 {
-    tr_bencInit( b, TYPE_BOOL );
+    tr_bencInit( b, TR_TYPE_BOOL );
     b->val.b = value != 0;
 }
@@ -619 +619 @@
 tr_bencInitReal( tr_benc * b, double value )
 {
-    tr_bencInit( b, TYPE_REAL );
+    tr_bencInit( b, TR_TYPE_REAL );
     b->val.d = value;
 }
@@ -626 +626 @@
 tr_bencInitInt( tr_benc * b, int64_t value )
 {
-    tr_bencInit( b, TYPE_INT );
+    tr_bencInit( b, TR_TYPE_INT );
     b->val.i = value;
 }
@@ -633 +633 @@
 tr_bencInitList( tr_benc * b, size_t reserveCount )
 {
-    tr_bencInit( b, TYPE_LIST );
+    tr_bencInit( b, TR_TYPE_LIST );
     return tr_bencListReserve( b, reserveCount );
 }
@@ -647 +647 @@
 tr_bencInitDict( tr_benc * b, size_t reserveCount )
 {
-    tr_bencInit( b, TYPE_DICT );
+    tr_bencInit( b, TR_TYPE_DICT );
     return tr_bencDictReserve( b, reserveCount );
 }
@@ -672 +672 @@
     item = &list->val.l.vals[list->val.l.count];
     list->val.l.count++;
-    tr_bencInit( item, TYPE_INT );
+    tr_bencInit( item, TR_TYPE_INT );
 
     return item;
@@ -732 +732 @@
 
     itemval = dict->val.l.vals + dict->val.l.count++;
-    tr_bencInit( itemval, TYPE_INT );
+    tr_bencInit( itemval, TR_TYPE_INT );
 
     return itemval;
@@ -762 +762 @@
                    int64_t      val )
 {
-    tr_benc * child = dictFindOrAdd( dict, key, TYPE_INT );
+    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_INT );
     tr_bencInitInt( child, val );
     return child;
@@ -770 +770 @@
 tr_bencDictAddBool( tr_benc * dict, const char * key, tr_bool val )
 {
-    tr_benc * child = dictFindOrAdd( dict, key, TYPE_BOOL );
+    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_BOOL );
     tr_bencInitBool( child, val );
     return child;
@@ -778 +778 @@
 tr_bencDictAddReal( tr_benc * dict, const char * key, double val )
 {
-    tr_benc * child = dictFindOrAdd( dict, key, TYPE_REAL );
+    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_REAL );
     tr_bencInitReal( child, val );
     return child;
@@ -1046 +1046 @@
         if( val ) switch( val->type )
             {
-                case TYPE_INT:
+                case TR_TYPE_INT:
                     walkFuncs->intFunc( val, user_data );
                     break;
 
-                case TYPE_BOOL:
+                case TR_TYPE_BOOL:
                     walkFuncs->boolFunc( val, user_data );
                     break;
 
-                case TYPE_REAL:
+                case TR_TYPE_REAL:
                     walkFuncs->realFunc( val, user_data );
                     break;
 
-                case TYPE_STR:
+                case TR_TYPE_STR:
                     walkFuncs->stringFunc( val, user_data );
                     break;
 
-                case TYPE_LIST:
+                case TR_TYPE_LIST:
                     if( val != node->val )
                         tr_ptrArrayAppend( &stack, nodeNew( val ) );
@@ -1069 +1069 @@
                     break;
 
-                case TYPE_DICT:
+                case TR_TYPE_DICT:
                     if( val != node->val )
                         tr_ptrArrayAppend( &stack, nodeNew( val ) );
@@ -1256 +1256 @@
         switch( parentState->bencType )
         {
-            case TYPE_DICT:
+            case TR_TYPE_DICT:
             {
                 const int i = parentState->childIndex++;
@@ -1269 +1269 @@
             }
 
-            case TYPE_LIST:
+            case TR_TYPE_LIST:
             {
                 ++parentState->childIndex;

trunk/libtransmission/bencode.h

@@ -24 +24 @@
 enum
 {
-    TYPE_INT  = 1,
-    TYPE_STR  = 2,
-    TYPE_LIST = 4,
-    TYPE_DICT = 8,
-    TYPE_BOOL = 16,
-    TYPE_REAL = 32
+    TR_TYPE_INT  = 1,
+    TR_TYPE_STR  = 2,
+    TR_TYPE_LIST = 4,
+    TR_TYPE_DICT = 8,
+    TR_TYPE_BOOL = 16,
+    TR_TYPE_REAL = 32
 };
 
@@ -181 +181 @@
 
 static TR_INLINE tr_bool tr_bencIsType  ( const tr_benc * b, int type ) { return ( b != NULL ) && ( b->type == type ); }
-static TR_INLINE tr_bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_INT ); }
-static TR_INLINE tr_bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_DICT ); }
-static TR_INLINE tr_bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_LIST ); }
-static TR_INLINE tr_bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TYPE_STR ); }
-static TR_INLINE tr_bool tr_bencIsBool  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_BOOL ); }
-static TR_INLINE tr_bool tr_bencIsReal  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_REAL ); }
+static TR_INLINE tr_bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_INT ); }
+static TR_INLINE tr_bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_DICT ); }
+static TR_INLINE tr_bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_LIST ); }
+static TR_INLINE tr_bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_STR ); }
+static TR_INLINE tr_bool tr_bencIsBool  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_BOOL ); }
+static TR_INLINE tr_bool tr_bencIsReal  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_REAL ); }
 
 /**

trunk/libtransmission/tracker.c

@@ -345 +345 @@
     const int peerCount = bePeers->val.l.count;
 
-    assert( bePeers->type == TYPE_LIST );
+    assert( tr_bencIsList( bePeers ) );
 
     array = tr_new( uint8_t, peerCount * ( sizeof( tr_address ) + 2 ) );
@@ -482 +482 @@
                 const int allAreSeeds = incomplete == 0;
 
-                if( tmp->type == TYPE_STR ) /* "compact" extension */
+                if( tr_bencIsString( tmp ) ) /* "compact" extension */
                 {
                     publishNewPeersCompact( t, allAreSeeds, tmp->val.s.s,
                                             tmp->val.s.i );
                 }
-                else if( tmp->type == TYPE_LIST ) /* original protocol */
+                else if( tr_bencIsList( tmp ) ) /* original protocol */
                 {
                     size_t    byteCount = 0;
@@ -500 +500 @@
                 const int allAreSeeds = incomplete == 0;
                 
-                if( tmp->type == TYPE_STR ) /* "compact" extension */
+                if( tmp->type == TR_TYPE_STR ) /* "compact" extension */
                 {
                     publishNewPeersCompact6( t, allAreSeeds, tmp->val.s.s,