Ignore:
Timestamp:
Sep 25, 2006, 6:37:45 PM (15 years ago)
Author:
joshe
Message:

Merge nat-traversal branch to trunk.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/utils.c

    r837 r920  
    2525#include "transmission.h"
    2626
     27#define SPRINTF_BUFSIZE         100
     28
    2729static tr_lock_t      * messageLock = NULL;
    2830static int              messageLevel = 0;
     
    9799void tr_msg( int level, char * msg, ... )
    98100{
    99     va_list          args;
     101    va_list         args1, args2;
    100102    tr_msg_list_t * newmsg;
     103    int             len1, len2;
    101104
    102105    assert( NULL != messageLock );
     
    113116    if( messageLevel >= level )
    114117    {
    115         va_start( args, msg );
     118        va_start( args1, msg );
    116119        if( messageQueuing )
    117120        {
     
    121124                newmsg->level = level;
    122125                newmsg->when = time( NULL );
    123                 vasprintf( &newmsg->message, msg, args );
     126                len1 = len2 = 0;
     127                va_start( args2, msg );
     128                tr_vsprintf( &newmsg->message, &len1, &len2, msg,
     129                             args1, args2 );
     130                va_end( args2 );
    124131                if( NULL == newmsg->message )
    125132                {
     
    135142        else
    136143        {
    137             vfprintf( stderr, msg, args );
     144            vfprintf( stderr, msg, args1 );
    138145            fputc( '\n', stderr );
    139146        }
    140         va_end( args );
     147        va_end( args1 );
    141148    }
    142149
     
    235242    return 0;
    236243}
     244
     245#define UPPER( cc ) \
     246    ( 'a' <= (cc) && 'z' >= (cc) ? (cc) - ( 'a' - 'A' ) : (cc) )
     247
     248int tr_strncasecmp( const char * first, const char * second, int len )
     249{
     250    int ii;
     251    char firstchar, secondchar;
     252
     253    if( 0 > len )
     254    {
     255        len = strlen( first );
     256        ii = strlen( second );
     257        len = MIN( len, ii );
     258    }
     259
     260    for( ii = 0; ii < len; ii++ )
     261    {
     262        if( first[ii] != second[ii] )
     263        {
     264            firstchar = UPPER( first[ii] );
     265            secondchar = UPPER( second[ii] );
     266            if( firstchar > secondchar )
     267            {
     268                return 1;
     269            }
     270            else if( firstchar < secondchar )
     271            {
     272                return -1;
     273            }
     274        }
     275        if( '\0' == first[ii] )
     276        {
     277            /* if first[ii] is '\0' then second[ii] is too */
     278            return 0;
     279        }
     280    }
     281
     282    return 0;
     283}
     284
     285int tr_sprintf( char ** buf, int * used, int * max, const char * format, ... )
     286{
     287    va_list ap1, ap2;
     288    int     ret;
     289
     290    va_start( ap1, format );
     291    va_start( ap2, format );
     292    ret = tr_vsprintf( buf, used, max, format, ap1, ap2 );
     293    va_end( ap2 );
     294    va_end( ap1 );
     295
     296    return ret;
     297}
     298
     299int tr_vsprintf( char ** buf, int * used, int * max, const char * fmt,
     300                 va_list ap1, va_list ap2 )
     301{
     302    int     want;
     303    char  * newbuf;
     304
     305    want = vsnprintf( NULL, 0, fmt, ap1 );
     306
     307    while( *used + want + 1 > *max )
     308    {
     309        *max += SPRINTF_BUFSIZE;
     310        newbuf = realloc( *buf, *max );
     311        if( NULL == newbuf )
     312        {
     313            return 1;
     314        }
     315        *buf = newbuf;
     316    }
     317
     318    *used += vsnprintf( *buf + *used, *max - *used, fmt, ap2 );
     319
     320    return 0;
     321}
     322
     323char *
     324tr_dupstr( const char * base, int len )
     325{
     326    char * ret;
     327
     328    ret = malloc( len + 1 );
     329    if( NULL != ret )
     330    {
     331        memcpy( ret, base, len );
     332        ret[len] = '\0';
     333    }
     334
     335    return ret;
     336}
Note: See TracChangeset for help on using the changeset viewer.