source: trunk/libtransmission/utils.c @ 13708

Last change on this file since 13708 was 13708, checked in by jordan, 9 years ago

(trunk, libT) #5199 'tr_sessionGetNextQueuedTorrent() can be faster' -- copy peer-mgr.c's partial-sorting peer candidate code to a reusable function in utils.c, tr_quickfindFirstK()"

  • Property svn:keywords set to Date Rev Author Id
File size: 43.2 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 13708 2012-12-28 20:07:50Z jordan $
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#endif
23
24#include <assert.h>
25#include <ctype.h> /* isdigit (), isalpha (), tolower () */
26#include <errno.h>
27#include <float.h> /* DBL_EPSILON */
28#include <locale.h> /* localeconv () */
29#include <math.h> /* pow (), fabs (), floor () */
30#include <stdarg.h>
31#include <stdio.h>
32#include <stdlib.h>
33#include <string.h> /* strerror (), memset (), memmem () */
34#include <time.h> /* nanosleep () */
35
36#ifdef HAVE_ICONV_OPEN
37 #include <iconv.h>
38#endif
39#include <libgen.h> /* basename () */
40#include <sys/time.h>
41#include <sys/types.h>
42#include <sys/stat.h>
43#include <unistd.h> /* stat (), getcwd (), getpagesize (), unlink () */
44
45#include <event2/buffer.h>
46#include <event2/event.h>
47
48#ifdef WIN32
49 #include <w32api.h>
50 #define WINVER WindowsXP /* freeaddrinfo (), getaddrinfo (), getnameinfo () */
51 #include <direct.h> /* _getcwd () */
52 #include <windows.h> /* Sleep () */
53#endif
54
55#include "transmission.h"
56#include "fdlimit.h"
57#include "ConvertUTF.h"
58#include "list.h"
59#include "utils.h"
60#include "platform.h" /* tr_lockLock (), TR_PATH_MAX */
61#include "variant.h"
62#include "version.h"
63
64
65time_t       __tr_current_time   = 0;
66tr_msg_level __tr_message_level  = TR_MSG_ERR;
67
68static bool           messageQueuing = false;
69static tr_msg_list *  messageQueue = NULL;
70static tr_msg_list ** messageQueueTail = &messageQueue;
71static int            messageQueueCount = 0;
72
73#ifndef WIN32
74    /* make null versions of these win32 functions */
75    static inline int IsDebuggerPresent (void) { return false; }
76    static inline void OutputDebugString (const void * unused UNUSED) { }
77#endif
78
79/***
80****
81***/
82
83static tr_lock*
84getMessageLock (void)
85{
86    static tr_lock * l = NULL;
87
88    if (!l)
89        l = tr_lockNew ();
90
91    return l;
92}
93
94void*
95tr_getLog (void)
96{
97    static bool initialized = false;
98    static FILE * file = NULL;
99
100    if (!initialized)
101    {
102        const char * str = getenv ("TR_DEBUG_FD");
103        int          fd = 0;
104        if (str && *str)
105            fd = atoi (str);
106        switch (fd)
107        {
108            case 1:
109                file = stdout; break;
110
111            case 2:
112                file = stderr; break;
113
114            default:
115                file = NULL; break;
116        }
117        initialized = true;
118    }
119
120    return file;
121}
122
123void
124tr_setMessageLevel (tr_msg_level level)
125{
126    __tr_message_level = level;
127}
128
129void
130tr_setMessageQueuing (bool enabled)
131{
132    messageQueuing = enabled;
133}
134
135bool
136tr_getMessageQueuing (void)
137{
138    return messageQueuing != 0;
139}
140
141tr_msg_list *
142tr_getQueuedMessages (void)
143{
144    tr_msg_list * ret;
145    tr_lockLock (getMessageLock ());
146
147    ret = messageQueue;
148    messageQueue = NULL;
149    messageQueueTail = &messageQueue;
150
151    messageQueueCount = 0;
152
153    tr_lockUnlock (getMessageLock ());
154    return ret;
155}
156
157void
158tr_freeMessageList (tr_msg_list * list)
159{
160    tr_msg_list * next;
161
162    while (NULL != list)
163    {
164        next = list->next;
165        free (list->message);
166        free (list->name);
167        free (list);
168        list = next;
169    }
170}
171
172/**
173***
174**/
175
176struct tm *
177tr_localtime_r (const time_t *_clock, struct tm *_result)
178{
179#ifdef HAVE_LOCALTIME_R
180    return localtime_r (_clock, _result);
181#else
182    struct tm *p = localtime (_clock);
183    if (p)
184        * (_result) = *p;
185    return p;
186#endif
187}
188
189char*
190tr_getLogTimeStr (char * buf, int buflen)
191{
192    char           tmp[64];
193    struct tm      now_tm;
194    struct timeval tv;
195    time_t         seconds;
196    int            milliseconds;
197
198    gettimeofday (&tv, NULL);
199
200    seconds = tv.tv_sec;
201    tr_localtime_r (&seconds, &now_tm);
202    strftime (tmp, sizeof (tmp), "%H:%M:%S", &now_tm);
203    milliseconds = tv.tv_usec / 1000;
204    tr_snprintf (buf, buflen, "%s.%03d", tmp, milliseconds);
205
206    return buf;
207}
208
209bool
210tr_deepLoggingIsActive (void)
211{
212    static int8_t deepLoggingIsActive = -1;
213
214    if (deepLoggingIsActive < 0)
215        deepLoggingIsActive = IsDebuggerPresent () || (tr_getLog ()!=NULL);
216
217    return deepLoggingIsActive != 0;
218}
219
220void
221tr_deepLog (const char  * file,
222            int           line,
223            const char  * name,
224            const char  * fmt,
225            ...)
226{
227    FILE * fp = tr_getLog ();
228    if (fp || IsDebuggerPresent ())
229    {
230        va_list           args;
231        char              timestr[64];
232        struct evbuffer * buf = evbuffer_new ();
233        char *            base = tr_basename (file);
234        char *            message;
235
236        evbuffer_add_printf (buf, "[%s] ",
237                            tr_getLogTimeStr (timestr, sizeof (timestr)));
238        if (name)
239            evbuffer_add_printf (buf, "%s ", name);
240        va_start (args, fmt);
241        evbuffer_add_vprintf (buf, fmt, args);
242        va_end (args);
243        evbuffer_add_printf (buf, " (%s:%d)\n", base, line);
244        /* FIXME (libevent2) ifdef this out for nonwindows platforms */
245        message = evbuffer_free_to_str (buf);
246        OutputDebugString (message);
247        if (fp)
248            fputs (message, fp);
249
250        tr_free (message);
251        tr_free (base);
252    }
253}
254
255/***
256****
257***/
258
259void
260tr_msg (const char * file, int line,
261        tr_msg_level level,
262        const char * name,
263        const char * fmt, ...)
264{
265    const int err = errno; /* message logging shouldn't affect errno */
266    char buf[1024];
267    va_list ap;
268    tr_lockLock (getMessageLock ());
269
270    /* build the text message */
271    *buf = '\0';
272    va_start (ap, fmt);
273    evutil_vsnprintf (buf, sizeof (buf), fmt, ap);
274    va_end (ap);
275
276    OutputDebugString (buf);
277
278    if (*buf)
279    {
280        if (messageQueuing)
281        {
282            tr_msg_list * newmsg;
283            newmsg = tr_new0 (tr_msg_list, 1);
284            newmsg->level = level;
285            newmsg->when = tr_time ();
286            newmsg->message = tr_strdup (buf);
287            newmsg->file = file;
288            newmsg->line = line;
289            newmsg->name = tr_strdup (name);
290
291            *messageQueueTail = newmsg;
292            messageQueueTail = &newmsg->next;
293            ++messageQueueCount;
294
295            if (messageQueueCount > TR_MAX_MSG_LOG)
296            {
297                tr_msg_list * old = messageQueue;
298                messageQueue = old->next;
299                old->next = NULL;
300                tr_freeMessageList (old);
301
302                --messageQueueCount;
303
304                assert (messageQueueCount == TR_MAX_MSG_LOG);
305            }
306        }
307        else
308        {
309            char timestr[64];
310            FILE * fp;
311
312            fp = tr_getLog ();
313            if (fp == NULL)
314                fp = stderr;
315
316            tr_getLogTimeStr (timestr, sizeof (timestr));
317
318            if (name)
319                fprintf (fp, "[%s] %s: %s\n", timestr, name, buf);
320            else
321                fprintf (fp, "[%s] %s\n", timestr, buf);
322            fflush (fp);
323        }
324    }
325
326    tr_lockUnlock (getMessageLock ());
327    errno = err;
328}
329
330/***
331****
332***/
333
334void*
335tr_malloc (size_t size)
336{
337    return size ? malloc (size) : NULL;
338}
339
340void*
341tr_malloc0 (size_t size)
342{
343    return size ? calloc (1, size) : NULL;
344}
345
346void
347tr_free (void * p)
348{
349    if (p != NULL)
350        free (p);
351}
352
353void*
354tr_memdup (const void * src, size_t byteCount)
355{
356    return memcpy (tr_malloc (byteCount), src, byteCount);
357}
358
359/***
360****
361***/
362
363const char*
364tr_strip_positional_args (const char* str)
365{
366    const char * in = str;
367    static size_t bufsize = 0;
368    static char * buf = NULL;
369    const size_t  len = str ? strlen (str) : 0;
370    char *        out;
371
372    if (!buf || (bufsize < len))
373    {
374        bufsize = len * 2 + 1;
375        buf = tr_renew (char, buf, bufsize);
376    }
377
378    for (out = buf; str && *str; ++str)
379    {
380        *out++ = *str;
381
382        if ((*str == '%') && isdigit (str[1]))
383        {
384            const char * tmp = str + 1;
385            while (isdigit (*tmp))
386                ++tmp;
387            if (*tmp == '$')
388                str = tmp[1]=='\'' ? tmp+1 : tmp;
389        }
390
391        if ((*str == '%') && (str[1] == '\''))
392            str = str + 1;
393
394    }
395    *out = '\0';
396
397    return !in || strcmp (buf, in) ? buf : in;
398}
399
400/**
401***
402**/
403
404void
405tr_timerAdd (struct event * timer, int seconds, int microseconds)
406{
407    struct timeval tv;
408    tv.tv_sec = seconds;
409    tv.tv_usec = microseconds;
410
411    assert (tv.tv_sec >= 0);
412    assert (tv.tv_usec >= 0);
413    assert (tv.tv_usec < 1000000);
414
415    evtimer_add (timer, &tv);
416}
417
418void
419tr_timerAddMsec (struct event * timer, int msec)
420{
421    const int seconds =  msec / 1000;
422    const int usec = (msec%1000) * 1000;
423    tr_timerAdd (timer, seconds, usec);
424}
425
426/**
427***
428**/
429
430uint8_t *
431tr_loadFile (const char * path,
432             size_t *     size)
433{
434    uint8_t * buf;
435    struct stat  sb;
436    int fd;
437    ssize_t n;
438    const char * const err_fmt = _("Couldn't read \"%1$s\": %2$s");
439
440    /* try to stat the file */
441    errno = 0;
442    if (stat (path, &sb))
443    {
444        const int err = errno;
445        tr_dbg (err_fmt, path, tr_strerror (errno));
446        errno = err;
447        return NULL;
448    }
449
450    if ((sb.st_mode & S_IFMT) != S_IFREG)
451    {
452        tr_err (err_fmt, path, _("Not a regular file"));
453        errno = EISDIR;
454        return NULL;
455    }
456
457    /* Load the torrent file into our buffer */
458    fd = tr_open_file_for_scanning (path);
459    if (fd < 0)
460    {
461        const int err = errno;
462        tr_err (err_fmt, path, tr_strerror (errno));
463        errno = err;
464        return NULL;
465    }
466    buf = tr_malloc (sb.st_size + 1);
467    if (!buf)
468    {
469        const int err = errno;
470        tr_err (err_fmt, path, _("Memory allocation failed"));
471        tr_close_file (fd);
472        errno = err;
473        return NULL;
474    }
475    n = read (fd, buf, (size_t)sb.st_size);
476    if (n == -1)
477    {
478        const int err = errno;
479        tr_err (err_fmt, path, tr_strerror (errno));
480        tr_close_file (fd);
481        free (buf);
482        errno = err;
483        return NULL;
484    }
485
486    tr_close_file (fd);
487    buf[ sb.st_size ] = '\0';
488    *size = sb.st_size;
489    return buf;
490}
491
492char*
493tr_basename (const char * path)
494{
495    char * tmp = tr_strdup (path);
496    char * ret = tr_strdup (basename (tmp));
497    tr_free (tmp);
498    return ret;
499}
500
501char*
502tr_dirname (const char * path)
503{
504    char * tmp = tr_strdup (path);
505    char * ret = tr_strdup (dirname (tmp));
506    tr_free (tmp);
507    return ret;
508}
509
510char*
511tr_mkdtemp (char * template)
512{
513#ifdef HAVE_MKDTEMP
514    return mkdtemp (template);
515#else
516    if (!mktemp (template) || mkdir (template, 0700))
517        return NULL;
518    return template;
519#endif
520}
521
522/**
523 * @brief Portability wrapper for mkdir ()
524 *
525 * A portability wrapper around mkdir ().
526 * On WIN32, the `permissions' argument is unused.
527 *
528 * @return zero on success, or -1 if an error occurred
529 * (in which case errno is set appropriately).
530 */
531static int
532tr_mkdir (const char * path, int permissions UNUSED)
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***/
1258
1259/* Byte-wise swap two items of size SIZE.
1260   From glibc, written by Douglas C. Schmidt, LGPL 2.1 or higher */
1261#define SWAP(a, b, size) \
1262  do { \
1263    register size_t __size = (size); \
1264    register char *__a = (a), *__b = (b); \
1265    if (__a != __b) do { \
1266      char __tmp = *__a; \
1267      *__a++ = *__b; \
1268      *__b++ = __tmp; \
1269    } while (--__size > 0); \
1270  } while (0)
1271
1272
1273static size_t
1274quickfindPartition (char * base, size_t left, size_t right, size_t size,
1275                    int (*compar)(const void *, const void *), size_t pivotIndex)
1276{
1277  size_t i;
1278  size_t storeIndex;
1279
1280  /* move pivot to the end */
1281  SWAP (base+(size*pivotIndex), base+(size*right), size);
1282
1283  storeIndex = left;
1284  for (i=left; i<=right-1; ++i)
1285    {
1286      if (compar (base+(size*i), base+(size*right)) <= 0)
1287        {
1288          SWAP (base+(size*storeIndex), base+(size*i), size);
1289          ++storeIndex;
1290        }
1291    }
1292
1293  /* move pivot to its final place */
1294  SWAP (base+(size*right), base+(size*storeIndex), size);
1295
1296  /* sanity check the partition */
1297#ifndef NDEBUG
1298  assert (storeIndex >= left);
1299  assert (storeIndex <= right);
1300
1301  for (i=left; i<storeIndex; ++i)
1302    assert (compar (base+(size*i), base+(size*storeIndex)) <= 0);
1303  for (i=storeIndex+1; i<=right; ++i)
1304    assert (compar (base+(size*i), base+(size*storeIndex)) >= 0);
1305#endif
1306
1307  return storeIndex;
1308}
1309
1310static void
1311quickfindFirstK (char * base, size_t left, size_t right, size_t size,
1312                 int (*compar)(const void *, const void *), size_t k)
1313{
1314  if (right > left)
1315    {
1316      const size_t pivotIndex = left + (right-left)/2u;
1317
1318      const size_t pivotNewIndex = quickfindPartition (base, left, right, size, compar, pivotIndex);
1319
1320      if (pivotNewIndex > left + k) /* new condition */
1321        quickfindFirstK (base, left, pivotNewIndex-1, size, compar, k);
1322      else if (pivotNewIndex < left + k)
1323        quickfindFirstK (base, pivotNewIndex+1, right, size, compar, k+left-pivotNewIndex-1);
1324    }
1325}
1326
1327#ifndef NDEBUG
1328static void
1329checkBestScoresComeFirst (char * base, size_t nmemb, size_t size,
1330                          int (*compar)(const void *, const void *), size_t k)
1331{
1332  size_t i;
1333  size_t worstFirstPos = 0;
1334
1335  for (i=1; i<k; ++i)
1336    if (compar (base+(size*worstFirstPos), base+(size*i)) < 0)
1337      worstFirstPos = i;
1338
1339  for (i=0; i<k; ++i)
1340    assert (compar (base+(size*i), base+(size*worstFirstPos)) <= 0);
1341  for (i=k; i<nmemb; ++i)
1342    assert (compar (base+(size*i), base+(size*worstFirstPos)) >= 0);
1343}
1344#endif
1345
1346void
1347tr_quickfindFirstK (void * base, size_t nmemb, size_t size,
1348                    int (*compar)(const void *, const void *), size_t k)
1349{
1350  if (k < nmemb)
1351    {
1352      quickfindFirstK (base, 0, nmemb-1, size, compar, k);
1353
1354#ifndef NDEBUG
1355      checkBestScoresComeFirst (base, nmemb, size, compar, k);
1356#endif
1357    }
1358}
1359
1360/***
1361****
1362***/
1363
1364static char*
1365strip_non_utf8 (const char * in, size_t inlen)
1366{
1367    const char * end;
1368    const char zero = '\0';
1369    struct evbuffer * buf = evbuffer_new ();
1370
1371    while (!tr_utf8_validate (in, inlen, &end))
1372    {
1373        const int good_len = end - in;
1374
1375        evbuffer_add (buf, in, good_len);
1376        inlen -= (good_len + 1);
1377        in += (good_len + 1);
1378        evbuffer_add (buf, "?", 1);
1379    }
1380
1381    evbuffer_add (buf, in, inlen);
1382    evbuffer_add (buf, &zero, 1);
1383    return evbuffer_free_to_str (buf);
1384}
1385
1386static char*
1387to_utf8 (const char * in, size_t inlen)
1388{
1389    char * ret = NULL;
1390
1391#ifdef HAVE_ICONV_OPEN
1392    int i;
1393    const char * encodings[] = { "CURRENT", "ISO-8859-15" };
1394    const int encoding_count = sizeof (encodings) / sizeof (encodings[1]);
1395    const size_t buflen = inlen*4 + 10;
1396    char * out = tr_new (char, buflen);
1397
1398    for (i=0; !ret && i<encoding_count; ++i)
1399    {
1400        char * inbuf = (char*) in;
1401        char * outbuf = out;
1402        size_t inbytesleft = inlen;
1403        size_t outbytesleft = buflen;
1404        const char * test_encoding = encodings[i];
1405
1406        iconv_t cd = iconv_open ("UTF-8", test_encoding);
1407        if (cd != (iconv_t)-1) {
1408            if (iconv (cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft) != (size_t)-1)
1409                ret = tr_strndup (out, buflen-outbytesleft);
1410            iconv_close (cd);
1411        }
1412    }
1413
1414    tr_free (out);
1415#endif
1416
1417    if (ret == NULL)
1418        ret = strip_non_utf8 (in, inlen);
1419
1420    return ret;
1421}
1422
1423char*
1424tr_utf8clean (const char * str, int max_len)
1425{
1426    char * ret;
1427    const char * end;
1428
1429    if (max_len < 0)
1430        max_len = (int) strlen (str);
1431
1432    if (tr_utf8_validate (str, max_len, &end))
1433        ret = tr_strndup (str, max_len);
1434    else
1435        ret = to_utf8 (str, max_len);
1436
1437    assert (tr_utf8_validate (ret, -1, NULL));
1438    return ret;
1439}
1440
1441/***
1442****
1443***/
1444
1445struct number_range
1446{
1447    int low;
1448    int high;
1449};
1450
1451/**
1452 * This should be a single number (ex. "6") or a range (ex. "6-9").
1453 * Anything else is an error and will return failure.
1454 */
1455static bool
1456parseNumberSection (const char * str, int len, struct number_range * setme)
1457{
1458    long a, b;
1459    bool success;
1460    char * end;
1461    const int error = errno;
1462    char * tmp = tr_strndup (str, len);
1463
1464    errno = 0;
1465    a = b = strtol (tmp, &end, 10);
1466    if (errno || (end == tmp)) {
1467        success = false;
1468    } else if (*end != '-') {
1469        success = true;
1470    } else {
1471        const char * pch = end + 1;
1472        b = strtol (pch, &end, 10);
1473        if (errno || (pch == end))
1474            success = false;
1475        else if (*end) /* trailing data */
1476            success = false;
1477        else
1478            success = true;
1479    }
1480    tr_free (tmp);
1481
1482    setme->low = MIN (a, b);
1483    setme->high = MAX (a, b);
1484
1485    errno = error;
1486    return success;
1487}
1488
1489int
1490compareInt (const void * va, const void * vb)
1491{
1492    const int a = * (const int *)va;
1493    const int b = * (const int *)vb;
1494    return a - b;
1495}
1496
1497/**
1498 * Given a string like "1-4" or "1-4,6,9,14-51", this allocates and returns an
1499 * array of setmeCount ints of all the values in the array.
1500 * For example, "5-8" will return [ 5, 6, 7, 8 ] and setmeCount will be 4.
1501 * It's the caller's responsibility to call tr_free () on the returned array.
1502 * If a fragment of the string can't be parsed, NULL is returned.
1503 */
1504int*
1505tr_parseNumberRange (const char * str_in, int len, int * setmeCount)
1506{
1507    int n = 0;
1508    int * uniq = NULL;
1509    char * str = tr_strndup (str_in, len);
1510    const char * walk;
1511    tr_list * ranges = NULL;
1512    bool success = true;
1513
1514    walk = str;
1515    while (walk && *walk && success) {
1516        struct number_range range;
1517        const char * pch = strchr (walk, ',');
1518        if (pch) {
1519            success = parseNumberSection (walk, pch-walk, &range);
1520            walk = pch + 1;
1521        } else {
1522            success = parseNumberSection (walk, strlen (walk), &range);
1523            walk += strlen (walk);
1524        }
1525        if (success)
1526            tr_list_append (&ranges, tr_memdup (&range, sizeof (struct number_range)));
1527    }
1528
1529    if (!success)
1530    {
1531        *setmeCount = 0;
1532        uniq = NULL;
1533    }
1534    else
1535    {
1536        int i;
1537        int n2;
1538        tr_list * l;
1539        int * sorted = NULL;
1540
1541        /* build a sorted number array */
1542        n = n2 = 0;
1543        for (l=ranges; l!=NULL; l=l->next) {
1544            const struct number_range * r = l->data;
1545            n += r->high + 1 - r->low;
1546        }
1547        sorted = tr_new (int, n);
1548        for (l=ranges; l!=NULL; l=l->next) {
1549            const struct number_range * r = l->data;
1550            int i;
1551            for (i=r->low; i<=r->high; ++i)
1552                sorted[n2++] = i;
1553        }
1554        qsort (sorted, n, sizeof (int), compareInt);
1555        assert (n == n2);
1556
1557        /* remove duplicates */
1558        uniq = tr_new (int, n);
1559        for (i=n=0; i<n2; ++i)
1560            if (!n || uniq[n-1] != sorted[i])
1561                uniq[n++] = sorted[i];
1562
1563        tr_free (sorted);
1564    }
1565
1566    /* cleanup */
1567    tr_list_free (&ranges, tr_free);
1568    tr_free (str);
1569
1570    /* return the result */
1571    *setmeCount = n;
1572    return uniq;
1573}
1574
1575/***
1576****
1577***/
1578
1579double
1580tr_truncd (double x, int precision)
1581{
1582    char * pt;
1583    char buf[128];
1584    const int max_precision = (int) log10 (1.0 / DBL_EPSILON) - 1;
1585    tr_snprintf (buf, sizeof (buf), "%.*f", max_precision, x);
1586    if ((pt = strstr (buf, localeconv ()->decimal_point)))
1587        pt[precision ? precision+1 : 0] = '\0';
1588    return atof (buf);
1589}
1590
1591/* return a truncated double as a string */
1592static char*
1593tr_strtruncd (char * buf, double x, int precision, size_t buflen)
1594{
1595    tr_snprintf (buf, buflen, "%.*f", precision, tr_truncd (x, precision));
1596    return buf;
1597}
1598
1599char*
1600tr_strpercent (char * buf, double x, size_t buflen)
1601{
1602    if (x < 10.0)
1603        tr_strtruncd (buf, x, 2, buflen);
1604    else if (x < 100.0)
1605        tr_strtruncd (buf, x, 1, buflen);
1606    else
1607        tr_strtruncd (buf, x, 0, buflen);
1608    return buf;
1609}
1610
1611char*
1612tr_strratio (char * buf, size_t buflen, double ratio, const char * infinity)
1613{
1614    if ((int)ratio == TR_RATIO_NA)
1615        tr_strlcpy (buf, _("None"), buflen);
1616    else if ((int)ratio == TR_RATIO_INF)
1617        tr_strlcpy (buf, infinity, buflen);
1618    else
1619        tr_strpercent (buf, ratio, buflen);
1620    return buf;
1621}
1622
1623/***
1624****
1625***/
1626
1627int
1628tr_moveFile (const char * oldpath, const char * newpath, bool * renamed)
1629{
1630    int in;
1631    int out;
1632    char * buf;
1633    struct stat st;
1634    off_t bytesLeft;
1635    const size_t buflen = 1024 * 128; /* 128 KiB buffer */
1636
1637    /* make sure the old file exists */
1638    if (stat (oldpath, &st)) {
1639        const int err = errno;
1640        errno = err;
1641        return -1;
1642    }
1643    if (!S_ISREG (st.st_mode)) {
1644        errno = ENOENT;
1645        return -1;
1646    }
1647    bytesLeft = st.st_size;
1648
1649    /* make sure the target directory exists */
1650    {
1651        char * newdir = tr_dirname (newpath);
1652        int i = tr_mkdirp (newdir, 0777);
1653        tr_free (newdir);
1654        if (i)
1655            return i;
1656    }
1657
1658    /* they might be on the same filesystem... */
1659    {
1660        const int i = rename (oldpath, newpath);
1661        if (renamed != NULL)
1662            *renamed = i == 0;
1663        if (!i)
1664            return 0;
1665    }
1666
1667    /* copy the file */
1668    in = tr_open_file_for_scanning (oldpath);
1669    out = tr_open_file_for_writing (newpath);
1670    buf = tr_valloc (buflen);
1671    while (bytesLeft > 0)
1672    {
1673        ssize_t bytesWritten;
1674        const off_t bytesThisPass = MIN (bytesLeft, (off_t)buflen);
1675        const int numRead = read (in, buf, bytesThisPass);
1676        if (numRead < 0)
1677            break;
1678        bytesWritten = write (out, buf, numRead);
1679        if (bytesWritten < 0)
1680            break;
1681        bytesLeft -= bytesWritten;
1682    }
1683
1684    /* cleanup */
1685    tr_free (buf);
1686    tr_close_file (out);
1687    tr_close_file (in);
1688    if (bytesLeft != 0)
1689        return -1;
1690
1691    unlink (oldpath);
1692    return 0;
1693}
1694
1695bool
1696tr_is_same_file (const char * filename1, const char * filename2)
1697{
1698    struct stat sb1, sb2;
1699
1700    return !stat (filename1, &sb1)
1701        && !stat (filename2, &sb2)
1702        && (sb1.st_dev == sb2.st_dev)
1703        && (sb1.st_ino == sb2.st_ino);
1704}
1705
1706/***
1707****
1708***/
1709
1710void*
1711tr_valloc (size_t bufLen)
1712{
1713    size_t allocLen;
1714    void * buf = NULL;
1715    static size_t pageSize = 0;
1716
1717    if (!pageSize) {
1718#ifdef HAVE_GETPAGESIZE
1719        pageSize = (size_t) getpagesize ();
1720#else /* guess */
1721        pageSize = 4096;
1722#endif
1723    }
1724
1725    allocLen = pageSize;
1726    while (allocLen < bufLen)
1727        allocLen += pageSize;
1728
1729#ifdef HAVE_POSIX_MEMALIGN
1730    if (!buf)
1731        if (posix_memalign (&buf, pageSize, allocLen))
1732            buf = NULL; /* just retry with valloc/malloc */
1733#endif
1734#ifdef HAVE_VALLOC
1735    if (!buf)
1736        buf = valloc (allocLen);
1737#endif
1738    if (!buf)
1739        buf = tr_malloc (allocLen);
1740
1741    return buf;
1742}
1743
1744char *
1745tr_realpath (const char * path, char * resolved_path)
1746{
1747#ifdef WIN32
1748    /* From a message to the Mingw-msys list, Jun 2, 2005 by Mark Junker. */
1749    if (GetFullPathNameA (path, TR_PATH_MAX, resolved_path, NULL) == 0)
1750        return NULL;
1751    return resolved_path;
1752#else
1753    return realpath (path, resolved_path);
1754#endif
1755}
1756
1757/***
1758****
1759***/
1760
1761uint64_t
1762tr_htonll (uint64_t x)
1763{
1764#ifdef HAVE_HTONLL
1765    return htonll (x);
1766#else
1767    /* fallback code by bdonlan at
1768     * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
1769    union { uint32_t lx[2]; uint64_t llx; } u;
1770    u.lx[0] = htonl (x >> 32);
1771    u.lx[1] = htonl (x & 0xFFFFFFFFULL);
1772    return u.llx;
1773#endif
1774}
1775
1776uint64_t
1777tr_ntohll (uint64_t x)
1778{
1779#ifdef HAVE_NTOHLL
1780    return ntohll (x);
1781#else
1782    /* fallback code by bdonlan at
1783     * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
1784    union { uint32_t lx[2]; uint64_t llx; } u;
1785    u.llx = x;
1786    return ((uint64_t)ntohl (u.lx[0]) << 32) | (uint64_t)ntohl (u.lx[1]);
1787#endif
1788}
1789
1790/***
1791****
1792****
1793****
1794***/
1795
1796struct formatter_unit
1797{
1798    char * name;
1799    int64_t value;
1800};
1801
1802struct formatter_units
1803{
1804    struct formatter_unit units[4];
1805};
1806
1807enum { TR_FMT_KB, TR_FMT_MB, TR_FMT_GB, TR_FMT_TB };
1808
1809static void
1810formatter_init (struct formatter_units * units,
1811                unsigned int kilo,
1812                const char * kb, const char * mb,
1813                const char * gb, const char * tb)
1814{
1815    uint64_t value = kilo;
1816    units->units[TR_FMT_KB].name = tr_strdup (kb);
1817    units->units[TR_FMT_KB].value = value;
1818
1819    value *= kilo;
1820    units->units[TR_FMT_MB].name = tr_strdup (mb);
1821    units->units[TR_FMT_MB].value = value;
1822
1823    value *= kilo;
1824    units->units[TR_FMT_GB].name = tr_strdup (gb);
1825    units->units[TR_FMT_GB].value = value;
1826
1827    value *= kilo;
1828    units->units[TR_FMT_TB].name = tr_strdup (tb);
1829    units->units[TR_FMT_TB].value = value;
1830}
1831
1832static char*
1833formatter_get_size_str (const struct formatter_units * u,
1834                        char * buf, int64_t bytes, size_t buflen)
1835{
1836    int precision;
1837    double value;
1838    const char * units;
1839    const struct formatter_unit * unit;
1840
1841         if (bytes < u->units[1].value) unit = &u->units[0];
1842    else if (bytes < u->units[2].value) unit = &u->units[1];
1843    else if (bytes < u->units[3].value) unit = &u->units[2];
1844    else                                 unit = &u->units[3];
1845
1846    value = (double)bytes / unit->value;
1847    units = unit->name;
1848    if (unit->value == 1)
1849        precision = 0;
1850    else if (value < 100)
1851        precision = 2;
1852    else
1853        precision = 1;
1854    tr_snprintf (buf, buflen, "%.*f %s", precision, value, units);
1855    return buf;
1856}
1857
1858static struct formatter_units size_units;
1859
1860void
1861tr_formatter_size_init (unsigned int kilo,
1862                        const char * kb, const char * mb,
1863                        const char * gb, const char * tb)
1864{
1865    formatter_init (&size_units, kilo, kb, mb, gb, tb);
1866}
1867
1868char*
1869tr_formatter_size_B (char * buf, int64_t bytes, size_t buflen)
1870{
1871    return formatter_get_size_str (&size_units, buf, bytes, buflen);
1872}
1873
1874static struct formatter_units speed_units;
1875
1876unsigned int tr_speed_K = 0u;
1877
1878void
1879tr_formatter_speed_init (unsigned int kilo,
1880                         const char * kb, const char * mb,
1881                         const char * gb, const char * tb)
1882{
1883    tr_speed_K = kilo;
1884    formatter_init (&speed_units, kilo, kb, mb, gb, tb);
1885}
1886
1887char*
1888tr_formatter_speed_KBps (char * buf, double KBps, size_t buflen)
1889{
1890    const double K = speed_units.units[TR_FMT_KB].value;
1891    double speed = KBps;
1892
1893    if (speed <= 999.95) /* 0.0 KB to 999.9 KB */
1894        tr_snprintf (buf, buflen, "%d %s", (int)speed, speed_units.units[TR_FMT_KB].name);
1895    else {
1896        speed /= K;
1897        if (speed <= 99.995) /* 0.98 MB to 99.99 MB */
1898            tr_snprintf (buf, buflen, "%.2f %s", speed, speed_units.units[TR_FMT_MB].name);
1899        else if (speed <= 999.95) /* 100.0 MB to 999.9 MB */
1900            tr_snprintf (buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_MB].name);
1901        else {
1902            speed /= K;
1903            tr_snprintf (buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_GB].name);
1904        }
1905    }
1906
1907    return buf;
1908}
1909
1910static struct formatter_units mem_units;
1911
1912unsigned int tr_mem_K = 0u;
1913
1914void
1915tr_formatter_mem_init (unsigned int kilo,
1916                       const char * kb, const char * mb,
1917                       const char * gb, const char * tb)
1918{
1919    tr_mem_K = kilo;
1920    formatter_init (&mem_units, kilo, kb, mb, gb, tb);
1921}
1922
1923char*
1924tr_formatter_mem_B (char * buf, int64_t bytes_per_second, size_t buflen)
1925{
1926    return formatter_get_size_str (&mem_units, buf, bytes_per_second, buflen);
1927}
1928
1929void
1930tr_formatter_get_units (void * vdict)
1931{
1932  int i;
1933  tr_variant * l;
1934  tr_variant * dict = vdict;
1935
1936  tr_variantDictReserve (dict, 6);
1937
1938  tr_variantDictAddInt (dict, TR_KEY_memory_bytes, mem_units.units[TR_FMT_KB].value);
1939  l = tr_variantDictAddList (dict, TR_KEY_memory_units, 4);
1940  for (i=0; i<4; i++)
1941    tr_variantListAddStr (l, mem_units.units[i].name);
1942
1943  tr_variantDictAddInt (dict, TR_KEY_size_bytes,   size_units.units[TR_FMT_KB].value);
1944  l = tr_variantDictAddList (dict, TR_KEY_size_units, 4);
1945  for (i=0; i<4; i++)
1946    tr_variantListAddStr (l, size_units.units[i].name);
1947
1948  tr_variantDictAddInt (dict, TR_KEY_speed_bytes,  speed_units.units[TR_FMT_KB].value);
1949  l = tr_variantDictAddList (dict, TR_KEY_speed_units, 4);
1950  for (i=0; i<4; i++)
1951    tr_variantListAddStr (l, speed_units.units[i].name);
1952}
1953
Note: See TracBrowser for help on using the repository browser.