Changeset 1542


Ignore:
Timestamp:
Mar 8, 2007, 4:13:10 AM (16 years ago)
Author:
joshe
Message:

Remove some leftover debug code.

Location:
branches/pex/libtransmission
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/pex/libtransmission/peeraz.h

    r1541 r1542  
    9797}
    9898
    99 #ifdef AZDBG
    100 
    101 #define AZHEX( cc )             ( 10 > (cc) ? (cc) + '0' : (cc) - 10 + 'A' )
    102 
    103 static void
    104 dumplinear( benc_val_t * val, char ** buf, int * used, int * max )
    105 {
    106     int ii, jj;
    107     benc_val_t * sub;
    108 
    109     assert( TYPE_DICT == val->type || TYPE_LIST == val->type );
    110 
    111     for( ii = 0; ii < val->val.l.count; ii++ )
    112     {
    113         if( TYPE_DICT == val->type )
    114         {
    115             sub = &val->val.l.vals[ii];
    116             if( TYPE_STR != sub->type )
    117             {
    118                 tr_sprintf( buf, used, max, "???" /* silly trigraphs */ "=" );
    119             }
    120             else
    121             {
    122                 tr_sprintf( buf, used, max, "'%s'=", sub->val.s.s );
    123             }
    124             if( ii + 1 == val->val.l.count )
    125             {
    126                 break;
    127             }
    128             ii++;
    129         }
    130         sub = &val->val.l.vals[ii];
    131         switch( sub->type )
    132         {
    133             case TYPE_INT:
    134                 tr_sprintf( buf, used, max, "%" PRId64 " ", sub->val.i );
    135                 break;
    136             case TYPE_STR:
    137                 for( jj = 0; jj < sub->val.s.i && 0x20 <= sub->val.s.s[jj] &&
    138                          0x7f >= (unsigned)sub->val.s.s[jj]; jj++ )
    139                 {
    140                 }
    141                 if( jj < sub->val.s.i )
    142                 {
    143                     tr_concat( buf, used, max, "0x", 2 );
    144                     tr_concat( buf, used, max, NULL, sub->val.s.i * 2 );
    145                     for( jj = 0; jj < sub->val.s.i; jj++ )
    146                     {
    147                         (*buf)[ *used + jj * 2 ] =
    148                             AZHEX((((unsigned)sub->val.s.s[jj]) & 0xf0) >> 4 );
    149                         (*buf)[ *used + jj * 2 + 1] =
    150                             AZHEX( ((unsigned)sub->val.s.s[jj]) & 0x0f );
    151                     }
    152                     *used += sub->val.s.i * 2;
    153                     tr_concat( buf, used, max, " ", 1 );
    154                 }
    155                 else
    156                 {
    157                     tr_sprintf( buf, used, max, "'%s' ", sub->val.s.s );
    158                 }
    159                 break;
    160             case TYPE_LIST:
    161             case TYPE_DICT:
    162                 tr_sprintf( buf, used, max, "(" );
    163                 dumplinear( sub, buf, used, max );
    164                 tr_sprintf( buf, used, max, ") " );
    165                 break;
    166             default:
    167                 tr_sprintf( buf, used, max, "??? " );
    168                 break;
    169         }
    170     }
    171 }
    172 
    173 #undef  AZHEX
    174 #define AZF                    "az %s %*s:%5i "
    175 #define AZA                    label, sizeof( addr ), addr, port
    176 
    177 static void
    178 azdebug( tr_peer_t * peer, uint8_t * buf, int len, const char * label )
    179 {
    180     char addr[INET_ADDRSTRLEN], * fmt;
    181     int port, fmtused, fmtmax;
    182     benc_val_t val;
    183 
    184     tr_netNtop( &peer->addr, addr, sizeof( addr ) );
    185     port = ntohs( peer->port );
    186 
    187     if( tr_bencLoad( buf, len, &val, NULL ) )
    188     {
    189         printf( AZF "benc load failed for %p %i\n", AZA, buf, len );
    190         return;
    191     }
    192     if( TYPE_DICT != val.type )
    193     {
    194         printf( AZF "not a dictionary\n", AZA );
    195         tr_bencFree( &val );
    196         return;
    197     }
    198 
    199     fmt     = NULL;
    200     fmtused = 0;
    201     fmtmax  = 0;
    202     dumplinear( &val, &fmt, &fmtused, &fmtmax );
    203     printf( AZF "%s\n", AZA, fmt );
    204     free( fmt );
    205 
    206     tr_bencFree( &val );
    207     fflush( stdout );
    208 }
    209 #undef AZF
    210 #undef AZA
    211 
    212 #endif
    213 
    21499static char *
    215100makeAZHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * buflen )
    … …  
    309194    peer->advertisedPort = tor->publicPort;
    310195
    311 #ifdef AZDBG
    312     idx = azmsgIdIndex( AZ_MSG_AZ_HANDSHAKE );
    313     azdebug( peer, buf + ( 4 + 4 + azmsgLen( idx ) + 1 ),
    314                    len - ( 4 + 4 + azmsgLen( idx ) + 1 ), "hand send" );
    315 #endif
    316 
    317196    *buflen = len;
    318197    return buf;
    … …  
    359238    tr_bencInitStr( &val, tor->info.hash, sizeof( tor->info.hash ), 1 );
    360239    buf = makeCommonPex( tor, peer, len, peertreeToBencAZ, "infohash", &val );
    361 
    362 #ifdef AZDBG
    363     azdebug( peer, buf, *len, "pex  send" );
    364 #endif
    365240
    366241    return buf;
    … …  
    476351    int             ii, idx;
    477352
    478 #ifdef AZDBG
    479     azdebug( peer, buf, len, "hand recv" );
    480 #endif
    481 
    482353    if( tr_bencLoad( buf, len, &val, NULL ) )
    483354    {
    … …  
    568439    benc_val_t  val, * list, * pair;
    569440    int         ii;
    570 
    571 #ifdef AZDBG
    572     azdebug( peer, buf, len, "pex  recv" );
    573 #endif
    574441
    575442    if( peer->private )

  • branches/pex/libtransmission/peerext.h

    r1540 r1542  
    2626#define EXTENDED_PEX_ID         1
    2727
    28 #ifdef PEXDBG
    29 
    30 static void
    31 dumptree( tr_peertree_t * tree, const char * label )
    32 {
    33     tr_peertree_entry_t * ii;
    34     char addr[INET_ADDRSTRLEN];
    35     in_port_t port;
    36 
    37     printf( "tree %s:", label );
    38     for( ii = peertreeFirst( tree ); NULL != ii;
    39          ii = peertreeNext( tree, ii ) )
    40     {
    41         tr_netNtop( ( struct in_addr * )( ii->peer ),
    42                     addr, sizeof( addr ) );
    43         memcpy( &port, ii->peer + 4, 2 );
    44         printf( " %s:%hu", addr, ntohs( port ) );
    45     }
    46     printf( "\n" );
    47 }
    48 
    49 #define PEXF                    "pex %s %*s:%5i "
    50 #define PEXA                    label, sizeof( addr ), addr, port
    51 static void
    52 pexdebug( tr_peer_t * peer, uint8_t * buf, int len, const char * label )
    53 {
    54     char addr[INET_ADDRSTRLEN], peeraddr[INET_ADDRSTRLEN], * list, * fmt;
    55     int port, ii, jj, count, fmtused, fmtmax;
    56     benc_val_t val, * sub;
    57     const char * names[] = { "added", "dropped", NULL };
    58     int lengths[] = { 0, 0, 0 };
    59     in_port_t peerport;
    60 
    61     tr_netNtop( &peer->addr, addr, sizeof( addr ) );
    62     port = ntohs( peer->port );
    63 
    64     if( tr_bencLoad( buf, len, &val, NULL ) )
    65     {
    66         printf( PEXF "benc load failed for %p %i\n", PEXA, buf, len );
    67         return;
    68     }
    69     if( TYPE_DICT != val.type )
    70     {
    71         printf( PEXF "not a dictionary\n", PEXA );
    72         tr_bencFree( &val );
    73         return;
    74     }
    75 
    76     fmt     = NULL;
    77     fmtused = 0;
    78     fmtmax  = 0;
    79     for( ii = 0; ii < val.val.l.count; ii += 2 )
    80     {
    81         sub = &val.val.l.vals[ii];
    82         if( TYPE_STR != sub->type )
    83         {
    84             tr_sprintf( &fmt, &fmtused, &fmtmax, " ???" );
    85         }
    86         else
    87         {
    88             tr_sprintf( &fmt, &fmtused, &fmtmax, " '%s'", sub->val.s.s );
    89         }
    90     }
    91     printf( PEXF "dict keys:%s\n", PEXA, fmt );
    92     free( fmt );
    93 
    94     for( ii = 0; NULL != names[ii]; ii++ )
    95     {
    96         sub = tr_bencDictFind( &val, names[ii] );
    97         if( NULL == sub )
    98         {
    99             printf( PEXF "'%s' is missing\n", PEXA, names[ii] );
    100         }
    101         else if( TYPE_STR != sub->type )
    102         {
    103             printf( PEXF "'%s' is not a string\n", PEXA, names[ii] );
    104         }
    105         else if( 0 != sub->val.s.i % 6 )
    106         {
    107             printf( PEXF "'%s' is %i bytes, should be a multiple of 6\n",
    108                     PEXA, names[ii], sub->val.s.i );
    109         }
    110         else
    111         {
    112             lengths[ii] = sub->val.s.i / 6;
    113             list    = sub->val.s.s;
    114             count   = sub->val.s.i / 6;
    115             fmt     = NULL;
    116             fmtused = 0;
    117             fmtmax  = 0;
    118             for( jj = 0; jj < count; jj++ )
    119             {
    120                 tr_netNtop( ( struct in_addr * )( list + jj * 6 ),
    121                             peeraddr, sizeof( peeraddr ) );
    122                 memcpy( &peerport, list + jj * 6 + 4, 2 );
    123                 tr_sprintf( &fmt, &fmtused, &fmtmax, " %s:%hu", peeraddr,
    124                             ntohs( peerport ) );
    125             }
    126             printf( PEXF "'%s' list:%s\n", PEXA, names[ii], fmt );
    127             free( fmt );
    128         }
    129     }
    130 
    131     sub = tr_bencDictFind( &val, "added.f" );
    132     if( NULL != sub )
    133     {
    134         if( TYPE_STR != sub->type )
    135         {
    136             printf( PEXF "'added.f' is not a string\n", PEXA );
    137         }
    138         else if( 0 < sub->val.s.i && sub->val.s.i != lengths[0] )
    139         {
    140             printf( PEXF "'added.f' should be %i bytes but is %i\n",
    141                     PEXA, lengths[0], sub->val.s.i );
    142         }
    143         else
    144         {
    145 /*
    146             list    = sub->val.s.s;
    147             count   = sub->val.s.i;
    148             fmt     = NULL;
    149             fmtused = 0;
    150             fmtmax  = 0;
    151             for( jj = 0; jj < count; jj++ )
    152             {
    153                 tr_sprintf( &fmt, &fmtused, &fmtmax, " %02x", list[jj] );
    154             }
    155             printf( PEXF "'added.f' data:%s\n", PEXA, fmt );
    156             free( fmt );
    157 */
    158         }
    159     }
    160 
    161     tr_bencFree( &val );
    162     fflush( stdout );
    163 }
    164 #undef PEXF
    165 #undef PEXA
    166 
    167 #endif
    168 
    16928static char *
    17029makeCommonPex( tr_torrent_t * tor, tr_peer_t * peer, int * len,
    … …  
    346205    ret = makeCommonPex( tor, peer, len, peertreeToBencUT, "added.f", &val );
    347206
    348 #ifdef PEXDBG
    349     pexdebug( peer, ret, *len, "send" );
    350 #endif
    351 
    352207    return ret;
    353208}
    … …  
    403258    benc_val_t val, * sub;
    404259
    405 #ifdef PEXDBG
    406     pexdebug( peer, buf, len, "recv" );
    407 #endif
    408 
    409260    if( peer->private )
    410261    {
Note: See TracChangeset for help on using the changeset viewer.