source: trunk/libtransmission/utils.c @ 13469

Last change on this file since 13469 was 13469, checked in by livings124, 10 years ago

Revert r13468 for now.

  • Property svn:keywords set to Date Rev Author Id
File size: 42.4 KB
Line 
1/*
2 * This file Copyright (C) Mnemosyne LLC
3 *
4 * This file is licensed by the GPL version 2. Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: utils.c 13469 2012-09-06 03:21:03Z livings124 $
11 */
12
13#ifdef HAVE_MEMMEM
14 #define _GNU_SOURCE /* glibc's string.h needs this to pick up memmem */
15#endif
16
17#if defined(SYS_DARWIN)
18 #define HAVE_GETPAGESIZE
19 #define HAVE_ICONV_OPEN
20 #define HAVE_MKDTEMP
21 #define HAVE_VALLOC
22 #define HAVE_XATTRS_MACOS
23#endif
24
25#include <assert.h>
26#include <ctype.h> /* isdigit(), isalpha(), tolower() */
27#include <errno.h>
28#include <float.h> /* DBL_EPSILON */
29#include <locale.h> /* localeconv() */
30#include <math.h> /* pow(), fabs(), floor() */
31#include <stdarg.h>
32#include <stdio.h>
33#include <stdlib.h>
34#include <string.h> /* strerror(), memset(), memmem() */
35#include <time.h> /* nanosleep() */
36
37#ifdef HAVE_ICONV_OPEN
38 #include <iconv.h>
39#endif
40#include <libgen.h> /* basename() */
41#include <sys/time.h>
42#include <sys/types.h>
43#include <sys/stat.h>
44#ifdef HAVE_XATTRS_MACOS
45 #include <sys/xattr.h> /*  listxattr(), getxattr(), setxattr() */
46#endif
47#include <unistd.h> /* stat(), getcwd(), getpagesize(), unlink() */
48
49#include <event2/buffer.h>
50#include <event2/event.h>
51
52#ifdef WIN32
53 #include <w32api.h>
54 #define WINVER WindowsXP /* freeaddrinfo(), getaddrinfo(), getnameinfo() */
55 #include <direct.h> /* _getcwd() */
56 #include <windows.h> /* Sleep() */
57#endif
58
59#include "transmission.h"
60#include "bencode.h"
61#include "fdlimit.h"
62#include "ConvertUTF.h"
63#include "list.h"
64#include "utils.h"
65#include "platform.h" /* tr_lockLock(), TR_PATH_MAX */
66#include "version.h"
67
68
69time_t       __tr_current_time   = 0;
70tr_msg_level __tr_message_level  = TR_MSG_ERR;
71
72static bool           messageQueuing = false;
73static tr_msg_list *  messageQueue = NULL;
74static tr_msg_list ** messageQueueTail = &messageQueue;
75static int            messageQueueCount = 0;
76
77#ifndef WIN32
78    /* make null versions of these win32 functions */
79    static inline int IsDebuggerPresent( void ) { return false; }
80    static inline void OutputDebugString( const void * unused UNUSED ) { }
81#endif
82
83/***
84****
85***/
86
87static tr_lock*
88getMessageLock( void )
89{
90    static tr_lock * l = NULL;
91
92    if( !l )
93        l = tr_lockNew( );
94
95    return l;
96}
97
98void*
99tr_getLog( void )
100{
101    static bool initialized = false;
102    static FILE * file = NULL;
103
104    if( !initialized )
105    {
106        const char * str = getenv( "TR_DEBUG_FD" );
107        int          fd = 0;
108        if( str && *str )
109            fd = atoi( str );
110        switch( fd )
111        {
112            case 1:
113                file = stdout; break;
114
115            case 2:
116                file = stderr; break;
117
118            default:
119                file = NULL; break;
120        }
121        initialized = true;
122    }
123
124    return file;
125}
126
127void
128tr_setMessageLevel( tr_msg_level level )
129{
130    __tr_message_level = level;
131}
132
133void
134tr_setMessageQueuing( bool enabled )
135{
136    messageQueuing = enabled;
137}
138
139bool
140tr_getMessageQueuing( void )
141{
142    return messageQueuing != 0;
143}
144
145tr_msg_list *
146tr_getQueuedMessages( void )
147{
148    tr_msg_list * ret;
149    tr_lockLock( getMessageLock( ) );
150
151    ret = messageQueue;
152    messageQueue = NULL;
153    messageQueueTail = &messageQueue;
154
155    messageQueueCount = 0;
156
157    tr_lockUnlock( getMessageLock( ) );
158    return ret;
159}
160
161void
162tr_freeMessageList( tr_msg_list * list )
163{
164    tr_msg_list * next;
165
166    while( NULL != list )
167    {
168        next = list->next;
169        free( list->message );
170        free( list->name );
171        free( list );
172        list = next;
173    }
174}
175
176/**
177***
178**/
179
180struct tm *
181tr_localtime_r( const time_t *_clock, struct tm *_result )
182{
183#ifdef HAVE_LOCALTIME_R
184    return localtime_r( _clock, _result );
185#else
186    struct tm *p = localtime( _clock );
187    if( p )
188        *(_result) = *p;
189    return p;
190#endif
191}
192
193char*
194tr_getLogTimeStr( char * buf, int buflen )
195{
196    char           tmp[64];
197    struct tm      now_tm;
198    struct timeval tv;
199    time_t         seconds;
200    int            milliseconds;
201
202    gettimeofday( &tv, NULL );
203
204    seconds = tv.tv_sec;
205    tr_localtime_r( &seconds, &now_tm );
206    strftime( tmp, sizeof( tmp ), "%H:%M:%S", &now_tm );
207    milliseconds = tv.tv_usec / 1000;
208    tr_snprintf( buf, buflen, "%s.%03d", tmp, milliseconds );
209
210    return buf;
211}
212
213bool
214tr_deepLoggingIsActive( void )
215{
216    static int8_t deepLoggingIsActive = -1;
217
218    if( deepLoggingIsActive < 0 )
219        deepLoggingIsActive = IsDebuggerPresent() || (tr_getLog()!=NULL);
220
221    return deepLoggingIsActive != 0;
222}
223
224void
225tr_deepLog( const char  * file,
226            int           line,
227            const char  * name,
228            const char  * fmt,
229            ... )
230{
231    FILE * fp = tr_getLog( );
232    if( fp || IsDebuggerPresent( ) )
233    {
234        va_list           args;
235        char              timestr[64];
236        struct evbuffer * buf = evbuffer_new( );
237        char *            base = tr_basename( file );
238        char *            message;
239
240        evbuffer_add_printf( buf, "[%s] ",
241                            tr_getLogTimeStr( timestr, sizeof( timestr ) ) );
242        if( name )
243            evbuffer_add_printf( buf, "%s ", name );
244        va_start( args, fmt );
245        evbuffer_add_vprintf( buf, fmt, args );
246        va_end( args );
247        evbuffer_add_printf( buf, " (%s:%d)\n", base, line );
248        /* FIXME(libevent2) ifdef this out for nonwindows platforms */
249        message = evbuffer_free_to_str( buf );
250        OutputDebugString( message );
251        if( fp )
252            fputs( message, fp );
253
254        tr_free( message );
255        tr_free( base );
256    }
257}
258
259/***
260****
261***/
262
263void
264tr_msg( const char * file, int line,
265        tr_msg_level level,
266        const char * name,
267        const char * fmt, ... )
268{
269    const int err = errno; /* message logging shouldn't affect errno */
270    char buf[1024];
271    va_list ap;
272    tr_lockLock( getMessageLock( ) );
273
274    /* build the text message */
275    *buf = '\0';
276    va_start( ap, fmt );
277    evutil_vsnprintf( buf, sizeof( buf ), fmt, ap );
278    va_end( ap );
279
280    OutputDebugString( buf );
281
282    if( *buf )
283    {
284        if( messageQueuing )
285        {
286            tr_msg_list * newmsg;
287            newmsg = tr_new0( tr_msg_list, 1 );
288            newmsg->level = level;
289            newmsg->when = tr_time( );
290            newmsg->message = tr_strdup( buf );
291            newmsg->file = file;
292            newmsg->line = line;
293            newmsg->name = tr_strdup( name );
294
295            *messageQueueTail = newmsg;
296            messageQueueTail = &newmsg->next;
297            ++messageQueueCount;
298
299            if( messageQueueCount > TR_MAX_MSG_LOG )
300            {
301                tr_msg_list * old = messageQueue;
302                messageQueue = old->next;
303                old->next = NULL;
304                tr_freeMessageList(old);
305
306                --messageQueueCount;
307
308                assert( messageQueueCount == TR_MAX_MSG_LOG );
309            }
310        }
311        else
312        {
313            char timestr[64];
314            FILE * fp;
315
316            fp = tr_getLog( );
317            if( fp == NULL )
318                fp = stderr;
319
320            tr_getLogTimeStr( timestr, sizeof( timestr ) );
321
322            if( name )
323                fprintf( fp, "[%s] %s: %s\n", timestr, name, buf );
324            else
325                fprintf( fp, "[%s] %s\n", timestr, buf );
326            fflush( fp );
327        }
328    }
329
330    tr_lockUnlock( getMessageLock( ) );
331    errno = err;
332}
333
334/***
335****
336***/
337
338void*
339tr_malloc( size_t size )
340{
341    return size ? malloc( size ) : NULL;
342}
343
344void*
345tr_malloc0( size_t size )
346{
347    return size ? calloc( 1, size ) : NULL;
348}
349
350void
351tr_free( void * p )
352{
353    if( p != NULL )
354        free( p );
355}
356
357void*
358tr_memdup( const void * src, size_t byteCount )
359{
360    return memcpy( tr_malloc( byteCount ), src, byteCount );
361}
362
363/***
364****
365***/
366
367const char*
368tr_strip_positional_args( const char* str )
369{
370    const char * in = str;
371    static size_t bufsize = 0;
372    static char * buf = NULL;
373    const size_t  len = str ? strlen( str ) : 0;
374    char *        out;
375
376    if( !buf || ( bufsize < len ) )
377    {
378        bufsize = len * 2 + 1;
379        buf = tr_renew( char, buf, bufsize );
380    }
381
382    for( out = buf; str && *str; ++str )
383    {
384        *out++ = *str;
385
386        if( ( *str == '%' ) && isdigit( str[1] ) )
387        {
388            const char * tmp = str + 1;
389            while( isdigit( *tmp ) )
390                ++tmp;
391            if( *tmp == '$' )
392                str = tmp[1]=='\'' ? tmp+1 : tmp;
393        }
394
395        if( ( *str == '%' ) && ( str[1] == '\'' ) )
396            str = str + 1;
397
398    }
399    *out = '\0';
400
401    return !in || strcmp( buf, in ) ? buf : in;
402}
403
404/**
405***
406**/
407
408void
409tr_timerAdd( struct event * timer, int seconds, int microseconds )
410{
411    struct timeval tv;
412    tv.tv_sec = seconds;
413    tv.tv_usec = microseconds;
414
415    assert( tv.tv_sec >= 0 );
416    assert( tv.tv_usec >= 0 );
417    assert( tv.tv_usec < 1000000 );
418
419    evtimer_add( timer, &tv );
420}
421
422void
423tr_timerAddMsec( struct event * timer, int msec )
424{
425    const int seconds =  msec / 1000;
426    const int usec = (msec%1000) * 1000;
427    tr_timerAdd( timer, seconds, usec );
428}
429
430/**
431***
432**/
433
434uint8_t *
435tr_loadFile( const char * path,
436             size_t *     size )
437{
438    uint8_t * buf;
439    struct stat  sb;
440    int fd;
441    ssize_t n;
442    const char * const err_fmt = _( "Couldn't read \"%1$s\": %2$s" );
443
444    /* try to stat the file */
445    errno = 0;
446    if( stat( path, &sb ) )
447    {
448        const int err = errno;
449        tr_dbg( err_fmt, path, tr_strerror( errno ) );
450        errno = err;
451        return NULL;
452    }
453
454    if( ( sb.st_mode & S_IFMT ) != S_IFREG )
455    {
456        tr_err( err_fmt, path, _( "Not a regular file" ) );
457        errno = EISDIR;
458        return NULL;
459    }
460
461    /* Load the torrent file into our buffer */
462    fd = tr_open_file_for_scanning( path );
463    if( fd < 0 )
464    {
465        const int err = errno;
466        tr_err( err_fmt, path, tr_strerror( errno ) );
467        errno = err;
468        return NULL;
469    }
470    buf = tr_malloc( sb.st_size + 1 );
471    if( !buf )
472    {
473        const int err = errno;
474        tr_err( err_fmt, path, _( "Memory allocation failed" ) );
475        tr_close_file( fd );
476        errno = err;
477        return NULL;
478    }
479    n = read( fd, buf, (size_t)sb.st_size );
480    if( n == -1 )
481    {
482        const int err = errno;
483        tr_err( err_fmt, path, tr_strerror( errno ) );
484        tr_close_file( fd );
485        free( buf );
486        errno = err;
487        return NULL;
488    }
489
490    tr_close_file( fd );
491    buf[ sb.st_size ] = '\0';
492    *size = sb.st_size;
493    return buf;
494}
495
496char*
497tr_basename( const char * path )
498{
499    char * tmp = tr_strdup( path );
500    char * ret = tr_strdup( basename( tmp ) );
501    tr_free( tmp );
502    return ret;
503}
504
505char*
506tr_dirname( const char * path )
507{
508    char * tmp = tr_strdup( path );
509    char * ret = tr_strdup( dirname( tmp ) );
510    tr_free( tmp );
511    return ret;
512}
513
514char*
515tr_mkdtemp( char * template )
516{
517#ifdef HAVE_MKDTEMP
518    return mkdtemp( template );
519#else
520    if( !mktemp( template ) || mkdir( template, 0700 ) )
521        return NULL;
522    return template;
523#endif
524}
525
526int
527tr_mkdir( const char * path,
528          int permissions
529#ifdef WIN32
530                       UNUSED
531#endif
532        )
533{
534#ifdef WIN32
535    if( path && isalpha( path[0] ) && path[1] == ':' && !path[2] )
536        return 0;
537    return mkdir( path );
538#else
539    return mkdir( path, permissions );
540#endif
541}
542
543int
544tr_mkdirp( const char * path_in,
545           int          permissions )
546{
547    char *      path = tr_strdup( path_in );
548    char *      p, * pp;
549    struct stat sb;
550    int         done;
551
552    /* walk past the root */
553    p = path;
554    while( *p == TR_PATH_DELIMITER )
555        ++p;
556
557    pp = p;
558    done = 0;
559    while( ( p =
560                strchr( pp, TR_PATH_DELIMITER ) ) || ( p = strchr( pp, '\0' ) ) )
561    {
562        if( !*p )
563            done = 1;
564        else
565            *p = '\0';
566
567        if( stat( path, &sb ) )
568        {
569            /* Folder doesn't exist yet */
570            if( tr_mkdir( path, permissions ) )
571            {
572                const int err = errno;
573                tr_err( _(
574                           "Couldn't create \"%1$s\": %2$s" ), path,
575                       tr_strerror( err ) );
576                tr_free( path );
577                errno = err;
578                return -1;
579            }
580        }
581        else if( ( sb.st_mode & S_IFMT ) != S_IFDIR )
582        {
583            /* Node exists but isn't a folder */
584            char * buf = tr_strdup_printf( _( "File \"%s\" is in the way" ), path );
585            tr_err( _( "Couldn't create \"%1$s\": %2$s" ), path_in, buf );
586            tr_free( buf );
587            tr_free( path );
588            errno = ENOTDIR;
589            return -1;
590        }
591
592        if( done )
593            break;
594
595        *p = TR_PATH_DELIMITER;
596        p++;
597        pp = p;
598    }
599
600    tr_free( path );
601    return 0;
602}
603
604char*
605tr_buildPath( const char *first_element, ... )
606{
607    size_t bufLen = 0;
608    const char * element;
609    char * buf;
610    char * pch;
611    va_list vl;
612
613    /* pass 1: allocate enough space for the string */
614    va_start( vl, first_element );
615    element = first_element;
616    while( element ) {
617        bufLen += strlen( element ) + 1;
618        element = va_arg( vl, const char* );
619    }
620    pch = buf = tr_new( char, bufLen );
621    va_end( vl );
622
623    /* pass 2: build the string piece by piece */
624    va_start( vl, first_element );
625    element = first_element;
626    while( element ) {
627        const size_t elementLen = strlen( element );
628        memcpy( pch, element, elementLen );
629        pch += elementLen;
630        *pch++ = TR_PATH_DELIMITER;
631        element = va_arg( vl, const char* );
632    }
633    va_end( vl );
634
635    /* terminate the string. if nonempty, eat the unwanted trailing slash */
636    if( pch != buf )
637        --pch;
638    *pch++ = '\0';
639
640    /* sanity checks & return */
641    assert( pch - buf == (off_t)bufLen );
642    return buf;
643}
644
645#ifdef SYS_DARWIN
646 #define TR_STAT_MTIME(sb) ((sb).st_mtimespec.tv_sec)
647#else
648 #define TR_STAT_MTIME(sb) ((sb).st_mtime)
649#endif
650
651bool
652tr_fileExists( const char * filename, time_t * mtime )
653{
654    struct stat sb;
655    const bool ok = !stat( filename, &sb );
656
657    if( ok && ( mtime != NULL ) )
658        *mtime = TR_STAT_MTIME( sb );
659
660    return ok;
661}
662
663/****
664*****
665****/
666
667char*
668evbuffer_free_to_str( struct evbuffer * buf )
669{
670    const size_t n = evbuffer_get_length( buf );
671    char * ret = tr_new( char, n + 1 );
672    evbuffer_copyout( buf, ret, n );
673    evbuffer_free( buf );
674    ret[n] = '\0';
675    return ret;
676}
677
678char*
679tr_strdup( const void * in )
680{
681    return tr_strndup( in, in ? (int)strlen((const char *)in) : 0 );
682}
683
684char*
685tr_strndup( const void * in, int len )
686{
687    char * out = NULL;
688
689    if( len < 0 )
690    {
691        out = tr_strdup( in );
692    }
693    else if( in )
694    {
695        out = tr_malloc( len + 1 );
696        memcpy( out, in, len );
697        out[len] = '\0';
698    }
699
700    return out;
701}
702
703const char*
704tr_memmem( const char * haystack, size_t haystacklen,
705           const char * needle, size_t needlelen )
706{
707#ifdef HAVE_MEMMEM
708    return memmem( haystack, haystacklen, needle, needlelen );
709#else
710    size_t i;
711    if( !needlelen )
712        return haystack;
713    if( needlelen > haystacklen || !haystack || !needle )
714        return NULL;
715    for( i=0; i<=haystacklen-needlelen; ++i )
716        if( !memcmp( haystack+i, needle, needlelen ) )
717            return haystack+i;
718    return NULL;
719#endif
720}
721
722char*
723tr_strdup_printf( const char * fmt, ... )
724{
725    va_list ap;
726    char * ret;
727    size_t len;
728    char statbuf[2048];
729
730    va_start( ap, fmt );
731    len = evutil_vsnprintf( statbuf, sizeof( statbuf ), fmt, ap );
732    va_end( ap );
733    if( len < sizeof( statbuf ) )
734        ret = tr_strndup( statbuf, len );
735    else {
736        ret = tr_new( char, len + 1 );
737        va_start( ap, fmt );
738        evutil_vsnprintf( ret, len + 1, fmt, ap );
739        va_end( ap );
740    }
741
742    return ret;
743}
744
745const char*
746tr_strerror( int i )
747{
748    const char * ret = strerror( i );
749
750    if( ret == NULL )
751        ret = "Unknown Error";
752    return ret;
753}
754
755int
756tr_strcmp0( const char * str1, const char * str2 )
757{
758    if( str1 && str2 ) return strcmp( str1, str2 );
759    if( str1 ) return 1;
760    if( str2 ) return -1;
761    return 0;
762}
763
764/****
765*****
766****/
767
768/* https://bugs.launchpad.net/percona-patches/+bug/526863/+attachment/1160199/+files/solaris_10_fix.patch */
769char*
770tr_strsep( char ** str, const char * delims )
771{
772#ifdef HAVE_STRSEP
773    return strsep( str, delims );
774#else
775    char *token;
776
777    if (*str == NULL) {
778        /* No more tokens */
779        return NULL;
780    }
781
782    token = *str;
783    while (**str != '\0') {
784        if (strchr(delims, **str) != NULL) {
785            **str = '\0';
786            (*str)++;
787            return token;
788        }
789        (*str)++;
790    }
791
792    /* There is not another token */
793    *str = NULL;
794
795    return token;
796#endif
797}
798
799char*
800tr_strstrip( char * str )
801{
802    if( str != NULL )
803    {
804        size_t pos;
805        size_t len = strlen( str );
806
807        while( len && isspace( str[len - 1] ) )
808            --len;
809
810        for( pos = 0; pos < len && isspace( str[pos] ); )
811            ++pos;
812
813        len -= pos;
814        memmove( str, str + pos, len );
815        str[len] = '\0';
816    }
817
818    return str;
819}
820
821bool
822tr_str_has_suffix( const char *str, const char *suffix )
823{
824    size_t str_len;
825    size_t suffix_len;
826
827    if( !str )
828        return false;
829    if( !suffix )
830        return true;
831
832    str_len = strlen( str );
833    suffix_len = strlen( suffix );
834    if( str_len < suffix_len )
835        return false;
836
837    return !evutil_ascii_strncasecmp( str + str_len - suffix_len, suffix, suffix_len );
838}
839
840/****
841*****
842****/
843
844uint64_t
845tr_time_msec( void )
846{
847    struct timeval tv;
848
849    gettimeofday( &tv, NULL );
850    return (uint64_t) tv.tv_sec * 1000 + ( tv.tv_usec / 1000 );
851}
852
853void
854tr_wait_msec( long int msec )
855{
856#ifdef WIN32
857    Sleep( (DWORD)msec );
858#else
859    struct timespec ts;
860    ts.tv_sec = msec / 1000;
861    ts.tv_nsec = ( msec % 1000 ) * 1000000;
862    nanosleep( &ts, NULL );
863#endif
864}
865
866/***
867****
868***/
869
870int
871tr_snprintf( char * buf, size_t buflen, const char * fmt, ... )
872{
873    int     len;
874    va_list args;
875
876    va_start( args, fmt );
877    len = evutil_vsnprintf( buf, buflen, fmt, args );
878    va_end( args );
879    return len;
880}
881
882/*
883 * Copy src to string dst of size siz. At most siz-1 characters
884 * will be copied. Always NUL terminates (unless siz == 0).
885 * Returns strlen(src); if retval >= siz, truncation occurred.
886 */
887size_t
888tr_strlcpy( char * dst, const void * src, size_t siz )
889{
890#ifdef HAVE_STRLCPY
891    return strlcpy( dst, src, siz );
892#else
893    char *      d = dst;
894    const char *s = src;
895    size_t      n = siz;
896
897    assert( s );
898    assert( d );
899
900    /* Copy as many bytes as will fit */
901    if( n != 0 )
902    {
903        while( --n != 0 )
904        {
905            if( ( *d++ = *s++ ) == '\0' )
906                break;
907        }
908    }
909
910    /* Not enough room in dst, add NUL and traverse rest of src */
911    if( n == 0 )
912    {
913        if( siz != 0 )
914            *d = '\0'; /* NUL-terminate dst */
915        while( *s++ )
916            ;
917    }
918
919    return s - (char*)src - 1;  /* count does not include NUL */
920#endif
921}
922
923/***
924****
925***/
926
927double
928tr_getRatio( uint64_t numerator, uint64_t denominator )
929{
930    double ratio;
931
932    if( denominator > 0 )
933        ratio = numerator / (double)denominator;
934    else if( numerator > 0 )
935        ratio = TR_RATIO_INF;
936    else
937        ratio = TR_RATIO_NA;
938
939    return ratio;
940}
941
942void
943tr_sha1_to_hex( char * out, const uint8_t * sha1 )
944{
945    int i;
946    static const char hex[] = "0123456789abcdef";
947
948    for( i=0; i<20; ++i )
949    {
950        const unsigned int val = *sha1++;
951        *out++ = hex[val >> 4];
952        *out++ = hex[val & 0xf];
953    }
954
955    *out = '\0';
956}
957
958void
959tr_hex_to_sha1( uint8_t * out, const char * in )
960{
961    int i;
962    static const char hex[] = "0123456789abcdef";
963
964    for( i=0; i<20; ++i )
965    {
966        const int hi = strchr( hex, tolower( *in++ ) ) - hex;
967        const int lo = strchr( hex, tolower( *in++ ) ) - hex;
968        *out++ = (uint8_t)( (hi<<4) | lo );
969    }
970}
971
972/***
973****
974***/
975
976static bool
977isValidURLChars( const char * url, int url_len )
978{
979    const char * c;
980    const char * end;
981    static const char * rfc2396_valid_chars =
982        "abcdefghijklmnopqrstuvwxyz" /* lowalpha */
983        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" /* upalpha */
984        "0123456789"                 /* digit */
985        "-_.!~*'()"                  /* mark */
986        ";/?:@&=+$,"                 /* reserved */
987        "<>#%<\""                    /* delims */
988        "{}|\\^[]`";                 /* unwise */
989
990    if( url == NULL )
991        return false;
992
993    for( c=url, end=c+url_len; c && *c && c!=end; ++c )
994        if( !strchr( rfc2396_valid_chars, *c ) )
995            return false;
996
997    return true;
998}
999
1000/** @brief return true if the URL is a http or https or UDP one that Transmission understands */
1001bool
1002tr_urlIsValidTracker( const char * url )
1003{
1004    bool valid;
1005
1006    if( url == NULL )
1007    {
1008        valid = false;
1009    }
1010    else
1011    {
1012        const int len = strlen( url );
1013
1014        valid = isValidURLChars( url, len )
1015            && !tr_urlParse( url, len, NULL, NULL, NULL, NULL )
1016            && ( !memcmp(url,"http://",7) || !memcmp(url,"https://",8) || !memcmp(url,"udp://",6) );
1017    }
1018
1019    return valid;
1020}
1021
1022/** @brief return true if the URL is a http or https or ftp or sftp one that Transmission understands */
1023bool
1024tr_urlIsValid( const char * url, int url_len )
1025{
1026    bool valid;
1027
1028    if( url == NULL )
1029    {
1030        valid = false;
1031    }
1032    else
1033    {
1034        if( url_len < 0 )
1035            url_len = strlen( url );
1036
1037        valid = isValidURLChars( url, url_len )
1038            && !tr_urlParse( url, url_len, NULL, NULL, NULL, NULL )
1039            && ( !memcmp(url,"http://",7) || !memcmp(url,"https://",8) || !memcmp(url,"ftp://",6) || !memcmp(url,"sftp://",7) );
1040    }
1041
1042    return valid;
1043}
1044
1045bool
1046tr_addressIsIP( const char * str )
1047{
1048    tr_address tmp;
1049    return tr_address_from_string( &tmp, str );
1050}
1051
1052int
1053tr_urlParse( const char * url_in,
1054             int          len,
1055             char **      setme_protocol,
1056             char **      setme_host,
1057             int *        setme_port,
1058             char **      setme_path )
1059{
1060    int          err;
1061    int          port = 0;
1062    int          n;
1063    char *       tmp;
1064    char *       pch;
1065    size_t       host_len;
1066    size_t       protocol_len;
1067    const char * host = NULL;
1068    const char * protocol = NULL;
1069    const char * path = NULL;
1070
1071    tmp = tr_strndup( url_in, len );
1072    if( ( pch = strstr( tmp, "://" ) ) )
1073    {
1074        *pch = '\0';
1075        protocol = tmp;
1076        protocol_len = pch - protocol;
1077        pch += 3;
1078/*fprintf( stderr, "protocol is [%s]... what's left is [%s]\n", protocol, pch);*/
1079        if( ( n = strcspn( pch, ":/" ) ) )
1080        {
1081            const int havePort = pch[n] == ':';
1082            host = pch;
1083            host_len = n;
1084            pch += n;
1085            if( pch && *pch )
1086                *pch++ = '\0';
1087/*fprintf( stderr, "host is [%s]... what's left is [%s]\n", host, pch );*/
1088            if( havePort )
1089            {
1090                char * end;
1091                port = strtol( pch, &end, 10 );
1092                pch = end;
1093/*fprintf( stderr, "port is [%d]... what's left is [%s]\n", port, pch );*/
1094            }
1095            path = pch;
1096/*fprintf( stderr, "path is [%s]\n", path );*/
1097        }
1098    }
1099
1100    err = !host || !path || !protocol;
1101
1102    if( !err && !port )
1103    {
1104        if( !strcmp( protocol, "udp" ) ) port = 80;
1105        else if( !strcmp( protocol, "ftp" ) ) port = 21;
1106        else if( !strcmp( protocol, "sftp" ) ) port = 22;
1107        else if( !strcmp( protocol, "http" ) ) port = 80;
1108        else if( !strcmp( protocol, "https" ) ) port = 443;
1109    }
1110
1111    if( !err )
1112    {
1113        if( setme_protocol ) *setme_protocol = tr_strndup( protocol, protocol_len );
1114
1115        if( setme_host ){ ( (char*)host )[-3] = ':'; *setme_host =
1116                              tr_strndup( host, host_len ); }
1117        if( setme_path ){ if( !*path ) *setme_path = tr_strdup( "/" );
1118                          else if( path[0] == '/' ) *setme_path = tr_strdup( path );
1119                          else { ( (char*)path )[-1] = '/'; *setme_path = tr_strdup( path - 1 ); } }
1120        if( setme_port ) *setme_port = port;
1121    }
1122
1123
1124    tr_free( tmp );
1125    return err;
1126}
1127
1128#include <string.h>
1129#include <openssl/sha.h>
1130#include <openssl/hmac.h>
1131#include <openssl/evp.h>
1132#include <openssl/bio.h>
1133#include <openssl/buffer.h>
1134
1135char *
1136tr_base64_encode( const void * input, int length, int * setme_len )
1137{
1138    int retlen = 0;
1139    char * ret = NULL;
1140
1141    if( input != NULL )
1142    {
1143        BIO * b64;
1144        BIO * bmem;
1145        BUF_MEM * bptr;
1146
1147        if( length < 1 )
1148            length = (int)strlen( input );
1149
1150        bmem = BIO_new( BIO_s_mem( ) );
1151        b64 = BIO_new( BIO_f_base64( ) );
1152        BIO_set_flags( b64, BIO_FLAGS_BASE64_NO_NL );
1153        b64 = BIO_push( b64, bmem );
1154        BIO_write( b64, input, length );
1155        (void) BIO_flush( b64 );
1156        BIO_get_mem_ptr( b64, &bptr );
1157        ret = tr_strndup( bptr->data, bptr->length );
1158        retlen = bptr->length;
1159        BIO_free_all( b64 );
1160    }
1161
1162    if( setme_len )
1163        *setme_len = retlen;
1164
1165    return ret;
1166}
1167
1168char *
1169tr_base64_decode( const void * input,
1170                  int          length,
1171                  int *        setme_len )
1172{
1173    char * ret;
1174    BIO *  b64;
1175    BIO *  bmem;
1176    int    retlen;
1177
1178    if( length < 1 )
1179        length = strlen( input );
1180
1181    ret = tr_new0( char, length );
1182    b64 = BIO_new( BIO_f_base64( ) );
1183    bmem = BIO_new_mem_buf( (unsigned char*)input, length );
1184    bmem = BIO_push( b64, bmem );
1185    retlen = BIO_read( bmem, ret, length );
1186    if( !retlen )
1187    {
1188        /* try again, but with the BIO_FLAGS_BASE64_NO_NL flag */
1189        BIO_free_all( bmem );
1190        b64 = BIO_new( BIO_f_base64( ) );
1191        BIO_set_flags( b64, BIO_FLAGS_BASE64_NO_NL );
1192        bmem = BIO_new_mem_buf( (unsigned char*)input, length );
1193        bmem = BIO_push( b64, bmem );
1194        retlen = BIO_read( bmem, ret, length );
1195    }
1196
1197    if( setme_len )
1198        *setme_len = retlen;
1199
1200    BIO_free_all( bmem );
1201    return ret;
1202}
1203
1204/***
1205****
1206***/
1207
1208void
1209tr_removeElementFromArray( void         * array,
1210                           unsigned int   index_to_remove,
1211                           size_t         sizeof_element,
1212                           size_t         nmemb )
1213{
1214    char * a = array;
1215
1216    memmove( a + sizeof_element * index_to_remove,
1217             a + sizeof_element * ( index_to_remove  + 1 ),
1218             sizeof_element * ( --nmemb - index_to_remove ) );
1219}
1220
1221int
1222tr_lowerBound( const void * key,
1223               const void * base,
1224               size_t       nmemb,
1225               size_t       size,
1226               int       (* compar)(const void* key, const void* arrayMember),
1227               bool       * exact_match )
1228{
1229    size_t first = 0;
1230    const char * cbase = base;
1231    bool exact = false;
1232
1233    while( nmemb != 0 )
1234    {
1235        const size_t half = nmemb / 2;
1236        const size_t middle = first + half;
1237        const int c = compar( key, cbase + size*middle );
1238
1239        if( c <= 0 ) {
1240            if( c == 0 )
1241                exact = true;
1242            nmemb = half;
1243        } else {
1244            first = middle + 1;
1245            nmemb = nmemb - half - 1;
1246        }
1247    }
1248
1249    *exact_match = exact;
1250
1251    return first;
1252}
1253
1254/***
1255****
1256***/
1257
1258static char*
1259strip_non_utf8( const char * in, size_t inlen )
1260{
1261    const char * end;
1262    const char zero = '\0';
1263    struct evbuffer * buf = evbuffer_new( );
1264
1265    while( !tr_utf8_validate( in, inlen, &end ) )
1266    {
1267        const int good_len = end - in;
1268
1269        evbuffer_add( buf, in, good_len );
1270        inlen -= ( good_len + 1 );
1271        in += ( good_len + 1 );
1272        evbuffer_add( buf, "?", 1 );
1273    }
1274
1275    evbuffer_add( buf, in, inlen );
1276    evbuffer_add( buf, &zero, 1 );
1277    return evbuffer_free_to_str( buf );
1278}
1279
1280static char*
1281to_utf8( const char * in, size_t inlen )
1282{
1283    char * ret = NULL;
1284
1285#ifdef HAVE_ICONV_OPEN
1286    int i;
1287    const char * encodings[] = { "CURRENT", "ISO-8859-15" };
1288    const int encoding_count = sizeof(encodings) / sizeof(encodings[1]);
1289    const size_t buflen = inlen*4 + 10;
1290    char * out = tr_new( char, buflen );
1291
1292    for( i=0; !ret && i<encoding_count; ++i )
1293    {
1294        char * inbuf = (char*) in;
1295        char * outbuf = out;
1296        size_t inbytesleft = inlen;
1297        size_t outbytesleft = buflen;
1298        const char * test_encoding = encodings[i];
1299
1300        iconv_t cd = iconv_open( "UTF-8", test_encoding );
1301        if( cd != (iconv_t)-1 ) {
1302            if( iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft ) != (size_t)-1 )
1303                ret = tr_strndup( out, buflen-outbytesleft );
1304            iconv_close( cd );
1305        }
1306    }
1307
1308    tr_free( out );
1309#endif
1310
1311    if( ret == NULL )
1312        ret = strip_non_utf8( in, inlen );
1313
1314    return ret;
1315}
1316
1317char*
1318tr_utf8clean( const char * str, int max_len )
1319{
1320    char * ret;
1321    const char * end;
1322
1323    if( max_len < 0 )
1324        max_len = (int) strlen( str );
1325
1326    if( tr_utf8_validate( str, max_len, &end  ) )
1327        ret = tr_strndup( str, max_len );
1328    else
1329        ret = to_utf8( str, max_len );
1330
1331    assert( tr_utf8_validate( ret, -1, NULL ) );
1332    return ret;
1333}
1334
1335/***
1336****
1337***/
1338
1339struct number_range
1340{
1341    int low;
1342    int high;
1343};
1344
1345/**
1346 * This should be a single number (ex. "6") or a range (ex. "6-9").
1347 * Anything else is an error and will return failure.
1348 */
1349static bool
1350parseNumberSection( const char * str, int len, struct number_range * setme )
1351{
1352    long a, b;
1353    bool success;
1354    char * end;
1355    const int error = errno;
1356    char * tmp = tr_strndup( str, len );
1357
1358    errno = 0;
1359    a = b = strtol( tmp, &end, 10 );
1360    if( errno || ( end == tmp ) ) {
1361        success = false;
1362    } else if( *end != '-' ) {
1363        success = true;
1364    } else {
1365        const char * pch = end + 1;
1366        b = strtol( pch, &end, 10 );
1367        if( errno || ( pch == end ) )
1368            success = false;
1369        else if( *end ) /* trailing data */
1370            success = false;
1371        else
1372            success = true;
1373    }
1374    tr_free( tmp );
1375
1376    setme->low = MIN( a, b );
1377    setme->high = MAX( a, b );
1378
1379    errno = error;
1380    return success;
1381}
1382
1383int
1384compareInt( const void * va, const void * vb )
1385{
1386    const int a = *(const int *)va;
1387    const int b = *(const int *)vb;
1388    return a - b;
1389}
1390
1391/**
1392 * Given a string like "1-4" or "1-4,6,9,14-51", this allocates and returns an
1393 * array of setmeCount ints of all the values in the array.
1394 * For example, "5-8" will return [ 5, 6, 7, 8 ] and setmeCount will be 4.
1395 * It's the caller's responsibility to call tr_free() on the returned array.
1396 * If a fragment of the string can't be parsed, NULL is returned.
1397 */
1398int*
1399tr_parseNumberRange( const char * str_in, int len, int * setmeCount )
1400{
1401    int n = 0;
1402    int * uniq = NULL;
1403    char * str = tr_strndup( str_in, len );
1404    const char * walk;
1405    tr_list * ranges = NULL;
1406    bool success = true;
1407
1408    walk = str;
1409    while( walk && *walk && success ) {
1410        struct number_range range;
1411        const char * pch = strchr( walk, ',' );
1412        if( pch ) {
1413            success = parseNumberSection( walk, pch-walk, &range );
1414            walk = pch + 1;
1415        } else {
1416            success = parseNumberSection( walk, strlen( walk ), &range );
1417            walk += strlen( walk );
1418        }
1419        if( success )
1420            tr_list_append( &ranges, tr_memdup( &range, sizeof( struct number_range ) ) );
1421    }
1422
1423    if( !success )
1424    {
1425        *setmeCount = 0;
1426        uniq = NULL;
1427    }
1428    else
1429    {
1430        int i;
1431        int n2;
1432        tr_list * l;
1433        int * sorted = NULL;
1434
1435        /* build a sorted number array */
1436        n = n2 = 0;
1437        for( l=ranges; l!=NULL; l=l->next ) {
1438            const struct number_range * r = l->data;
1439            n += r->high + 1 - r->low;
1440        }
1441        sorted = tr_new( int, n );
1442        for( l=ranges; l!=NULL; l=l->next ) {
1443            const struct number_range * r = l->data;
1444            int i;
1445            for( i=r->low; i<=r->high; ++i )
1446                sorted[n2++] = i;
1447        }
1448        qsort( sorted, n, sizeof( int ), compareInt );
1449        assert( n == n2 );
1450
1451        /* remove duplicates */
1452        uniq = tr_new( int, n );
1453        for( i=n=0; i<n2; ++i )
1454            if( !n || uniq[n-1] != sorted[i] )
1455                uniq[n++] = sorted[i];
1456
1457        tr_free( sorted );
1458    }
1459
1460    /* cleanup */
1461    tr_list_free( &ranges, tr_free );
1462    tr_free( str );
1463
1464    /* return the result */
1465    *setmeCount = n;
1466    return uniq;
1467}
1468
1469/***
1470****
1471***/
1472
1473double
1474tr_truncd( double x, int precision )
1475{
1476    char * pt;
1477    char buf[128];
1478    const int max_precision = (int) log10( 1.0 / DBL_EPSILON ) - 1;
1479    tr_snprintf( buf, sizeof( buf ), "%.*f", max_precision, x );
1480    if(( pt = strstr( buf, localeconv()->decimal_point )))
1481        pt[precision ? precision+1 : 0] = '\0';
1482    return atof(buf);
1483}
1484
1485/* return a truncated double as a string */
1486static char*
1487tr_strtruncd( char * buf, double x, int precision, size_t buflen )
1488{
1489    tr_snprintf( buf, buflen, "%.*f", precision, tr_truncd( x, precision ) );
1490    return buf;
1491}
1492
1493char*
1494tr_strpercent( char * buf, double x, size_t buflen )
1495{
1496    if( x < 10.0 )
1497        tr_strtruncd( buf, x, 2, buflen );
1498    else if( x < 100.0 )
1499        tr_strtruncd( buf, x, 1, buflen );
1500    else
1501        tr_strtruncd( buf, x, 0, buflen );
1502    return buf;
1503}
1504
1505char*
1506tr_strratio( char * buf, size_t buflen, double ratio, const char * infinity )
1507{
1508    if( (int)ratio == TR_RATIO_NA )
1509        tr_strlcpy( buf, _( "None" ), buflen );
1510    else if( (int)ratio == TR_RATIO_INF )
1511        tr_strlcpy( buf, infinity, buflen );
1512    else
1513        tr_strpercent( buf, ratio, buflen );
1514    return buf;
1515}
1516
1517int
1518tr_copyXattr( const char* srcpath, const char* dstpath )
1519{
1520    int ret = 0;
1521#ifdef HAVE_XATTRS_MACOS
1522    char * listbuf = NULL, * valuebuf = NULL;
1523    ssize_t listlen = 0, valuelen = 0;
1524    char* name;
1525
1526    listlen = listxattr( srcpath, NULL, 0, 0 );
1527
1528    if( listlen <= 0 ) {
1529        ret = -1;
1530        goto out;
1531    }
1532
1533    listbuf = tr_malloc( listlen );
1534    if( listbuf == NULL ) {
1535        ret = -1;
1536        goto out;
1537    }
1538
1539    listlen = listxattr( srcpath, listbuf, listlen, 0 );
1540    if( listlen <= 0) {
1541        ret = -1;
1542        goto out;
1543    }
1544
1545    for( name = listbuf; name < listbuf + listlen; name = strchr( name, '\0' ) + 1) {
1546        ssize_t len = getxattr( srcpath, name, NULL, 0, 0, 0);
1547        if( len < 0 ) {
1548            ret = -1;
1549            goto out;
1550        }
1551
1552        if( len > valuelen ) {
1553            valuelen = len;
1554            valuebuf = reallocf( valuebuf, valuelen );
1555            if (valuebuf == NULL) {
1556                ret = -1;
1557                goto out;
1558            }
1559        }
1560
1561        len = getxattr( srcpath, name, valuebuf, valuelen, 0, 0 );
1562        if ( len < 0) {
1563            ret = -1;
1564            goto out;
1565        }
1566
1567        ret = setxattr( dstpath, name, valuebuf, len, 0, 0 );
1568        if( ret != 0 ) {
1569            ret = -1;
1570            goto out;
1571        }
1572    }
1573
1574out:
1575    tr_free( valuebuf );
1576    tr_free( listbuf );
1577
1578    if( ret != 0 )
1579        tr_err( "Couldn't copy xattrs from \"%s\" to \"%s\": %s",
1580                srcpath, dstpath, tr_strerror( errno ) );
1581
1582#endif
1583    return ret;
1584}
1585
1586/***
1587****
1588***/
1589
1590int
1591tr_moveFile( const char * oldpath, const char * newpath, bool * renamed )
1592{
1593    int in;
1594    int out;
1595    char * buf;
1596    struct stat st;
1597    off_t bytesLeft;
1598    const size_t buflen = 1024 * 128; /* 128 KiB buffer */
1599
1600    /* make sure the old file exists */
1601    if( stat( oldpath, &st ) ) {
1602        const int err = errno;
1603        errno = err;
1604        return -1;
1605    }
1606    if( !S_ISREG( st.st_mode ) ) {
1607        errno = ENOENT;
1608        return -1;
1609    }
1610    bytesLeft = st.st_size;
1611
1612    /* make sure the target directory exists */
1613    {
1614        char * newdir = tr_dirname( newpath );
1615        int i = tr_mkdirp( newdir, 0777 );
1616        tr_free( newdir );
1617        if( i )
1618            return i;
1619    }
1620
1621    /* they might be on the same filesystem... */
1622    {
1623        const int i = rename( oldpath, newpath );
1624        if( renamed != NULL )
1625            *renamed = i == 0;
1626        if( !i )
1627            return 0;
1628    }
1629
1630    /* copy the file */
1631    in = tr_open_file_for_scanning( oldpath );
1632    out = tr_open_file_for_writing( newpath );
1633    buf = tr_valloc( buflen );
1634    while( bytesLeft > 0 )
1635    {
1636        ssize_t bytesWritten;
1637        const off_t bytesThisPass = MIN( bytesLeft, (off_t)buflen );
1638        const int numRead = read( in, buf, bytesThisPass );
1639        if( numRead < 0 )
1640            break;
1641        bytesWritten = write( out, buf, numRead );
1642        if( bytesWritten < 0 )
1643            break;
1644        bytesLeft -= bytesWritten;
1645    }
1646
1647    /* cleanup */
1648    tr_free( buf );
1649    tr_close_file( out );
1650    tr_close_file( in );
1651    if( bytesLeft != 0 )
1652        return -1;
1653
1654    tr_copyXattr( oldpath, newpath );
1655    unlink( oldpath );
1656    return 0;
1657}
1658
1659bool
1660tr_is_same_file( const char * filename1, const char * filename2 )
1661{
1662    struct stat sb1, sb2;
1663
1664    return !stat( filename1, &sb1 )
1665        && !stat( filename2, &sb2 )
1666        && ( sb1.st_dev == sb2.st_dev )
1667        && ( sb1.st_ino == sb2.st_ino );
1668}
1669
1670/***
1671****
1672***/
1673
1674void*
1675tr_valloc( size_t bufLen )
1676{
1677    size_t allocLen;
1678    void * buf = NULL;
1679    static size_t pageSize = 0;
1680
1681    if( !pageSize ) {
1682#ifdef HAVE_GETPAGESIZE
1683        pageSize = (size_t) getpagesize();
1684#else /* guess */
1685        pageSize = 4096;
1686#endif
1687    }
1688
1689    allocLen = pageSize;
1690    while( allocLen < bufLen )
1691        allocLen += pageSize;
1692
1693#ifdef HAVE_POSIX_MEMALIGN
1694    if( !buf )
1695        if( posix_memalign( &buf, pageSize, allocLen ) )
1696            buf = NULL; /* just retry with valloc/malloc */
1697#endif
1698#ifdef HAVE_VALLOC
1699    if( !buf )
1700        buf = valloc( allocLen );
1701#endif
1702    if( !buf )
1703        buf = tr_malloc( allocLen );
1704
1705    return buf;
1706}
1707
1708char *
1709tr_realpath( const char * path, char * resolved_path )
1710{
1711#ifdef WIN32
1712    /* From a message to the Mingw-msys list, Jun 2, 2005 by Mark Junker. */
1713    if( GetFullPathNameA( path, TR_PATH_MAX, resolved_path, NULL ) == 0 )
1714        return NULL;
1715    return resolved_path;
1716#else
1717    return realpath( path, resolved_path );
1718#endif
1719}
1720
1721/***
1722****
1723***/
1724
1725uint64_t
1726tr_htonll( uint64_t x )
1727{
1728#ifdef HAVE_HTONLL
1729    return htonll( x );
1730#else
1731    /* fallback code by bdonlan at
1732     * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
1733    union { uint32_t lx[2]; uint64_t llx; } u;
1734    u.lx[0] = htonl(x >> 32);
1735    u.lx[1] = htonl(x & 0xFFFFFFFFULL);
1736    return u.llx;
1737#endif
1738}
1739
1740uint64_t
1741tr_ntohll( uint64_t x )
1742{
1743#ifdef HAVE_NTOHLL
1744    return ntohll( x );
1745#else
1746    /* fallback code by bdonlan at
1747     * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
1748    union { uint32_t lx[2]; uint64_t llx; } u;
1749    u.llx = x;
1750    return ((uint64_t)ntohl(u.lx[0]) << 32) | (uint64_t)ntohl(u.lx[1]);
1751#endif
1752}
1753
1754/***
1755****
1756****
1757****
1758***/
1759
1760struct formatter_unit
1761{
1762    char * name;
1763    int64_t value;
1764};
1765
1766struct formatter_units
1767{
1768    struct formatter_unit units[4];
1769};
1770
1771enum { TR_FMT_KB, TR_FMT_MB, TR_FMT_GB, TR_FMT_TB };
1772
1773static void
1774formatter_init( struct formatter_units * units,
1775                unsigned int kilo,
1776                const char * kb, const char * mb,
1777                const char * gb, const char * tb )
1778{
1779    uint64_t value = kilo;
1780    units->units[TR_FMT_KB].name = tr_strdup( kb );
1781    units->units[TR_FMT_KB].value = value;
1782
1783    value *= kilo;
1784    units->units[TR_FMT_MB].name = tr_strdup( mb );
1785    units->units[TR_FMT_MB].value = value;
1786
1787    value *= kilo;
1788    units->units[TR_FMT_GB].name = tr_strdup( gb );
1789    units->units[TR_FMT_GB].value = value;
1790
1791    value *= kilo;
1792    units->units[TR_FMT_TB].name = tr_strdup( tb );
1793    units->units[TR_FMT_TB].value = value;
1794}
1795
1796static char*
1797formatter_get_size_str( const struct formatter_units * u,
1798                        char * buf, int64_t bytes, size_t buflen )
1799{
1800    int precision;
1801    double value;
1802    const char * units;
1803    const struct formatter_unit * unit;
1804
1805         if( bytes < u->units[1].value ) unit = &u->units[0];
1806    else if( bytes < u->units[2].value ) unit = &u->units[1];
1807    else if( bytes < u->units[3].value ) unit = &u->units[2];
1808    else                                 unit = &u->units[3];
1809
1810    value = (double)bytes / unit->value;
1811    units = unit->name;
1812    if( unit->value == 1 )
1813        precision = 0;
1814    else if( value < 100 )
1815        precision = 2;
1816    else
1817        precision = 1;
1818    tr_snprintf( buf, buflen, "%.*f %s", precision, value, units );
1819    return buf;
1820}
1821
1822static struct formatter_units size_units;
1823
1824void
1825tr_formatter_size_init( unsigned int kilo,
1826                        const char * kb, const char * mb,
1827                        const char * gb, const char * tb )
1828{
1829    formatter_init( &size_units, kilo, kb, mb, gb, tb );
1830}
1831
1832char*
1833tr_formatter_size_B( char * buf, int64_t bytes, size_t buflen )
1834{
1835    return formatter_get_size_str( &size_units, buf, bytes, buflen );
1836}
1837
1838static struct formatter_units speed_units;
1839
1840unsigned int tr_speed_K = 0u;
1841
1842void
1843tr_formatter_speed_init( unsigned int kilo,
1844                         const char * kb, const char * mb,
1845                         const char * gb, const char * tb )
1846{
1847    tr_speed_K = kilo;
1848    formatter_init( &speed_units, kilo, kb, mb, gb, tb );
1849}
1850
1851char*
1852tr_formatter_speed_KBps( char * buf, double KBps, size_t buflen )
1853{
1854    const double K = speed_units.units[TR_FMT_KB].value;
1855    double speed = KBps;
1856
1857    if( speed <= 999.95 ) /* 0.0 KB to 999.9 KB */
1858        tr_snprintf( buf, buflen, "%d %s", (int)speed, speed_units.units[TR_FMT_KB].name );
1859    else {
1860        speed /= K;
1861        if( speed <= 99.995 ) /* 0.98 MB to 99.99 MB */
1862            tr_snprintf( buf, buflen, "%.2f %s", speed, speed_units.units[TR_FMT_MB].name );
1863        else if (speed <= 999.95) /* 100.0 MB to 999.9 MB */
1864            tr_snprintf( buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_MB].name );
1865        else {
1866            speed /= K;
1867            tr_snprintf( buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_GB].name );
1868        }
1869    }
1870
1871    return buf;
1872}
1873
1874static struct formatter_units mem_units;
1875
1876unsigned int tr_mem_K = 0u;
1877
1878void
1879tr_formatter_mem_init( unsigned int kilo,
1880                       const char * kb, const char * mb,
1881                       const char * gb, const char * tb )
1882{
1883    tr_mem_K = kilo;
1884    formatter_init( &mem_units, kilo, kb, mb, gb, tb );
1885}
1886
1887char*
1888tr_formatter_mem_B( char * buf, int64_t bytes_per_second, size_t buflen )
1889{
1890    return formatter_get_size_str( &mem_units, buf, bytes_per_second, buflen );
1891}
1892
1893void
1894tr_formatter_get_units( tr_benc * d )
1895{
1896    int i;
1897    tr_benc * l;
1898
1899    tr_bencDictReserve( d, 6 );
1900
1901    tr_bencDictAddInt( d, "memory-bytes", mem_units.units[TR_FMT_KB].value );
1902    l = tr_bencDictAddList( d, "memory-units", 4 );
1903    for( i=0; i<4; i++ ) tr_bencListAddStr( l, mem_units.units[i].name );
1904
1905    tr_bencDictAddInt( d, "size-bytes",   size_units.units[TR_FMT_KB].value );
1906    l = tr_bencDictAddList( d, "size-units", 4 );
1907    for( i=0; i<4; i++ ) tr_bencListAddStr( l, size_units.units[i].name );
1908
1909    tr_bencDictAddInt( d, "speed-bytes",  speed_units.units[TR_FMT_KB].value );
1910    l = tr_bencDictAddList( d, "speed-units", 4 );
1911    for( i=0; i<4; i++ ) tr_bencListAddStr( l, speed_units.units[i].name );
1912}
1913
Note: See TracBrowser for help on using the repository browser.