source: trunk/libtransmission/utils.c @ 13683

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

(trunk, libT) first drop of the tr_quark patch.

  • Property svn:keywords set to Date Rev Author Id
File size: 40.5 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 13683 2012-12-22 20:35:19Z 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
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
1517/***
1518****
1519***/
1520
1521int
1522tr_moveFile (const char * oldpath, const char * newpath, bool * renamed)
1523{
1524    int in;
1525    int out;
1526    char * buf;
1527    struct stat st;
1528    off_t bytesLeft;
1529    const size_t buflen = 1024 * 128; /* 128 KiB buffer */
1530
1531    /* make sure the old file exists */
1532    if (stat (oldpath, &st)) {
1533        const int err = errno;
1534        errno = err;
1535        return -1;
1536    }
1537    if (!S_ISREG (st.st_mode)) {
1538        errno = ENOENT;
1539        return -1;
1540    }
1541    bytesLeft = st.st_size;
1542
1543    /* make sure the target directory exists */
1544    {
1545        char * newdir = tr_dirname (newpath);
1546        int i = tr_mkdirp (newdir, 0777);
1547        tr_free (newdir);
1548        if (i)
1549            return i;
1550    }
1551
1552    /* they might be on the same filesystem... */
1553    {
1554        const int i = rename (oldpath, newpath);
1555        if (renamed != NULL)
1556            *renamed = i == 0;
1557        if (!i)
1558            return 0;
1559    }
1560
1561    /* copy the file */
1562    in = tr_open_file_for_scanning (oldpath);
1563    out = tr_open_file_for_writing (newpath);
1564    buf = tr_valloc (buflen);
1565    while (bytesLeft > 0)
1566    {
1567        ssize_t bytesWritten;
1568        const off_t bytesThisPass = MIN (bytesLeft, (off_t)buflen);
1569        const int numRead = read (in, buf, bytesThisPass);
1570        if (numRead < 0)
1571            break;
1572        bytesWritten = write (out, buf, numRead);
1573        if (bytesWritten < 0)
1574            break;
1575        bytesLeft -= bytesWritten;
1576    }
1577
1578    /* cleanup */
1579    tr_free (buf);
1580    tr_close_file (out);
1581    tr_close_file (in);
1582    if (bytesLeft != 0)
1583        return -1;
1584
1585    unlink (oldpath);
1586    return 0;
1587}
1588
1589bool
1590tr_is_same_file (const char * filename1, const char * filename2)
1591{
1592    struct stat sb1, sb2;
1593
1594    return !stat (filename1, &sb1)
1595        && !stat (filename2, &sb2)
1596        && (sb1.st_dev == sb2.st_dev)
1597        && (sb1.st_ino == sb2.st_ino);
1598}
1599
1600/***
1601****
1602***/
1603
1604void*
1605tr_valloc (size_t bufLen)
1606{
1607    size_t allocLen;
1608    void * buf = NULL;
1609    static size_t pageSize = 0;
1610
1611    if (!pageSize) {
1612#ifdef HAVE_GETPAGESIZE
1613        pageSize = (size_t) getpagesize ();
1614#else /* guess */
1615        pageSize = 4096;
1616#endif
1617    }
1618
1619    allocLen = pageSize;
1620    while (allocLen < bufLen)
1621        allocLen += pageSize;
1622
1623#ifdef HAVE_POSIX_MEMALIGN
1624    if (!buf)
1625        if (posix_memalign (&buf, pageSize, allocLen))
1626            buf = NULL; /* just retry with valloc/malloc */
1627#endif
1628#ifdef HAVE_VALLOC
1629    if (!buf)
1630        buf = valloc (allocLen);
1631#endif
1632    if (!buf)
1633        buf = tr_malloc (allocLen);
1634
1635    return buf;
1636}
1637
1638char *
1639tr_realpath (const char * path, char * resolved_path)
1640{
1641#ifdef WIN32
1642    /* From a message to the Mingw-msys list, Jun 2, 2005 by Mark Junker. */
1643    if (GetFullPathNameA (path, TR_PATH_MAX, resolved_path, NULL) == 0)
1644        return NULL;
1645    return resolved_path;
1646#else
1647    return realpath (path, resolved_path);
1648#endif
1649}
1650
1651/***
1652****
1653***/
1654
1655uint64_t
1656tr_htonll (uint64_t x)
1657{
1658#ifdef HAVE_HTONLL
1659    return htonll (x);
1660#else
1661    /* fallback code by bdonlan at
1662     * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
1663    union { uint32_t lx[2]; uint64_t llx; } u;
1664    u.lx[0] = htonl (x >> 32);
1665    u.lx[1] = htonl (x & 0xFFFFFFFFULL);
1666    return u.llx;
1667#endif
1668}
1669
1670uint64_t
1671tr_ntohll (uint64_t x)
1672{
1673#ifdef HAVE_NTOHLL
1674    return ntohll (x);
1675#else
1676    /* fallback code by bdonlan at
1677     * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
1678    union { uint32_t lx[2]; uint64_t llx; } u;
1679    u.llx = x;
1680    return ((uint64_t)ntohl (u.lx[0]) << 32) | (uint64_t)ntohl (u.lx[1]);
1681#endif
1682}
1683
1684/***
1685****
1686****
1687****
1688***/
1689
1690struct formatter_unit
1691{
1692    char * name;
1693    int64_t value;
1694};
1695
1696struct formatter_units
1697{
1698    struct formatter_unit units[4];
1699};
1700
1701enum { TR_FMT_KB, TR_FMT_MB, TR_FMT_GB, TR_FMT_TB };
1702
1703static void
1704formatter_init (struct formatter_units * units,
1705                unsigned int kilo,
1706                const char * kb, const char * mb,
1707                const char * gb, const char * tb)
1708{
1709    uint64_t value = kilo;
1710    units->units[TR_FMT_KB].name = tr_strdup (kb);
1711    units->units[TR_FMT_KB].value = value;
1712
1713    value *= kilo;
1714    units->units[TR_FMT_MB].name = tr_strdup (mb);
1715    units->units[TR_FMT_MB].value = value;
1716
1717    value *= kilo;
1718    units->units[TR_FMT_GB].name = tr_strdup (gb);
1719    units->units[TR_FMT_GB].value = value;
1720
1721    value *= kilo;
1722    units->units[TR_FMT_TB].name = tr_strdup (tb);
1723    units->units[TR_FMT_TB].value = value;
1724}
1725
1726static char*
1727formatter_get_size_str (const struct formatter_units * u,
1728                        char * buf, int64_t bytes, size_t buflen)
1729{
1730    int precision;
1731    double value;
1732    const char * units;
1733    const struct formatter_unit * unit;
1734
1735         if (bytes < u->units[1].value) unit = &u->units[0];
1736    else if (bytes < u->units[2].value) unit = &u->units[1];
1737    else if (bytes < u->units[3].value) unit = &u->units[2];
1738    else                                 unit = &u->units[3];
1739
1740    value = (double)bytes / unit->value;
1741    units = unit->name;
1742    if (unit->value == 1)
1743        precision = 0;
1744    else if (value < 100)
1745        precision = 2;
1746    else
1747        precision = 1;
1748    tr_snprintf (buf, buflen, "%.*f %s", precision, value, units);
1749    return buf;
1750}
1751
1752static struct formatter_units size_units;
1753
1754void
1755tr_formatter_size_init (unsigned int kilo,
1756                        const char * kb, const char * mb,
1757                        const char * gb, const char * tb)
1758{
1759    formatter_init (&size_units, kilo, kb, mb, gb, tb);
1760}
1761
1762char*
1763tr_formatter_size_B (char * buf, int64_t bytes, size_t buflen)
1764{
1765    return formatter_get_size_str (&size_units, buf, bytes, buflen);
1766}
1767
1768static struct formatter_units speed_units;
1769
1770unsigned int tr_speed_K = 0u;
1771
1772void
1773tr_formatter_speed_init (unsigned int kilo,
1774                         const char * kb, const char * mb,
1775                         const char * gb, const char * tb)
1776{
1777    tr_speed_K = kilo;
1778    formatter_init (&speed_units, kilo, kb, mb, gb, tb);
1779}
1780
1781char*
1782tr_formatter_speed_KBps (char * buf, double KBps, size_t buflen)
1783{
1784    const double K = speed_units.units[TR_FMT_KB].value;
1785    double speed = KBps;
1786
1787    if (speed <= 999.95) /* 0.0 KB to 999.9 KB */
1788        tr_snprintf (buf, buflen, "%d %s", (int)speed, speed_units.units[TR_FMT_KB].name);
1789    else {
1790        speed /= K;
1791        if (speed <= 99.995) /* 0.98 MB to 99.99 MB */
1792            tr_snprintf (buf, buflen, "%.2f %s", speed, speed_units.units[TR_FMT_MB].name);
1793        else if (speed <= 999.95) /* 100.0 MB to 999.9 MB */
1794            tr_snprintf (buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_MB].name);
1795        else {
1796            speed /= K;
1797            tr_snprintf (buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_GB].name);
1798        }
1799    }
1800
1801    return buf;
1802}
1803
1804static struct formatter_units mem_units;
1805
1806unsigned int tr_mem_K = 0u;
1807
1808void
1809tr_formatter_mem_init (unsigned int kilo,
1810                       const char * kb, const char * mb,
1811                       const char * gb, const char * tb)
1812{
1813    tr_mem_K = kilo;
1814    formatter_init (&mem_units, kilo, kb, mb, gb, tb);
1815}
1816
1817char*
1818tr_formatter_mem_B (char * buf, int64_t bytes_per_second, size_t buflen)
1819{
1820    return formatter_get_size_str (&mem_units, buf, bytes_per_second, buflen);
1821}
1822
1823void
1824tr_formatter_get_units (void * vdict)
1825{
1826  int i;
1827  tr_variant * l;
1828  tr_variant * dict = vdict;
1829
1830  tr_variantDictReserve (dict, 6);
1831
1832  tr_variantDictAddInt (dict, TR_KEY_memory_bytes, mem_units.units[TR_FMT_KB].value);
1833  l = tr_variantDictAddList (dict, TR_KEY_memory_units, 4);
1834  for (i=0; i<4; i++)
1835    tr_variantListAddStr (l, mem_units.units[i].name);
1836
1837  tr_variantDictAddInt (dict, TR_KEY_size_bytes,   size_units.units[TR_FMT_KB].value);
1838  l = tr_variantDictAddList (dict, TR_KEY_size_units, 4);
1839  for (i=0; i<4; i++)
1840    tr_variantListAddStr (l, size_units.units[i].name);
1841
1842  tr_variantDictAddInt (dict, TR_KEY_speed_bytes,  speed_units.units[TR_FMT_KB].value);
1843  l = tr_variantDictAddList (dict, TR_KEY_speed_units, 4);
1844  for (i=0; i<4; i++)
1845    tr_variantListAddStr (l, speed_units.units[i].name);
1846}
1847
Note: See TracBrowser for help on using the repository browser.