From 0c1c57a62ab330b6175504465826053a00780a46 Mon Sep 17 00:00:00 2001 From: Josh Elsasser Date: Thu, 29 Mar 2007 21:02:59 +0000 Subject: [PATCH] Eliminate an error-prone varargs function. --- libtransmission/bencode.c | 110 +++++++++----------------------------- libtransmission/bencode.h | 15 +++--- libtransmission/peeraz.h | 60 +++++++++------------ libtransmission/peerext.h | 53 +++++++++--------- 4 files changed, 86 insertions(+), 152 deletions(-) diff --git a/libtransmission/bencode.c b/libtransmission/bencode.c index 991e15f6d..4e3303cd8 100644 --- a/libtransmission/bencode.c +++ b/libtransmission/bencode.c @@ -318,40 +318,7 @@ void tr_bencInitInt( benc_val_t * val, int64_t num ) val->val.i = num; } -int tr_bencListAppend( benc_val_t * val, ... ) -{ - va_list ap; - int len; - benc_val_t ** ptr; - - assert( TYPE_LIST == val->type ); - - len = 0; - va_start( ap, val ); - while( NULL != va_arg( ap, benc_val_t ** ) ) - { - len++; - } - va_end( ap ); - - if( makeroom( val, len ) ) - { - return 1; - } - - va_start( ap, val ); - while( NULL != ( ptr = va_arg( ap, benc_val_t ** ) ) ) - { - *ptr = &val->val.l.vals[val->val.l.count]; - tr_bencInit( *ptr, TYPE_INT ); - val->val.l.count++; - } - va_end( ap ); - - return 0; -} - -int tr_bencListExtend( benc_val_t * val, int count ) +int tr_bencListReserve( benc_val_t * val, int count ) { assert( TYPE_LIST == val->type ); @@ -363,75 +330,48 @@ int tr_bencListExtend( benc_val_t * val, int count ) return 0; } -static inline int _tr_bencDictAppend( benc_val_t * val, va_list ap, - va_list ap2, int nofree ) +int tr_bencDictReserve( benc_val_t * val, int count ) { - int len; - char * key; - benc_val_t ** ptr; - assert( TYPE_DICT == val->type ); - len = 0; - while( NULL != va_arg( ap, char * ) ) - { - ptr = va_arg( ap, benc_val_t ** ); - assert( NULL != ptr ); - len += 2; - } - - if( makeroom( val, len ) ) + if( makeroom( val, count * 2 ) ) { return 1; } - while( NULL != ( key = va_arg( ap2, char * ) ) ) - { - if( !nofree ) - { - key = strdup( key ); - if( NULL == key ) - { - return 1; - } - } - ptr = va_arg( ap2, benc_val_t ** ); - tr_bencInitStr( &val->val.l.vals[val->val.l.count], key, 0, nofree ); - val->val.l.count++; - *ptr = &val->val.l.vals[val->val.l.count]; - tr_bencInit( *ptr, TYPE_INT ); - val->val.l.count++; - } - return 0; } -int tr_bencDictAppend( benc_val_t * val, ... ) +benc_val_t * tr_bencListAdd( benc_val_t * list ) { - va_list ap, ap2; - int ret; + benc_val_t * item; - va_start( ap, val ); - va_start( ap2, val ); - ret = _tr_bencDictAppend( val, ap, ap2, 0 ); - va_end( ap2 ); - va_end( ap ); + assert( TYPE_LIST == list->type ); + assert( list->val.l.count < list->val.l.alloc ); - return ret; + item = &list->val.l.vals[list->val.l.count]; + list->val.l.count++; + tr_bencInit( item, TYPE_INT ); + + return item; } -int tr_bencDictAppendNofree( benc_val_t * val, ... ) +benc_val_t * tr_bencDictAdd( benc_val_t * dict, const char * key ) { - va_list ap, ap2; - int ret; + benc_val_t * keyval, * itemval; - va_start( ap, val ); - va_start( ap2, val ); - ret = _tr_bencDictAppend( val, ap, ap2, 1 ); - va_end( ap2 ); - va_end( ap ); + assert( TYPE_DICT == dict->type ); + assert( dict->val.l.count + 2 <= dict->val.l.alloc ); - return ret; + keyval = &dict->val.l.vals[dict->val.l.count]; + dict->val.l.count++; + itemval = &dict->val.l.vals[dict->val.l.count]; + dict->val.l.count++; + + tr_bencInitStr( keyval, key, -1, 1 ); + tr_bencInit( itemval, TYPE_INT ); + + return itemval; } char * tr_bencSaveMalloc( benc_val_t * val, int * len ) diff --git a/libtransmission/bencode.h b/libtransmission/bencode.h index f480f63b1..e1034f9dc 100644 --- a/libtransmission/bencode.h +++ b/libtransmission/bencode.h @@ -76,15 +76,12 @@ static inline void tr_bencInit( benc_val_t * val, int type ) void _tr_bencInitStr( benc_val_t * val, char * str, int len, int nofree ); int tr_bencInitStrDup( benc_val_t * val, const char * str ); void tr_bencInitInt( benc_val_t * val, int64_t num ); -/* args are a NULL terminated list of benc_val_t** */ -int tr_bencListAppend( benc_val_t * val, ... ); -/* args are a NULL terminated list of pairs of char * key, benc_val_t ** val */ -int tr_bencDictAppend( benc_val_t * val, ... ); -/* like tr_bencDictAppend but char * key args are marked nofree */ -int tr_bencDictAppendNofree( benc_val_t * val, ... ); - -/* insure val has room for at least count more items */ -int tr_bencListExtend( benc_val_t * val, int count ); +int tr_bencListReserve( benc_val_t * list, int count ); +/* note that for one key-value pair, count should be 1, not 2 */ +int tr_bencDictReserve( benc_val_t * dict, int count ); +benc_val_t * tr_bencListAdd( benc_val_t * list ); +/* note: key must not be freed or modified while val is in use */ +benc_val_t * tr_bencDictAdd( benc_val_t * dict, const char * key ); char * tr_bencSaveMalloc( benc_val_t * val, int * len ); int tr_bencSave( benc_val_t * val, char ** buf, diff --git a/libtransmission/peeraz.h b/libtransmission/peeraz.h index 1129e6d2d..d97ad5d4c 100644 --- a/libtransmission/peeraz.h +++ b/libtransmission/peeraz.h @@ -100,8 +100,7 @@ static uint8_t * makeAZHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * buflen ) { char * buf; - benc_val_t val, * idval, * clientval, * versval; - benc_val_t * tcpval, * msgsval, * msgdictval, * msgidval, * msgversval; + benc_val_t val, * msgsval, * msgdictval; int len, max, idx; uint8_t vers; @@ -123,13 +122,7 @@ makeAZHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * buflen ) /* start building a dictionary for handshake data */ tr_bencInit( &val, TYPE_DICT ); - if( tr_bencDictAppendNofree( &val, - "identity", &idval, - "client", &clientval, - "version", &versval, - "tcp_port", &tcpval, - "messages", &msgsval, - NULL ) ) + if( tr_bencDictReserve( &val, 5 ) ) { free( buf ); tr_bencFree( &val ); @@ -137,13 +130,23 @@ makeAZHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * buflen ) } /* fill in the dictionary values */ - tr_bencInitStr( idval, tor->azId, TR_AZ_ID_LEN, 1 ); - tr_bencInitStr( clientval, TR_NAME, 0, 1 ); - tr_bencInitStr( versval, VERSION_STRING, 0, 1 ); - tr_bencInitInt( tcpval, tor->publicPort ); - tr_bencInit( msgsval, TYPE_LIST ); + tr_bencInitStr( tr_bencDictAdd( &val, "identity" ), + tor->azId, TR_AZ_ID_LEN, 1 ); + tr_bencInitStr( tr_bencDictAdd( &val, "client" ), TR_NAME, 0, 1 ); + tr_bencInitStr( tr_bencDictAdd( &val, "version" ), VERSION_STRING, 0, 1 ); + tr_bencInitInt( tr_bencDictAdd( &val, "tcp_port" ), tor->publicPort ); - /* fill in the supported message list */ + /* initialize supported message list */ + msgsval = tr_bencDictAdd( &val, "messages" ); + tr_bencInit( msgsval, TYPE_LIST ); + if( tr_bencListReserve( msgsval, azmsgCount() ) ) + { + tr_bencFree( &val ); + free( buf ); + return NULL; + } + + /* fill in the message list */ vers = AZ_EXT_VERSION; for( idx = 0; azmsgCount() > idx; idx++ ) { @@ -156,25 +159,18 @@ makeAZHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * buflen ) /* no point in saying we can do pex if the torrent is private */ continue; } - if( tr_bencListAppend( msgsval, &msgdictval, NULL ) ) - { - tr_bencFree( &val ); - free( buf ); - return NULL; - } /* each item in the list is a dict with id and ver keys */ + msgdictval = tr_bencListAdd( msgsval ); tr_bencInit( msgdictval, TYPE_DICT ); - if( tr_bencDictAppendNofree( msgdictval, - "id", &msgidval, - "ver", &msgversval, - NULL ) ) + if( tr_bencDictReserve( msgdictval, 2 ) ) { tr_bencFree( &val ); free( buf ); return NULL; } - tr_bencInitStr( msgidval, azmsgStr( idx ), azmsgLen( idx ), 1 ); - tr_bencInitStr( msgversval, &vers, 1, 1 ); + tr_bencInitStr( tr_bencDictAdd( msgdictval, "id" ), + azmsgStr( idx ), azmsgLen( idx ), 1 ); + tr_bencInitStr( tr_bencDictAdd( msgdictval, "ver" ), &vers, 1, 1 ); } /* bencode the dictionary and append it to the buffer */ @@ -200,7 +196,7 @@ makeAZHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * buflen ) static int peertreeToBencAZ( tr_peertree_t * tree, benc_val_t * val ) { - int count, jj; + int count; tr_peertree_entry_t * ii; tr_bencInit( val, TYPE_LIST ); @@ -209,20 +205,16 @@ peertreeToBencAZ( tr_peertree_t * tree, benc_val_t * val ) { return 0; } - if( tr_bencListExtend( val, count ) ) + if( tr_bencListReserve( val, count ) ) { return 1; } ii = peertreeFirst( tree ); - jj = val->val.l.count; while( NULL != ii ) { - assert( jj < val->val.l.alloc ); - tr_bencInitStr( &val->val.l.vals[jj], ii->peer, 6, 1 ); - val->val.l.count++; + tr_bencInitStr( tr_bencListAdd( val ), ii->peer, 6, 1 ); ii = peertreeNext( tree, ii ); - jj++; } return 0; diff --git a/libtransmission/peerext.h b/libtransmission/peerext.h index 6a4bf7b2c..ae57652f6 100644 --- a/libtransmission/peerext.h +++ b/libtransmission/peerext.h @@ -67,10 +67,19 @@ makeCommonPex( tr_torrent_t * tor, tr_peer_t * peer, int * len, /* build the dictionaries */ tr_bencInit( &val, TYPE_DICT ); if( ( peertreeEmpty( &added ) && peertreeEmpty( sent ) ) || - tr_bencDictAppendNofree( &val, extrakey, &extra, "added", &addval, - "dropped", &delval, NULL ) || - (*peerfunc)( &added, addval ) || - (*peerfunc)( sent, delval ) ) + tr_bencDictReserve( &val, 3 ) ) + { + tr_bencFree( &val ); + peertreeMerge( sent, &common ); + peertreeFree( &added ); + tr_bencFree( extraval ); + return NULL; + } + extra = tr_bencDictAdd( &val, extrakey ); + addval = tr_bencDictAdd( &val, "added" ); + delval = tr_bencDictAdd( &val, "dropped" ); + assert( NULL != extra && NULL != addval && NULL != delval ); + if( (*peerfunc)( &added, addval ) || (*peerfunc)( sent, delval ) ) { tr_bencFree( &val ); peertreeMerge( sent, &common ); @@ -101,12 +110,9 @@ makeCommonPex( tr_torrent_t * tor, tr_peer_t * peer, int * len, static char * makeExtendedHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * len ) { - benc_val_t val, * msgsval, * portval, * versval, * pexval; + benc_val_t val, * msgsval; char * buf, * vers; - peer_dbg( "SEND extended-handshake, %s pex", - ( peer->private ? "without" : "with" ) ); - /* get human-readable version string */ vers = NULL; asprintf( &vers, "%s %s", TR_NAME, VERSION_STRING ); @@ -115,10 +121,9 @@ makeExtendedHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * len ) return NULL; } + /* reserve space in toplevel dictionary for v, m, and possibly p */ tr_bencInit( &val, TYPE_DICT ); - - /* append v str and m dict to toplevel dictionary */ - if( tr_bencDictAppendNofree( &val, "v", &versval, "m", &msgsval, NULL ) ) + if( tr_bencDictReserve( &val, ( 0 < tor->publicPort ? 3 : 2 ) ) ) { free( vers ); tr_bencFree( &val ); @@ -126,41 +131,41 @@ makeExtendedHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * len ) } /* human readable version string */ - tr_bencInitStr( versval, vers, 0, 0 ); + tr_bencInitStr( tr_bencDictAdd( &val, "v" ), vers, 0, 0 ); /* create dict of supported extended messages */ + msgsval = tr_bencDictAdd( &val, "m" ); tr_bencInit( msgsval, TYPE_DICT ); if( !peer->private ) { - /* for public torrents advertise utorrent pex message */ - if( tr_bencDictAppendNofree( msgsval, "ut_pex", &pexval, NULL ) ) + /* for public torrents, advertise utorrent pex message */ + if( tr_bencDictReserve( msgsval, 1 ) ) { tr_bencFree( &val ); return NULL; } - tr_bencInitInt( pexval, EXTENDED_PEX_ID ); + tr_bencInitInt( tr_bencDictAdd( msgsval, "ut_pex" ), EXTENDED_PEX_ID ); } /* our listening port */ if( 0 < tor->publicPort ) { - if( tr_bencDictAppendNofree( &val, "p", &portval, NULL ) ) - { - tr_bencFree( &val ); - return NULL; - } - tr_bencInitInt( portval, tor->publicPort ); + tr_bencInitInt( tr_bencDictAdd( &val, "p" ), tor->publicPort ); } /* bencode it */ buf = tr_bencSaveMalloc( &val, len ); tr_bencFree( &val ); - - if( NULL != buf ) + if( NULL == buf ) { - peer->advertisedPort = tor->publicPort; + return NULL; } + peer->advertisedPort = tor->publicPort; + + peer_dbg( "SEND extended-handshake, %s pex", + ( peer->private ? "without" : "with" ) ); + return buf; }