Changeset 3735


Ignore:
Timestamp:
Nov 6, 2007, 9:14:30 PM (14 years ago)
Author:
charles
Message:

remove libtransmission code that duplicates functionality in libevent

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/torrents.c

    r3578 r3735  
    879879    }
    880880
    881     buf = ( uint8_t * )tr_bencSaveMalloc( &top, &len );
     881    buf = ( uint8_t * )tr_bencSave( &top, &len );
    882882    SAFEBENCFREE( &top );
    883883    if( NULL == buf )
  • trunk/libtransmission/bencode.c

    r3684 r3735  
    2929#include <stdlib.h>
    3030
     31#include <event.h>
     32
    3133#include "transmission.h"
    3234#include "bencode.h"
     
    391393}
    392394
    393 char * tr_bencSaveMalloc( benc_val_t * val, int * len )
    394 {
    395     char * buf   = NULL;
    396     int alloc = 0;
    397 
    398     *len = 0;
    399     if( tr_bencSave( val, &buf, len, &alloc ) )
    400     {
    401         if( NULL != buf )
    402         {
    403             free(buf);
    404         }
    405         *len = 0;
    406         return NULL;
    407     }
    408 
    409     return buf;
    410 }
    411 
    412 typedef struct
     395struct KeyIndex
    413396{
    414397    const char * key;
    415398    int index;
    416 }
    417 KeyIndex;
     399};
    418400
    419401static int compareKeyIndex( const void * va, const void * vb )
    420402{
    421     const KeyIndex * a = (const KeyIndex *) va;
    422     const KeyIndex * b = (const KeyIndex *) vb;
     403    const struct KeyIndex * a = va;
     404    const struct KeyIndex * b = vb;
    423405    return strcmp( a->key, b->key );
    424406}
    425407
    426 int tr_bencSave( benc_val_t * val, char ** buf, int * used, int * max )
    427 {
    428     int ii;   
     408static void
     409saveImpl( struct evbuffer * out, const benc_val_t * val )
     410{
     411    int ii;
    429412
    430413    switch( val->type )
    431414    {
    432415        case TYPE_INT:
    433             if( tr_sprintf( buf, used, max, "i%"PRId64"e", val->val.i ) )
    434                 return 1;
     416            evbuffer_add_printf( out, "i%"PRId64"e", val->val.i );
    435417            break;
    436418
    437419        case TYPE_STR:
    438             if( tr_sprintf( buf, used, max, "%i:", val->val.s.i ) ||
    439                 tr_concat( buf, used,  max, val->val.s.s, val->val.s.i ) )
    440                 return 1;
     420            evbuffer_add_printf( out, "i:%*.*s", val->val.i, val->val.i, val->val.i, val->val.s );
    441421            break;
    442422
    443423        case TYPE_LIST:
    444             if( tr_sprintf( buf, used, max, "l" ) )
    445                 return 1;
     424            evbuffer_add_printf( out, "l" );
    446425            for( ii = 0; val->val.l.count > ii; ii++ )
    447                 if( tr_bencSave( val->val.l.vals + ii, buf, used, max ) )
    448                     return 1;
    449             if( tr_sprintf( buf, used, max, "e" ) )
    450                 return 1;
     426                saveImpl( out, val->val.l.vals + ii );
     427            evbuffer_add_printf( out, "e" );
    451428            break;
    452429
     
    454431            /* Keys must be strings and appear in sorted order
    455432               (sorted as raw strings, not alphanumerics). */
    456             if( tr_sprintf( buf, used, max, "d" ) )
    457                 return 1;
     433            evbuffer_add_printf( out, "d" );
    458434            if( 1 ) {
    459435                int i;
    460                 KeyIndex * indices = tr_new( KeyIndex, val->val.l.count );
     436                struct KeyIndex * indices = tr_new( struct KeyIndex, val->val.l.count );
    461437                for( ii=i=0; i<val->val.l.count; i+=2 ) {
    462438                    indices[ii].key = val->val.l.vals[i].val.s.s;
     
    464440                    ii++;
    465441                }
    466                 qsort( indices, ii, sizeof(KeyIndex), compareKeyIndex );
     442                qsort( indices, ii, sizeof(struct KeyIndex), compareKeyIndex );
    467443                for( i=0; i<ii; ++i ) {
    468444                    const int index = indices[i].index;
    469                     if( tr_bencSave( val->val.l.vals + index,     buf, used, max ) ||
    470                         tr_bencSave( val->val.l.vals + index + 1, buf, used, max ) ) {
    471                         tr_free( indices );
    472                         return 1;
    473                     }
     445                    saveImpl( out, val->val.l.vals + index );
     446                    saveImpl( out, val->val.l.vals + index + 1 );
    474447                }
    475448                tr_free( indices );
    476             }
    477             if( tr_sprintf( buf, used, max, "e" ) )
    478                 return 1;
    479             break;
    480     }
    481 
    482     return 0;
     449            }
     450            evbuffer_add_printf( out, "e" );
     451            break;
     452    }
     453}
     454
     455char*
     456tr_bencSave( const benc_val_t * val, int * len )
     457{
     458    struct evbuffer * buf = evbuffer_new( );
     459    char * ret;
     460    saveImpl( buf, val );
     461    if( len != NULL )
     462        *len = EVBUFFER_LENGTH( buf );
     463    ret = tr_strndup( (char*) EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
     464    evbuffer_free( buf );
     465    return ret;
    483466}
    484467
  • trunk/libtransmission/bencode.h

    r3105 r3735  
    8787benc_val_t * tr_bencDictAdd( benc_val_t * dict, const char * key );
    8888
    89 char * tr_bencSaveMalloc( benc_val_t * val, int * len );
    90 int    tr_bencSave( benc_val_t * val, char ** buf,
    91                           int * used, int * max );
     89char*  tr_bencSave( const benc_val_t * val, int * len );
    9290
    9391int    tr_bencIsStr   ( const benc_val_t * val );
  • trunk/libtransmission/clients.c

    r3463 r3735  
    2828
    2929#include "transmission.h"
    30 #include "trcompat.h"
     30#include "utils.h"
    3131
    3232static int charToInt( char character )
     
    5555            if ( !memcmp( &id[3], "00", 2 ) )
    5656            {
    57                 asprintf( &ret, "Transmission 0.%d",
     57                tr_asprintf( &ret, "Transmission 0.%d",
    5858                        charToInt( id[5] ) * 10 + charToInt( id[6] ) );
    5959            }
    6060            else
    6161            {
    62                 asprintf( &ret, "Transmission %d.%c%c%s",
     62                tr_asprintf( &ret, "Transmission %d.%c%c%s",
    6363                        charToInt( id[3] ), id[4], id[5],
    6464                        id[6] == 'Z' ? "+" : "" );
     
    6767        else if( !memcmp( &id[1], "AZ", 2 ) )
    6868        {
    69             asprintf( &ret, "Azureus %c.%c.%c.%c",
     69            tr_asprintf( &ret, "Azureus %c.%c.%c.%c",
    7070                      id[3], id[4], id[5], id[6] );
    7171        }
    7272        else if( !memcmp( &id[1], "UT", 2 ) )
    7373        {
    74             asprintf( &ret, "\xc2\xb5Torrent %c.%d", id[3],
     74            tr_asprintf( &ret, "\xc2\xb5Torrent %c.%d", id[3],
    7575                      charToInt( id[4] ) * 10 + charToInt( id[5] ) );
    7676        }
    7777        else if( !memcmp( &id[1], "BC", 2 ) )
    7878        {
    79             asprintf( &ret, "BitComet %d.%c%c",
     79            tr_asprintf( &ret, "BitComet %d.%c%c",
    8080                      charToInt( id[3] ) * 10 + charToInt( id[4] ),
    8181                      id[5], id[6] );
     
    8383        else if( !memcmp( &id[1], "SZ", 2 ) || !memcmp( &id[1], "S~", 2 ) )
    8484        {
    85             asprintf( &ret, "Shareaza %c.%c.%c.%c",
     85            tr_asprintf( &ret, "Shareaza %c.%c.%c.%c",
    8686                      id[3], id[4], id[5], id[6] );
    8787        }
     
    9090            if( !memcmp( &id[4], "A0C", 3 ) )
    9191            {
    92                 asprintf( &ret, "Bits on Wheels 1.0.6" );
     92                tr_asprintf( &ret, "Bits on Wheels 1.0.6" );
    9393            }
    9494            else if( !memcmp( &id[4], "A0B", 3 ) )
    9595            {
    96                 asprintf( &ret, "Bits on Wheels 1.0.5" );
     96                tr_asprintf( &ret, "Bits on Wheels 1.0.5" );
    9797            }
    9898            else
    9999            {
    100                 asprintf( &ret, "Bits on Wheels (%c%c%c)",
     100                tr_asprintf( &ret, "Bits on Wheels (%c%c%c)",
    101101                        id[4], id[5], id[6] );
    102102            }
     
    104104        else if( !memcmp( &id[1], "BR", 2 ) )
    105105        {
    106             asprintf( &ret, "BitRocket %c.%c (%d)",
     106            tr_asprintf( &ret, "BitRocket %c.%c (%d)",
    107107                      id[3], id[4], charToInt( id[5] ) * 10 + charToInt( id[6] ) );
    108108        }
    109109        else if( !memcmp( &id[1], "XX", 2 ) )
    110110        {
    111             asprintf( &ret, "Xtorrent %c.%c (%d)",
     111            tr_asprintf( &ret, "Xtorrent %c.%c (%d)",
    112112                      id[3], id[4], charToInt( id[5] ) * 10 + charToInt( id[6] ) );
    113113        }
    114114        else if( !memcmp( &id[1], "TS", 2 ) )
    115115        {
    116             asprintf( &ret, "TorrentStorm %c.%c.%c.%c",
     116            tr_asprintf( &ret, "TorrentStorm %c.%c.%c.%c",
    117117                      id[3], id[4], id[5], id[6] );
    118118        }
     
    121121            if( id[5] == 'R' )
    122122            {
    123                 asprintf( &ret, "KTorrent %c.%c RC %c",
     123                tr_asprintf( &ret, "KTorrent %c.%c RC %c",
    124124                        id[3], id[4], id[6] );
    125125            }
    126126            else if( id[5] == 'D' )
    127127            {
    128                 asprintf( &ret, "KTorrent %c.%c Dev",
     128                tr_asprintf( &ret, "KTorrent %c.%c Dev",
    129129                        id[3], id[4] );
    130130            }
    131131            else
    132132            {
    133                 asprintf( &ret, "KTorrent %c.%c.%c",
     133                tr_asprintf( &ret, "KTorrent %c.%c.%c",
    134134                        id[3], id[4], id[5] );
    135135            }
     
    137137        else if( !memcmp( &id[1], "lt", 2 ) )
    138138        {
    139             asprintf( &ret, "libTorrent %d.%d.%d.%d",
     139            tr_asprintf( &ret, "libTorrent %d.%d.%d.%d",
    140140                      charToInt( id[3] ), charToInt( id[4] ),
    141141                      charToInt( id[5] ), charToInt( id[6] ) );
     
    143143        else if( !memcmp( &id[1], "LT", 2 ) )
    144144        {
    145             asprintf( &ret, "libtorrent %d.%d.%d.%d",
     145            tr_asprintf( &ret, "libtorrent %d.%d.%d.%d",
    146146                      charToInt( id[3] ), charToInt( id[4] ),
    147147                      charToInt( id[5] ), charToInt( id[6] ) );
     
    149149        else if( !memcmp( &id[1], "TT", 2 ) )
    150150        {
    151             asprintf( &ret, "TuoTu %c.%c.%c",
     151            tr_asprintf( &ret, "TuoTu %c.%c.%c",
    152152                      id[3], id[4], id[5] );
    153153        }
    154154                else if( !memcmp( &id[1], "ES", 2 ) )
    155155        {
    156             asprintf( &ret, "Electric Sheep %c.%c.%c",
     156            tr_asprintf( &ret, "Electric Sheep %c.%c.%c",
    157157                      id[3], id[4], id[5] );
    158158        }
    159159        else if( !memcmp( &id[1], "CD", 2 ) )
    160160        {
    161             asprintf( &ret, "Enhanced CTorrent %d.%d",
     161            tr_asprintf( &ret, "Enhanced CTorrent %d.%d",
    162162                      charToInt( id[3] ) * 10 + charToInt( id[4] ),
    163163                      charToInt( id[5] ) * 10 + charToInt( id[6] ) );
     
    165165                else if( !memcmp( &id[1], "CT", 2 ) )
    166166        {
    167             asprintf( &ret, "CTorrent %c.%c.%d",
     167            tr_asprintf( &ret, "CTorrent %c.%c.%d",
    168168                      id[3], id[4],
    169169                      charToInt( id[5] ) * 10 + charToInt( id[6] ) );
     
    171171        else if( !memcmp( &id[1], "LP", 2 ) )
    172172        {
    173             asprintf( &ret, "Lphant %d.%c%c",
     173            tr_asprintf( &ret, "Lphant %d.%c%c",
    174174                      charToInt( id[3] ) * 10 + charToInt( id[4] ),
    175175                      id[5], id[6] );
     
    177177        else if( !memcmp( &id[1], "AX", 2 ) )
    178178        {
    179             asprintf( &ret, "BitPump %d.%c%c",
     179            tr_asprintf( &ret, "BitPump %d.%c%c",
    180180                      charToInt( id[3] ) * 10 + charToInt( id[4] ),
    181181                      id[5], id[6] );
     
    183183        else if( !memcmp( &id[1], "DE", 2 ) )
    184184        {
    185             asprintf( &ret, "Deluge %d.%d.%d",
     185            tr_asprintf( &ret, "Deluge %d.%d.%d",
    186186                      charToInt( id[3] ), charToInt( id[4] ),
    187187                      charToInt( id[5] ) );
     
    189189        else if( !memcmp( &id[1], "AG", 2 ) )
    190190        {
    191             asprintf( &ret, "Ares Galaxy %d.%d.%d",
     191            tr_asprintf( &ret, "Ares Galaxy %d.%d.%d",
    192192                      charToInt( id[3] ), charToInt( id[4] ),
    193193                      charToInt( id[5] ) );
     
    195195        else if( !memcmp( &id[1], "HL", 2 ) )
    196196        {
    197             asprintf( &ret, "Halite %d.%d.%d",
     197            tr_asprintf( &ret, "Halite %d.%d.%d",
    198198                      charToInt( id[3] ), charToInt( id[4] ),
    199199                      charToInt( id[5] ) );
     
    201201        else if( !memcmp( &id[1], "AR", 2 ) )
    202202        {
    203             asprintf( &ret, "Arctic Torrent" );
     203            tr_asprintf( &ret, "Arctic Torrent" );
    204204        }
    205205        else if( !memcmp( &id[1], "BG", 2 ) )
    206206        {
    207             asprintf( &ret, "BTG %c.%c.%c.%c",
     207            tr_asprintf( &ret, "BTG %c.%c.%c.%c",
    208208                      id[3], id[4], id[5], id[6] );
    209209        }
    210210                else if( !memcmp( &id[1], "BB", 2 ) )
    211211        {
    212             asprintf( &ret, "BitBuddy %c.%c%c%c",
     212            tr_asprintf( &ret, "BitBuddy %c.%c%c%c",
    213213                      id[3], id[4], id[5], id[6] );
    214214        }
    215215                else if( !memcmp( &id[1], "qB", 2 ) )
    216216        {
    217             asprintf( &ret, "qBittorrent %d.%d.%d",
     217            tr_asprintf( &ret, "qBittorrent %d.%d.%d",
    218218                      charToInt( id[3] ), charToInt( id[4] ),
    219219                      charToInt( id[5] ) );
     
    221221        else if( !memcmp( &id[1], "BF", 2 ) )
    222222        {
    223             asprintf( &ret, "Bitflu (%d/%d/%02d)",
     223            tr_asprintf( &ret, "Bitflu (%d/%d/%02d)",
    224224                      charToInt( id[6] ),
    225225                      charToInt( id[4] ) * 10 + charToInt( id[5] ),
     
    228228        else if( !memcmp( &id[1], "FT", 2 ) )
    229229        {
    230             asprintf( &ret, "FoxTorrent (%c%c%c%c)",
     230            tr_asprintf( &ret, "FoxTorrent (%c%c%c%c)",
    231231                      id[3], id[4], id[5], id[6] );
    232232        }
    233233        else if( !memcmp( &id[1], "GR", 2 ) )
    234234        {
    235             asprintf( &ret, "GetRight %c.%c.%c.%c",
     235            tr_asprintf( &ret, "GetRight %c.%c.%c.%c",
    236236                      id[3], id[4], id[5], id[6] );
    237237        }
    238238        else if( !memcmp( &id[1], "PD", 2 ) )
    239239        {
    240             asprintf( &ret, "Pando %c.%c.%c.%c",
     240            tr_asprintf( &ret, "Pando %c.%c.%c.%c",
    241241                      id[3], id[4], id[5], id[6] );
    242242        }
    243243        else if( !memcmp( &id[1], "LW", 2 ) )
    244244        {
    245             asprintf( &ret, "LimeWire" );
     245            tr_asprintf( &ret, "LimeWire" );
    246246        }
    247247       
     
    257257        if( id[0] == 'T' )
    258258        {
    259             asprintf( &ret, "BitTornado %d.%d.%d", charToInt( id[1] ),
     259            tr_asprintf( &ret, "BitTornado %d.%d.%d", charToInt( id[1] ),
    260260                        charToInt( id[2] ), charToInt( id[3] ) );
    261261        }
    262262        else if( id[0] == 'A' )
    263263        {
    264             asprintf( &ret, "ABC %d.%d.%d", charToInt( id[1] ),
     264            tr_asprintf( &ret, "ABC %d.%d.%d", charToInt( id[1] ),
    265265                        charToInt( id[2] ), charToInt( id[3] ) );
    266266        }
    267267        else if( id[0] == 'R' )
    268268        {
    269             asprintf( &ret, "Tribler %c.%c", id[1], id[2] );
     269            tr_asprintf( &ret, "Tribler %c.%c", id[1], id[2] );
    270270        }
    271271        else if( id[0] == 'S' )
    272272        {
    273             asprintf( &ret, "Shad0w's Client %d.%d.%d", charToInt( id[1] ),
     273            tr_asprintf( &ret, "Shad0w's Client %d.%d.%d", charToInt( id[1] ),
    274274                        charToInt( id[2] ), charToInt( id[3] ) );
    275275        }
     
    286286        if( id[4] == '-' && id[6] == '-' )
    287287        {
    288             asprintf( &ret, "BitTorrent %c.%c.%c", id[1], id[3], id[5] );
     288            tr_asprintf( &ret, "BitTorrent %c.%c.%c", id[1], id[3], id[5] );
    289289        }
    290290        else if( id[5] == '-' )
    291291        {
    292             asprintf( &ret, "BitTorrent %c.%c%c.%c", id[1], id[3], id[4], id[6] );
     292            tr_asprintf( &ret, "BitTorrent %c.%c%c.%c", id[1], id[3], id[4], id[6] );
    293293        }
    294294       
     
    302302        if( id[4] == '-' && id[6] == '-' )
    303303        {
    304             asprintf( &ret, "Queen Bee %c.%c.%c", id[1], id[3], id[5] );
     304            tr_asprintf( &ret, "Queen Bee %c.%c.%c", id[1], id[3], id[5] );
    305305        }
    306306        else if( id[5] == '-' )
    307307        {
    308             asprintf( &ret, "Queen Bee %c.%c%c.%c", id[1], id[3], id[4], id[6] );
     308            tr_asprintf( &ret, "Queen Bee %c.%c%c.%c", id[1], id[3], id[4], id[6] );
    309309        }
    310310       
     
    318318    if( !memcmp( id, "exbc", 4 ) )
    319319    {
    320         asprintf( &ret, "%s %d.%02d",
     320        tr_asprintf( &ret, "%s %d.%02d",
    321321                    !memcmp( &id[6], "LORD", 4 ) ? "BitLord" : "BitComet",
    322322                    id[4], id[5] );
     
    324324    else if( !memcmp( id, "OP", 2 ) )
    325325    {
    326         asprintf( &ret, "Opera (%c%c%c%c)", id[2], id[3], id[4], id[5] );
     326        tr_asprintf( &ret, "Opera (%c%c%c%c)", id[2], id[3], id[4], id[5] );
    327327    }
    328328    else if( !memcmp( id, "-ML", 3 ) )
    329329    {
    330         asprintf( &ret, "MLDonkey %c%c%c%c%c",
     330        tr_asprintf( &ret, "MLDonkey %c%c%c%c%c",
    331331                  id[3], id[4], id[5], id[6], id[7] );
    332332    }
    333333    else if( !memcmp( id, "AZ", 2 ) && !memcmp( &id[6], "BT", 2 ) )
    334334    {
    335         asprintf( &ret, "BitTyrant %c.%c.%c.%c",
     335        tr_asprintf( &ret, "BitTyrant %c.%c.%c.%c",
    336336                    id[2], id[3], id[4], id[5] );
    337337    }
    338338    else if( !memcmp( id, "-FG", 3 ) )
    339339    {
    340         asprintf( &ret, "FlashGet %d.%c%c",
     340        tr_asprintf( &ret, "FlashGet %d.%c%c",
    341341                  charToInt( id[3] ) * 10 + charToInt( id[4] ),
    342342                      id[5], id[6] );
     
    344344    else if( !memcmp( id, "DNA", 3 ) )
    345345    {
    346         asprintf( &ret, "BitTorrent DNA %d.%d.%d", charToInt( id[3] ) * 10 + charToInt( id[4] ),
     346        tr_asprintf( &ret, "BitTorrent DNA %d.%d.%d", charToInt( id[3] ) * 10 + charToInt( id[4] ),
    347347                    charToInt( id[5] ) * 10 + charToInt( id[6] ), charToInt( id[7] ) * 10 + charToInt( id[8] ) );
    348348    }
    349349    else if( !memcmp( id, "Plus", 4 ) )
    350350    {
    351         asprintf( &ret, "Plus! v2 %c.%c%c", id[4], id[5], id[6] );
     351        tr_asprintf( &ret, "Plus! v2 %c.%c%c", id[4], id[5], id[6] );
    352352    }
    353353    else if( !memcmp( id, "XBT", 3 ) )
    354354    {
    355         asprintf( &ret, "XBT Client %c%c%c%s", id[3], id[4], id[5],
     355        tr_asprintf( &ret, "XBT Client %c%c%c%s", id[3], id[4], id[5],
    356356                    id[6] == 'd' ? " (debug)" : "" );
    357357    }
    358358    else if( !memcmp( id, "Mbrst", 5 ) )
    359359    {
    360         asprintf( &ret, "burst! %c.%c.%c", id[5], id[7], id[9] );
     360        tr_asprintf( &ret, "burst! %c.%c.%c", id[5], id[7], id[9] );
    361361    }
    362362    else if( !memcmp( id, "btpd", 4 ) )
    363363    {
    364         asprintf( &ret, "BT Protocol Daemon %c%c%c", id[5], id[6], id[7] );
     364        tr_asprintf( &ret, "BT Protocol Daemon %c%c%c", id[5], id[6], id[7] );
    365365    }
    366366    else if( id[0] == 'Q' && !memcmp( &id[4], "--", 2 ) )
    367367    {
    368         asprintf( &ret, "BTQueue %d.%d.%d", charToInt( id[1] ),
     368        tr_asprintf( &ret, "BTQueue %d.%d.%d", charToInt( id[1] ),
    369369                    charToInt( id[2] ), charToInt( id[3] ) );
    370370    }
    371371    else if( !memcmp( id, "BLZ", 3 ) )
    372372    {
    373         asprintf( &ret, "Blizzard Downloader %d.%d", id[3] + 1, id[4] );
     373        tr_asprintf( &ret, "Blizzard Downloader %d.%d", id[3] + 1, id[4] );
    374374    }
    375375    else if( !memcmp( id, "-WT-", 4 ) )
    376376    {
    377         asprintf( &ret, "BitLet" );
     377        tr_asprintf( &ret, "BitLet" );
    378378    }
    379379    else if( !memcmp( id, "LIME", 4 ) )
    380380    {
    381         asprintf( &ret, "LimeWire" );
     381        tr_asprintf( &ret, "LimeWire" );
    382382    }
    383383    else if( !memcmp( id, "-G3", 3 ) )
    384384    {
    385         asprintf( &ret, "G3 Torrent" );
     385        tr_asprintf( &ret, "G3 Torrent" );
    386386    }
    387387    else if( !memcmp( id, "10-------", 9 ) )
    388388    {
    389         asprintf( &ret, "JVtorrent" );
     389        tr_asprintf( &ret, "JVtorrent" );
    390390    }
    391391    else if( !memcmp( id, "346-", 4 ) )
    392392    {
    393         asprintf( &ret, "TorrentTopia" );
     393        tr_asprintf( &ret, "TorrentTopia" );
    394394    }
    395395    else if( !memcmp( id, "eX", 2 ) )
    396396    {
    397         asprintf( &ret, "eXeem" );
     397        tr_asprintf( &ret, "eXeem" );
    398398    }
    399399    else if( '\0' == id[0] && !memcmp( &id[1], "BS", 2 ) )
    400400    {
    401         asprintf( &ret, "BitSpirit %u", ( id[1] == 0 ? 1 : id[1] ) );
     401        tr_asprintf( &ret, "BitSpirit %u", ( id[1] == 0 ? 1 : id[1] ) );
    402402    }
    403403
     
    409409            isprint( id[6] ) && isprint( id[7] ) )
    410410        {
    411             asprintf( &ret, "unknown client (%c%c%c%c%c%c%c%c)",
     411            tr_asprintf( &ret, "unknown client (%c%c%c%c%c%c%c%c)",
    412412                  id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7] );
    413413        }
    414414        else
    415415        {
    416             asprintf( &ret, "unknown client (0x%02x%02x%02x%02x%02x%02x%02x%02x)",
     416            tr_asprintf( &ret, "unknown client (0x%02x%02x%02x%02x%02x%02x%02x%02x)",
    417417                  id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7] );
    418418        }
  • trunk/libtransmission/inout.c

    r3674 r3735  
    3030#include "peer-mgr.h"
    3131#include "utils.h"
    32 
    33 struct tr_io
    34 {
    35     tr_torrent * tor;
    36 };
    3732
    3833/****
  • trunk/libtransmission/ipcparse.c

    r3666 r3735  
    3131
    3232#include "transmission.h"
     33#include "utils.h"
    3334
    3435#include "ipcparse.h"
     
    364365
    365366uint8_t *
    366 ipc_mkval( benc_val_t * pk, size_t * len )
    367 {
    368     char * buf, hex[IPC_MIN_MSG_LEN+1];
    369     int    used, max;
    370 
    371     used = IPC_MIN_MSG_LEN;
    372     max  = IPC_MIN_MSG_LEN;
    373     buf  = malloc( IPC_MIN_MSG_LEN );
    374     if( NULL == buf )
    375     {
    376         return NULL;
    377     }
    378 
    379     if( tr_bencSave( pk, &buf, &used, &max ) )
    380     {
    381         SAFEFREE( buf );
    382         return NULL;
    383     }
    384 
    385     /* ok, this check is pretty laughable */
    386     if( IPC_MAX_MSG_LEN < used )
    387     {
    388         free( buf );
     367ipc_mkval( benc_val_t * pk, size_t * setmeSize )
     368{
     369    int bencSize = 0;
     370    char * benc = tr_bencSave( pk, &bencSize );
     371    uint8_t * ret = NULL;
     372
     373    if( bencSize > IPC_MAX_MSG_LEN )
    389374        errno = EFBIG;
    390         return NULL;
    391     }
    392 
    393     assert( 0 <= used );
    394     snprintf( hex, sizeof hex, "%0*X",
    395               IPC_MIN_MSG_LEN, used - IPC_MIN_MSG_LEN );
    396     memcpy( buf, hex, IPC_MIN_MSG_LEN );
    397     *len = used;
    398 
    399     return ( uint8_t * )buf;
     375    else {
     376        const size_t size = IPC_MIN_MSG_LEN + bencSize;
     377        ret = tr_new( uint8_t, size );
     378        snprintf( (char*)ret, size, "%0*X", IPC_MIN_MSG_LEN, bencSize );
     379        memcpy( ret + IPC_MIN_MSG_LEN, benc, bencSize );
     380        *setmeSize = size;
     381    }
     382
     383    tr_free( benc );
     384    return ret;
    400385}
    401386
  • trunk/libtransmission/makemeta.c

    r3658 r3735  
    386386    if ( !builder->abortFlag ) {
    387387        size_t nmemb;
    388         char * pch = tr_bencSaveMalloc( &top, &n );
     388        char * pch = tr_bencSave( &top, &n );
    389389        FILE * fp = fopen( builder->outputFile, "wb+" );
    390390        nmemb = n;
  • trunk/libtransmission/peer-msgs.c

    r3704 r3735  
    698698        tr_bencInitInt( tr_bencDictAdd( &val, "p" ), port );
    699699    tr_bencInitStr( tr_bencDictAdd( &val, "v" ), v, 0, 1 );
    700     buf = tr_bencSaveMalloc( &val, &len );
     700    buf = tr_bencSave( &val, &len );
    701701
    702702    tr_peerIoWriteUint32( msgs->io, outbuf, 2*sizeof(uint8_t) + len );
     
    16211621
    16221622        /* write the pex message */
    1623         benc = tr_bencSaveMalloc( &val, &bencLen );
     1623        benc = tr_bencSave( &val, &bencLen );
    16241624        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, 2*sizeof(uint8_t) + bencLen );
    16251625        tr_peerIoWriteUint8 ( msgs->io, msgs->outMessages, BT_LTEP );
  • trunk/libtransmission/trcompat.h

    r3652 r3735  
    3636#endif
    3737
    38 #ifndef HAVE_ASPRINTF
    39 int asprintf( char **, const char *, ... );
    40 int vasprintf( char **, const char *, va_list );
    41 #endif
    42 
    4338#endif /* TRCOMPAT_H */
  • trunk/libtransmission/utils.c

    r3731 r3735  
    3636#include <unistd.h> /* usleep, stat */
    3737
     38#include "event.h"
     39
    3840#ifdef WIN32
    3941    #include <windows.h> /* for Sleep */
    4042#elif defined(__BEOS__)
    4143    #include <kernel/OS.h>
    42     extern int vasprintf( char **, const char *, va_list );
    4344#endif
    4445
     
    4748#include "utils.h"
    4849#include "platform.h"
    49 
    50 #define SPRINTF_BUFSIZE         100
    5150
    5251static tr_lock      * messageLock = NULL;
     
    161160}
    162161
    163 void tr_msg( int level, const char * msg, ... )
    164 {
    165     va_list       args1, args2;
     162int
     163tr_vasprintf( char **strp, const char *fmt, va_list ap )
     164{
     165    int ret;
     166    struct evbuffer * buf = evbuffer_new( );
     167    if( evbuffer_add_vprintf( buf, fmt, ap ) )
     168        ret = -1;
     169    else {
     170        ret = EVBUFFER_LENGTH( buf );
     171        *strp = tr_strndup( (char*)EVBUFFER_DATA(buf), ret );
     172    }
     173    evbuffer_free( buf );
     174    return ret;
     175
     176}
     177
     178int
     179tr_asprintf( char **strp, const char *fmt, ...)
     180{
     181    int ret;
     182    va_list ap;
     183    va_start( ap, fmt );
     184    ret = tr_vasprintf( strp, fmt, ap );
     185    va_end( ap );
     186    return ret;
     187}
     188
     189void tr_msg( int level, const char * fmt, ... )
     190{
    166191    tr_msg_list * newmsg;
    167     int           len1, len2;
    168     FILE        * fp;
     192    FILE * fp;
    169193
    170194    assert( NULL != messageLock );
     
    183207    if( messageLevel >= level )
    184208    {
    185         va_start( args1, msg );
     209        va_list ap;
     210        char * text;
     211
     212        /* build the text message */
     213        va_start( ap, fmt );
     214        tr_vasprintf( &text, fmt, ap );
     215        va_end( ap );
     216
    186217        if( messageQueuing )
    187218        {
    188             newmsg = calloc( 1, sizeof( *newmsg ) );
    189             if( NULL != newmsg )
    190             {
    191                 newmsg->level = level;
    192                 newmsg->when = time( NULL );
    193                 len1 = len2 = 0;
    194                 va_start( args2, msg );
    195                 tr_vsprintf( &newmsg->message, &len1, &len2, msg,
    196                              args1, args2 );
    197                 va_end( args2 );
    198                 if( fp != NULL )
    199                     fprintf( fp, "%s\n", newmsg->message );
    200                 if( NULL == newmsg->message )
    201                 {
    202                     free( newmsg );
    203                 }
    204                 else
    205                 {
    206                     *messageQueueTail = newmsg;
    207                     messageQueueTail = &newmsg->next;
    208                 }
    209             }
     219            newmsg = tr_new0( tr_msg_list, 1 );
     220            newmsg->level = level;
     221            newmsg->when = time( NULL );
     222            newmsg->message = text;
     223
     224            *messageQueueTail = newmsg;
     225            messageQueueTail = &newmsg->next;
    210226        }
    211227        else
     
    213229            if( fp == NULL )
    214230                fp = stderr;
    215             vfprintf( fp, msg, args1 );
    216             fputc( '\n', fp );
     231            fprintf( stderr, "%s\n", text );
     232            tr_free( text );
    217233            fflush( fp );
    218234        }
    219         va_end( args1 );
    220235    }
    221236
     
    440455
    441456    tr_free( path );
    442     return 0;
    443 }
    444 
    445 int tr_sprintf( char ** buf, int * used, int * max, const char * format, ... )
    446 {
    447     va_list ap1, ap2;
    448     int     ret;
    449 
    450     va_start( ap1, format );
    451     va_start( ap2, format );
    452     ret = tr_vsprintf( buf, used, max, format, ap1, ap2 );
    453     va_end( ap2 );
    454     va_end( ap1 );
    455 
    456     return ret;
    457 }
    458 
    459 int tr_vsprintf( char ** buf, int * used, int * max, const char * fmt,
    460                  va_list ap1, va_list ap2 )
    461 {
    462     int     want;
    463 
    464     want = vsnprintf( NULL, 0, fmt, ap1 );
    465 
    466     if( tr_concat( buf, used, max, NULL, want ) )
    467     {
    468         return 1;
    469     }
    470     assert( *used + want + 1 <= *max );
    471 
    472     *used += vsnprintf( *buf + *used, *max - *used, fmt, ap2 );
    473 
    474     return 0;
    475 }
    476 
    477 #ifndef HAVE_ASPRINTF
    478 
    479 int
    480 asprintf( char ** buf, const char * format, ... )
    481 {
    482     va_list ap;
    483     int     ret;
    484 
    485     va_start( ap, format );
    486     ret = vasprintf( buf, format, ap );
    487     va_end( ap );
    488 
    489     return ret;
    490 }
    491 
    492 int
    493 vasprintf( char ** buf, const char * format, va_list ap )
    494 {
    495     va_list ap2;
    496     int     used, max;
    497 
    498     va_copy( ap2, ap );
    499 
    500     *buf = NULL;
    501     used = 0;
    502     max  = 0;
    503 
    504     if( tr_vsprintf( buf, &used, &max, format, ap, ap2 ) )
    505     {
    506         free( *buf );
    507         return -1;
    508     }
    509 
    510     return used;
    511 }
    512 
    513 #endif /* HAVE_ASPRINTF */
    514 
    515 int tr_concat( char ** buf, int * used, int * max, const char * data, int len )
    516 {
    517     int     newmax;
    518     char  * newbuf;
    519 
    520     newmax = *max;
    521     while( *used + len + 1 > newmax )
    522     {
    523         newmax += SPRINTF_BUFSIZE;
    524     }
    525     if( newmax > *max )
    526     {
    527         newbuf = realloc( *buf, newmax );
    528         if( NULL == newbuf )
    529         {
    530             return 1;
    531         }
    532         *buf = newbuf;
    533         *max = newmax;
    534     }
    535 
    536     if( NULL != data )
    537     {
    538         memcpy( *buf + *used, data, len );
    539         *used += len;
    540     }
    541 
    542457    return 0;
    543458}
  • trunk/libtransmission/utils.h

    r3731 r3735  
    4343int  tr_rand ( int );
    4444
    45 /***********************************************************************
    46  * tr_mkdirp
    47  ***********************************************************************
    48  * Create a directory and any needed parent directories.
    49  * Note that the string passed in must be writable!
    50  **********************************************************************/
     45int tr_asprintf(char **strp, const char *fmt, ...);
     46
    5147int tr_mkdirp( const char * path, int permissions );
    5248
     
    5551uint8_t* tr_loadFile( const char * filename, size_t * size );
    5652
    57 /***********************************************************************
    58  * tr_sprintf
    59  ***********************************************************************
    60  * Appends to the end of a buffer using printf formatting,
    61  * growing the buffer if needed
    62  **********************************************************************/
    63 int tr_sprintf( char ** buf, int * used, int * max,
    64                 const char * format, ... );
    65 /* gee, it sure would be nice if BeOS had va_copy() */
    66 int tr_vsprintf( char **, int *, int *, const char *, va_list, va_list );
    67 /* this concatenates some binary data onto the end of a buffer */
    68 int tr_concat( char ** buf, int * used, int * max,
    69                const char * data, int len );
     53int tr_vasprintf( char **strp, const char *fmt, va_list ap );
     54
     55int tr_asprintf( char **strp, const char *fmt, ...);
     56
    7057
    7158/* creates a filename from a series of elements using the
Note: See TracChangeset for help on using the changeset viewer.