source: trunk/libtransmission/bencode.c @ 10816

Last change on this file since 10816 was 10816, checked in by charles, 12 years ago

(trunk) more win32 fixes from rb07 in #3311

  • Property svn:keywords set to Date Rev Author Id
File size: 43.3 KB
Line 
1/*
2 * This file Copyright (C) 2008-2010 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: bencode.c 10816 2010-06-22 00:12:52Z charles $
11 */
12
13#include <assert.h>
14#include <ctype.h> /* isdigit() */
15#include <errno.h>
16#include <math.h> /* fabs() */
17#include <stdio.h>
18#include <stdlib.h> /* realpath() */
19#include <string.h>
20
21#ifdef WIN32 /* tr_mkstemp() */
22 #include <fcntl.h>
23 #define _S_IREAD 256
24 #define _S_IWRITE 128
25#endif
26
27#include <sys/types.h> /* stat() */
28#include <sys/stat.h> /* stat() */
29#include <locale.h>
30#include <unistd.h> /* stat(), close() */
31
32#include <event.h> /* struct evbuffer */
33
34#include "ConvertUTF.h"
35
36#include "transmission.h"
37#include "bencode.h"
38#include "json.h"
39#include "list.h"
40#include "platform.h" /* TR_PATH_MAX */
41#include "ptrarray.h"
42#include "utils.h" /* tr_new(), tr_free() */
43
44#ifndef ENODATA
45 #define ENODATA EIO
46#endif
47
48/**
49***
50**/
51
52static tr_bool
53isContainer( const tr_benc * val )
54{
55    return tr_bencIsList( val ) || tr_bencIsDict( val );
56}
57
58static tr_bool
59isSomething( const tr_benc * val )
60{
61    return isContainer( val ) || tr_bencIsInt( val )
62                              || tr_bencIsString( val )
63                              || tr_bencIsReal( val )
64                              || tr_bencIsBool( val );
65}
66
67static void
68tr_bencInit( tr_benc * val,
69             int       type )
70{
71    memset( val, 0, sizeof( *val ) );
72    val->type = type;
73}
74
75/***
76****  tr_bencParse()
77****  tr_bencLoad()
78***/
79
80/**
81 * The initial i and trailing e are beginning and ending delimiters.
82 * You can have negative numbers such as i-3e. You cannot prefix the
83 * number with a zero such as i04e. However, i0e is valid.
84 * Example: i3e represents the integer "3"
85 * NOTE: The maximum number of bit of this integer is unspecified,
86 * but to handle it as a signed 64bit integer is mandatory to handle
87 * "large files" aka .torrent for more that 4Gbyte
88 */
89int
90tr_bencParseInt( const uint8_t *  buf,
91                 const uint8_t *  bufend,
92                 const uint8_t ** setme_end,
93                 int64_t *        setme_val )
94{
95    char *       endptr;
96    const void * begin;
97    const void * end;
98    int64_t      val;
99
100    if( buf >= bufend )
101        return EILSEQ;
102    if( *buf != 'i' )
103        return EILSEQ;
104
105    begin = buf + 1;
106    end = memchr( begin, 'e', ( bufend - buf ) - 1 );
107    if( end == NULL )
108        return EILSEQ;
109
110    errno = 0;
111    val = evutil_strtoll( begin, &endptr, 10 );
112    if( errno || ( endptr != end ) ) /* incomplete parse */
113        return EILSEQ;
114    if( val && *(const char*)begin == '0' ) /* no leading zeroes! */
115        return EILSEQ;
116
117    *setme_end = (const uint8_t*)end + 1;
118    *setme_val = val;
119    return 0;
120}
121
122/**
123 * Byte strings are encoded as follows:
124 * <string length encoded in base ten ASCII>:<string data>
125 * Note that there is no constant beginning delimiter, and no ending delimiter.
126 * Example: 4:spam represents the string "spam"
127 */
128int
129tr_bencParseStr( const uint8_t *  buf,
130                 const uint8_t *  bufend,
131                 const uint8_t ** setme_end,
132                 const uint8_t ** setme_str,
133                 size_t *         setme_strlen )
134{
135    size_t       len;
136    const void * end;
137    char *       endptr;
138
139    if( buf >= bufend )
140        return EILSEQ;
141
142    if( !isdigit( *buf  ) )
143        return EILSEQ;
144
145    end = memchr( buf, ':', bufend - buf );
146    if( end == NULL )
147        return EILSEQ;
148
149    errno = 0;
150    len = strtoul( (const char*)buf, &endptr, 10 );
151    if( errno || endptr != end )
152        return EILSEQ;
153
154    if( (const uint8_t*)end + 1 + len > bufend )
155        return EILSEQ;
156
157    *setme_end = (const uint8_t*)end + 1 + len;
158    *setme_str = (const uint8_t*)end + 1;
159    *setme_strlen = len;
160    return 0;
161}
162
163/* set to 1 to help expose bugs with tr_bencListAdd and tr_bencDictAdd */
164#define LIST_SIZE 4 /* number of items to increment list/dict buffer by */
165
166static int
167makeroom( tr_benc * val,
168          size_t    count )
169{
170    assert( TR_TYPE_LIST == val->type || TR_TYPE_DICT == val->type );
171
172    if( val->val.l.count + count > val->val.l.alloc )
173    {
174        /* We need a bigger boat */
175        const int len = val->val.l.alloc + count +
176                        ( count % LIST_SIZE ? LIST_SIZE -
177                          ( count % LIST_SIZE ) : 0 );
178        void * tmp = realloc( val->val.l.vals, len * sizeof( tr_benc ) );
179        if( !tmp )
180            return 1;
181
182        val->val.l.alloc = len;
183        val->val.l.vals  = tmp;
184    }
185
186    return 0;
187}
188
189static tr_benc*
190getNode( tr_benc *     top,
191         tr_ptrArray * parentStack,
192         int           type )
193{
194    tr_benc * parent;
195
196    assert( top );
197    assert( parentStack );
198
199    if( tr_ptrArrayEmpty( parentStack ) )
200        return top;
201
202    parent = tr_ptrArrayBack( parentStack );
203    assert( parent );
204
205    /* dictionary keys must be strings */
206    if( ( parent->type == TR_TYPE_DICT )
207      && ( type != TR_TYPE_STR )
208      && ( !( parent->val.l.count % 2 ) ) )
209        return NULL;
210
211    makeroom( parent, 1 );
212    return parent->val.l.vals + parent->val.l.count++;
213}
214
215/**
216 * This function's previous recursive implementation was
217 * easier to read, but was vulnerable to a smash-stacking
218 * attack via maliciously-crafted bencoded data. (#667)
219 */
220static int
221tr_bencParseImpl( const void *     buf_in,
222                  const void *     bufend_in,
223                  tr_benc *        top,
224                  tr_ptrArray *    parentStack,
225                  const uint8_t ** setme_end )
226{
227    int             err;
228    const uint8_t * buf = buf_in;
229    const uint8_t * bufend = bufend_in;
230
231    tr_bencInit( top, 0 );
232
233    while( buf != bufend )
234    {
235        if( buf > bufend ) /* no more text to parse... */
236            return 1;
237
238        if( *buf == 'i' ) /* int */
239        {
240            int64_t         val;
241            const uint8_t * end;
242            tr_benc *       node;
243
244            if( ( err = tr_bencParseInt( buf, bufend, &end, &val ) ) )
245                return err;
246
247            node = getNode( top, parentStack, TR_TYPE_INT );
248            if( !node )
249                return EILSEQ;
250
251            tr_bencInitInt( node, val );
252            buf = end;
253
254            if( tr_ptrArrayEmpty( parentStack ) )
255                break;
256        }
257        else if( *buf == 'l' ) /* list */
258        {
259            tr_benc * node = getNode( top, parentStack, TR_TYPE_LIST );
260            if( !node )
261                return EILSEQ;
262            tr_bencInit( node, TR_TYPE_LIST );
263            tr_ptrArrayAppend( parentStack, node );
264            ++buf;
265        }
266        else if( *buf == 'd' ) /* dict */
267        {
268            tr_benc * node = getNode( top, parentStack, TR_TYPE_DICT );
269            if( !node )
270                return EILSEQ;
271            tr_bencInit( node, TR_TYPE_DICT );
272            tr_ptrArrayAppend( parentStack, node );
273            ++buf;
274        }
275        else if( *buf == 'e' ) /* end of list or dict */
276        {
277            tr_benc * node;
278            ++buf;
279            if( tr_ptrArrayEmpty( parentStack ) )
280                return EILSEQ;
281
282            node = tr_ptrArrayBack( parentStack );
283            if( tr_bencIsDict( node ) && ( node->val.l.count % 2 ) )
284            {
285                /* odd # of children in dict */
286                tr_bencFree( &node->val.l.vals[--node->val.l.count] );
287                return EILSEQ;
288            }
289
290            tr_ptrArrayPop( parentStack );
291            if( tr_ptrArrayEmpty( parentStack ) )
292                break;
293        }
294        else if( isdigit( *buf ) ) /* string? */
295        {
296            const uint8_t * end;
297            const uint8_t * str;
298            size_t          str_len;
299            tr_benc *       node;
300
301            if( ( err = tr_bencParseStr( buf, bufend, &end, &str, &str_len ) ) )
302                return err;
303
304            node = getNode( top, parentStack, TR_TYPE_STR );
305            if( !node )
306                return EILSEQ;
307
308            tr_bencInitStr( node, str, str_len );
309            buf = end;
310
311            if( tr_ptrArrayEmpty( parentStack ) )
312                break;
313        }
314        else /* invalid bencoded text... march past it */
315        {
316            ++buf;
317        }
318    }
319
320    err = !isSomething( top ) || !tr_ptrArrayEmpty( parentStack );
321
322    if( !err && setme_end )
323        *setme_end = buf;
324
325    return err;
326}
327
328int
329tr_bencParse( const void *     buf,
330              const void *     end,
331              tr_benc *        top,
332              const uint8_t ** setme_end )
333{
334    int           err;
335    tr_ptrArray   parentStack = TR_PTR_ARRAY_INIT;
336
337    top->type = 0; /* set to `uninitialized' */
338    err = tr_bencParseImpl( buf, end, top, &parentStack, setme_end );
339    if( err )
340        tr_bencFree( top );
341
342    tr_ptrArrayDestruct( &parentStack, NULL );
343    return err;
344}
345
346int
347tr_bencLoad( const void * buf_in,
348             size_t       buflen,
349             tr_benc *    setme_benc,
350             char **      setme_end )
351{
352    const uint8_t * buf = buf_in;
353    const uint8_t * end;
354    const int       ret = tr_bencParse( buf, buf + buflen, setme_benc, &end );
355
356    if( !ret && setme_end )
357        *setme_end = (char*) end;
358    return ret;
359}
360
361/***
362****
363***/
364
365/* returns true if the benc's string was malloced.
366 * this occurs when the string is too long for our string buffer */
367static inline int
368stringIsAlloced( const tr_benc * val )
369{
370    return val->val.s.len >= sizeof( val->val.s.str.buf );
371}
372
373/* returns a const pointer to the benc's string */
374static inline const char*
375getStr( const tr_benc* val )
376{
377    return stringIsAlloced(val) ? val->val.s.str.ptr : val->val.s.str.buf;
378}
379
380static int
381dictIndexOf( const tr_benc * val, const char * key )
382{
383    if( tr_bencIsDict( val ) )
384    {
385        size_t       i;
386        const size_t len = strlen( key );
387
388        for( i = 0; ( i + 1 ) < val->val.l.count; i += 2 )
389        {
390            const tr_benc * child = val->val.l.vals + i;
391            if( ( child->type == TR_TYPE_STR )
392              && ( child->val.s.len == len )
393              && !memcmp( getStr(child), key, len ) )
394                return i;
395        }
396    }
397
398    return -1;
399}
400
401tr_benc *
402tr_bencDictFind( tr_benc * val, const char * key )
403{
404    const int i = dictIndexOf( val, key );
405
406    return i < 0 ? NULL : &val->val.l.vals[i + 1];
407}
408
409static tr_bool
410tr_bencDictFindType( tr_benc * dict, const char * key, int type, tr_benc ** setme )
411{
412    return tr_bencIsType( *setme = tr_bencDictFind( dict, key ), type );
413}
414
415size_t
416tr_bencListSize( const tr_benc * list )
417{
418    return tr_bencIsList( list ) ? list->val.l.count : 0;
419}
420
421tr_benc*
422tr_bencListChild( tr_benc * val,
423                  size_t    i )
424{
425    tr_benc * ret = NULL;
426
427    if( tr_bencIsList( val ) && ( i < val->val.l.count ) )
428        ret = val->val.l.vals + i;
429    return ret;
430}
431
432int
433tr_bencListRemove( tr_benc * list, size_t i )
434{
435    if( tr_bencIsList( list ) && ( i < list->val.l.count ) )
436    {
437        tr_bencFree( &list->val.l.vals[i] );
438        tr_removeElementFromArray( list->val.l.vals, i, sizeof( tr_benc ), list->val.l.count-- );
439        return 1;
440    }
441
442    return 0;
443}
444
445static void
446tr_benc_warning( const char * err )
447{
448    fprintf( stderr, "warning: %s\n", err );
449}
450
451tr_bool
452tr_bencGetInt( const tr_benc * val,
453               int64_t *       setme )
454{
455    tr_bool success = FALSE;
456
457    if( !success && (( success = tr_bencIsInt( val ))))
458        if( setme )
459            *setme = val->val.i;
460
461    if( !success && (( success = tr_bencIsBool( val )))) {
462        tr_benc_warning( "reading bool as an int" );
463        if( setme )
464            *setme = val->val.b ? 1 : 0;
465    }
466
467    return success;
468}
469
470tr_bool
471tr_bencGetStr( const tr_benc * val,
472               const char **   setme )
473{
474    const int success = tr_bencIsString( val );
475
476    if( success )
477        *setme = getStr( val );
478
479    return success;
480}
481
482tr_bool
483tr_bencGetBool( const tr_benc * val, tr_bool * setme )
484{
485    const char * str;
486    tr_bool success = FALSE;
487
488    if(( success = tr_bencIsBool( val )))
489        *setme = val->val.b;
490
491    if( !success && tr_bencIsInt( val ) )
492        if(( success = ( val->val.i==0 || val->val.i==1 ) ))
493            *setme = val->val.i!=0;
494
495    if( !success && tr_bencGetStr( val, &str ) )
496        if(( success = ( !strcmp(str,"true") || !strcmp(str,"false"))))
497            *setme = !strcmp(str,"true");
498
499    return success;
500}
501
502tr_bool
503tr_bencGetReal( const tr_benc * val, double * setme )
504{
505    tr_bool success = FALSE;
506
507    if( !success && (( success = tr_bencIsReal( val ))))
508        *setme = val->val.d;
509
510    if( !success && (( success = tr_bencIsInt( val ))))
511        *setme = val->val.i;
512
513    if( !success && tr_bencIsString(val) )
514    {
515        char * endptr;
516        char locale[128];
517        double d;
518
519        /* the json spec requires a '.' decimal point regardless of locale */
520        tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
521        setlocale( LC_NUMERIC, "POSIX" );
522        d  = strtod( getStr(val), &endptr );
523        setlocale( LC_NUMERIC, locale );
524
525        if(( success = ( getStr(val) != endptr ) && !*endptr ))
526            *setme = d;
527    }
528
529
530    return success;
531}
532
533tr_bool
534tr_bencDictFindInt( tr_benc * dict, const char * key, int64_t * setme )
535{
536    return tr_bencGetInt( tr_bencDictFind( dict, key ), setme );
537}
538
539tr_bool
540tr_bencDictFindBool( tr_benc * dict, const char * key, tr_bool * setme )
541{
542    return tr_bencGetBool( tr_bencDictFind( dict, key ), setme );
543}
544
545tr_bool
546tr_bencDictFindReal( tr_benc * dict, const char * key, double * setme )
547{
548    return tr_bencGetReal( tr_bencDictFind( dict, key ), setme );
549}
550
551tr_bool
552tr_bencDictFindStr( tr_benc *  dict, const char *  key, const char ** setme )
553{
554    return tr_bencGetStr( tr_bencDictFind( dict, key ), setme );
555}
556
557tr_bool
558tr_bencDictFindList( tr_benc * dict, const char * key, tr_benc ** setme )
559{
560    return tr_bencDictFindType( dict, key, TR_TYPE_LIST, setme );
561}
562
563tr_bool
564tr_bencDictFindDict( tr_benc * dict, const char * key, tr_benc ** setme )
565{
566    return tr_bencDictFindType( dict, key, TR_TYPE_DICT, setme );
567}
568
569tr_bool
570tr_bencDictFindRaw( tr_benc         * dict,
571                    const char      * key,
572                    const uint8_t  ** setme_raw,
573                    size_t          * setme_len )
574{
575    tr_benc * child;
576    const tr_bool found = tr_bencDictFindType( dict, key, TR_TYPE_STR, &child );
577
578    if( found ) {
579        *setme_raw = (uint8_t*) getStr(child);
580        *setme_len = child->val.s.len;
581    }
582
583    return found;
584}
585
586/***
587****
588***/
589
590void
591tr_bencInitRaw( tr_benc * val, const void * src, size_t byteCount )
592{
593    char * setme;
594    tr_bencInit( val, TR_TYPE_STR );
595
596    /* There's no way in benc notation to distinguish between
597     * zero-terminated strings and raw byte arrays.
598     * Because of this, tr_bencMergeDicts() and tr_bencListCopy()
599     * don't know whether or not a TR_TYPE_STR node needs a '\0'.
600     * Append one, een to the raw arrays, just to be safe. */
601
602    if( byteCount < sizeof( val->val.s.str.buf ) )
603        setme = val->val.s.str.buf;
604    else
605        setme = val->val.s.str.ptr = tr_new( char, byteCount + 1 );
606
607    memcpy( setme, src, byteCount );
608    setme[byteCount] = '\0';
609    val->val.s.len = byteCount;
610}
611
612void
613tr_bencInitStr( tr_benc * val, const void * str, int len )
614{
615    if( str == NULL )
616        len = 0;
617    else if( len < 0 )
618        len = strlen( str );
619
620    tr_bencInitRaw( val, str, len );
621}
622
623void
624tr_bencInitBool( tr_benc * b, int value )
625{
626    tr_bencInit( b, TR_TYPE_BOOL );
627    b->val.b = value != 0;
628}
629
630void
631tr_bencInitReal( tr_benc * b, double value )
632{
633    tr_bencInit( b, TR_TYPE_REAL );
634    b->val.d = value;
635}
636
637void
638tr_bencInitInt( tr_benc * b, int64_t value )
639{
640    tr_bencInit( b, TR_TYPE_INT );
641    b->val.i = value;
642}
643
644int
645tr_bencInitList( tr_benc * b, size_t reserveCount )
646{
647    tr_bencInit( b, TR_TYPE_LIST );
648    return tr_bencListReserve( b, reserveCount );
649}
650
651int
652tr_bencListReserve( tr_benc * b, size_t count )
653{
654    assert( tr_bencIsList( b ) );
655    return makeroom( b, count );
656}
657
658int
659tr_bencInitDict( tr_benc * b, size_t reserveCount )
660{
661    tr_bencInit( b, TR_TYPE_DICT );
662    return tr_bencDictReserve( b, reserveCount );
663}
664
665int
666tr_bencDictReserve( tr_benc * b, size_t reserveCount )
667{
668    assert( tr_bencIsDict( b ) );
669    return makeroom( b, reserveCount * 2 );
670}
671
672tr_benc *
673tr_bencListAdd( tr_benc * list )
674{
675    tr_benc * item;
676
677    assert( tr_bencIsList( list ) );
678
679    if( list->val.l.count == list->val.l.alloc )
680        tr_bencListReserve( list, LIST_SIZE );
681
682    assert( list->val.l.count < list->val.l.alloc );
683
684    item = &list->val.l.vals[list->val.l.count];
685    list->val.l.count++;
686    tr_bencInit( item, TR_TYPE_INT );
687
688    return item;
689}
690
691tr_benc *
692tr_bencListAddInt( tr_benc * list, int64_t val )
693{
694    tr_benc * node = tr_bencListAdd( list );
695
696    tr_bencInitInt( node, val );
697    return node;
698}
699
700tr_benc *
701tr_bencListAddReal( tr_benc * list, double val )
702{
703    tr_benc * node = tr_bencListAdd( list );
704    tr_bencInitReal( node, val );
705    return node;
706}
707
708tr_benc *
709tr_bencListAddBool( tr_benc * list, tr_bool val )
710{
711    tr_benc * node = tr_bencListAdd( list );
712    tr_bencInitBool( node, val );
713    return node;
714}
715
716tr_benc *
717tr_bencListAddStr( tr_benc * list, const char * val )
718{
719    tr_benc * node = tr_bencListAdd( list );
720    tr_bencInitStr( node, val, -1 );
721    return node;
722}
723
724tr_benc *
725tr_bencListAddRaw( tr_benc * list, const uint8_t * val, size_t len )
726{
727    tr_benc * node = tr_bencListAdd( list );
728    tr_bencInitRaw( node, val, len );
729    return node;
730}
731
732tr_benc*
733tr_bencListAddList( tr_benc * list,
734                    size_t    reserveCount )
735{
736    tr_benc * child = tr_bencListAdd( list );
737
738    tr_bencInitList( child, reserveCount );
739    return child;
740}
741
742tr_benc*
743tr_bencListAddDict( tr_benc * list,
744                    size_t    reserveCount )
745{
746    tr_benc * child = tr_bencListAdd( list );
747
748    tr_bencInitDict( child, reserveCount );
749    return child;
750}
751
752tr_benc *
753tr_bencDictAdd( tr_benc *    dict,
754                const char * key )
755{
756    tr_benc * keyval, * itemval;
757
758    assert( tr_bencIsDict( dict ) );
759    if( dict->val.l.count + 2 > dict->val.l.alloc )
760        makeroom( dict, 2 );
761    assert( dict->val.l.count + 2 <= dict->val.l.alloc );
762
763    keyval = dict->val.l.vals + dict->val.l.count++;
764    tr_bencInitStr( keyval, key, -1 );
765
766    itemval = dict->val.l.vals + dict->val.l.count++;
767    tr_bencInit( itemval, TR_TYPE_INT );
768
769    return itemval;
770}
771
772static tr_benc*
773dictFindOrAdd( tr_benc * dict, const char * key, int type )
774{
775    tr_benc * child;
776
777    /* see if it already exists, and if so, try to reuse it */
778    if(( child = tr_bencDictFind( dict, key ))) {
779        if( !tr_bencIsType( child, type ) ) {
780            tr_bencDictRemove( dict, key );
781            child = NULL;
782        }
783    }
784
785    /* if it doesn't exist, create it */
786    if( child == NULL )
787        child = tr_bencDictAdd( dict, key );
788
789    return child;
790}
791
792tr_benc*
793tr_bencDictAddInt( tr_benc *    dict,
794                   const char * key,
795                   int64_t      val )
796{
797    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_INT );
798    tr_bencInitInt( child, val );
799    return child;
800}
801
802tr_benc*
803tr_bencDictAddBool( tr_benc * dict, const char * key, tr_bool val )
804{
805    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_BOOL );
806    tr_bencInitBool( child, val );
807    return child;
808}
809
810tr_benc*
811tr_bencDictAddReal( tr_benc * dict, const char * key, double val )
812{
813    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_REAL );
814    tr_bencInitReal( child, val );
815    return child;
816}
817
818tr_benc*
819tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
820{
821    tr_benc * child;
822
823    /* see if it already exists, and if so, try to reuse it */
824    if(( child = tr_bencDictFind( dict, key ))) {
825        if( tr_bencIsString( child ) ) {
826            if( stringIsAlloced( child ) )
827                tr_free( child->val.s.str.ptr );
828        } else {
829            tr_bencDictRemove( dict, key );
830            child = NULL;
831        }
832    }
833
834    /* if it doesn't exist, create it */
835    if( child == NULL )
836        child = tr_bencDictAdd( dict, key );
837
838    /* set it */
839    tr_bencInitStr( child, val, -1 );
840
841    return child;
842}
843
844tr_benc*
845tr_bencDictAddRaw( tr_benc *    dict,
846                   const char * key,
847                   const void * src,
848                   size_t       len )
849{
850    tr_benc * child;
851
852    /* see if it already exists, and if so, try to reuse it */
853    if(( child = tr_bencDictFind( dict, key ))) {
854        if( tr_bencIsString( child ) ) {
855            if( stringIsAlloced( child ) )
856                tr_free( child->val.s.str.ptr );
857        } else {
858            tr_bencDictRemove( dict, key );
859            child = NULL;
860        }
861    }
862
863    /* if it doesn't exist, create it */
864    if( child == NULL )
865        child = tr_bencDictAdd( dict, key );
866
867    /* set it */
868    tr_bencInitRaw( child, src, len );
869
870    return child;
871}
872
873tr_benc*
874tr_bencDictAddList( tr_benc *    dict,
875                    const char * key,
876                    size_t       reserveCount )
877{
878    tr_benc * child = tr_bencDictAdd( dict, key );
879
880    tr_bencInitList( child, reserveCount );
881    return child;
882}
883
884tr_benc*
885tr_bencDictAddDict( tr_benc *    dict,
886                    const char * key,
887                    size_t       reserveCount )
888{
889    tr_benc * child = tr_bencDictAdd( dict, key );
890
891    tr_bencInitDict( child, reserveCount );
892    return child;
893}
894
895int
896tr_bencDictRemove( tr_benc *    dict,
897                   const char * key )
898{
899    int i = dictIndexOf( dict, key );
900
901    if( i >= 0 )
902    {
903        const int n = dict->val.l.count;
904        tr_bencFree( &dict->val.l.vals[i] );
905        tr_bencFree( &dict->val.l.vals[i + 1] );
906        if( i + 2 < n )
907        {
908            dict->val.l.vals[i]   = dict->val.l.vals[n - 2];
909            dict->val.l.vals[i + 1] = dict->val.l.vals[n - 1];
910        }
911        dict->val.l.count -= 2;
912    }
913    return i >= 0; /* return true if found */
914}
915
916/***
917****  BENC WALKING
918***/
919
920struct KeyIndex
921{
922    const char *  key;
923    int           index;
924};
925
926static int
927compareKeyIndex( const void * va,
928                 const void * vb )
929{
930    const struct KeyIndex * a = va;
931    const struct KeyIndex * b = vb;
932
933    return strcmp( a->key, b->key );
934}
935
936struct SaveNode
937{
938    const tr_benc *  val;
939    int              valIsVisited;
940    int              childCount;
941    int              childIndex;
942    int *            children;
943};
944
945static struct SaveNode*
946nodeNewDict( const tr_benc * val )
947{
948    int               i, j;
949    int               nKeys;
950    struct SaveNode * node;
951    struct KeyIndex * indices;
952
953    assert( tr_bencIsDict( val ) );
954
955    nKeys = val->val.l.count / 2;
956    node = tr_new0( struct SaveNode, 1 );
957    node->val = val;
958    node->children = tr_new0( int, nKeys * 2 );
959
960    /* ugh, a dictionary's children have to be sorted by key... */
961    indices = tr_new( struct KeyIndex, nKeys );
962    for( i = j = 0; i < ( nKeys * 2 ); i += 2, ++j )
963    {
964        indices[j].key = getStr(&val->val.l.vals[i]);
965        indices[j].index = i;
966    }
967    qsort( indices, j, sizeof( struct KeyIndex ), compareKeyIndex );
968    for( i = 0; i < j; ++i )
969    {
970        const int index = indices[i].index;
971        node->children[node->childCount++] = index;
972        node->children[node->childCount++] = index + 1;
973    }
974
975    assert( node->childCount == nKeys * 2 );
976    tr_free( indices );
977    return node;
978}
979
980static struct SaveNode*
981nodeNewList( const tr_benc * val )
982{
983    int               i, n;
984    struct SaveNode * node;
985
986    assert( tr_bencIsList( val ) );
987
988    n = val->val.l.count;
989    node = tr_new0( struct SaveNode, 1 );
990    node->val = val;
991    node->childCount = n;
992    node->children = tr_new0( int, n );
993    for( i = 0; i < n; ++i ) /* a list's children don't need to be reordered */
994        node->children[i] = i;
995
996    return node;
997}
998
999static struct SaveNode*
1000nodeNewLeaf( const tr_benc * val )
1001{
1002    struct SaveNode * node;
1003
1004    assert( !isContainer( val ) );
1005
1006    node = tr_new0( struct SaveNode, 1 );
1007    node->val = val;
1008    return node;
1009}
1010
1011static struct SaveNode*
1012nodeNew( const tr_benc * val )
1013{
1014    struct SaveNode * node;
1015
1016    if( tr_bencIsList( val ) )
1017        node = nodeNewList( val );
1018    else if( tr_bencIsDict( val ) )
1019        node = nodeNewDict( val );
1020    else
1021        node = nodeNewLeaf( val );
1022
1023    return node;
1024}
1025
1026typedef void ( *BencWalkFunc )( const tr_benc * val, void * user_data );
1027
1028struct WalkFuncs
1029{
1030    BencWalkFunc    intFunc;
1031    BencWalkFunc    boolFunc;
1032    BencWalkFunc    realFunc;
1033    BencWalkFunc    stringFunc;
1034    BencWalkFunc    dictBeginFunc;
1035    BencWalkFunc    listBeginFunc;
1036    BencWalkFunc    containerEndFunc;
1037};
1038
1039/**
1040 * This function's previous recursive implementation was
1041 * easier to read, but was vulnerable to a smash-stacking
1042 * attack via maliciously-crafted bencoded data. (#667)
1043 */
1044static void
1045bencWalk( const tr_benc          * top,
1046          const struct WalkFuncs * walkFuncs,
1047          void                   * user_data )
1048{
1049    tr_ptrArray stack = TR_PTR_ARRAY_INIT;
1050
1051    tr_ptrArrayAppend( &stack, nodeNew( top ) );
1052
1053    while( !tr_ptrArrayEmpty( &stack ) )
1054    {
1055        struct SaveNode * node = tr_ptrArrayBack( &stack );
1056        const tr_benc *   val;
1057
1058        if( !node->valIsVisited )
1059        {
1060            val = node->val;
1061            node->valIsVisited = TRUE;
1062        }
1063        else if( node->childIndex < node->childCount )
1064        {
1065            const int index = node->children[node->childIndex++];
1066            val = node->val->val.l.vals +  index;
1067        }
1068        else /* done with this node */
1069        {
1070            if( isContainer( node->val ) )
1071                walkFuncs->containerEndFunc( node->val, user_data );
1072            tr_ptrArrayPop( &stack );
1073            tr_free( node->children );
1074            tr_free( node );
1075            continue;
1076        }
1077
1078        if( val ) switch( val->type )
1079            {
1080                case TR_TYPE_INT:
1081                    walkFuncs->intFunc( val, user_data );
1082                    break;
1083
1084                case TR_TYPE_BOOL:
1085                    walkFuncs->boolFunc( val, user_data );
1086                    break;
1087
1088                case TR_TYPE_REAL:
1089                    walkFuncs->realFunc( val, user_data );
1090                    break;
1091
1092                case TR_TYPE_STR:
1093                    walkFuncs->stringFunc( val, user_data );
1094                    break;
1095
1096                case TR_TYPE_LIST:
1097                    if( val != node->val )
1098                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
1099                    else
1100                        walkFuncs->listBeginFunc( val, user_data );
1101                    break;
1102
1103                case TR_TYPE_DICT:
1104                    if( val != node->val )
1105                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
1106                    else
1107                        walkFuncs->dictBeginFunc( val, user_data );
1108                    break;
1109
1110                default:
1111                    /* did caller give us an uninitialized val? */
1112                    tr_err( "%s", _( "Invalid metadata" ) );
1113                    break;
1114            }
1115    }
1116
1117    tr_ptrArrayDestruct( &stack, NULL );
1118}
1119
1120/****
1121*****
1122****/
1123
1124static void
1125saveIntFunc( const tr_benc * val, void * evbuf )
1126{
1127    evbuffer_add_printf( evbuf, "i%" PRId64 "e", val->val.i );
1128}
1129
1130static void
1131saveBoolFunc( const tr_benc * val, void * evbuf )
1132{
1133    if( val->val.b )
1134        evbuffer_add( evbuf, "i1e", 3 );
1135    else
1136        evbuffer_add( evbuf, "i0e", 3 );
1137}
1138
1139static void
1140saveRealFunc( const tr_benc * val, void * evbuf )
1141{
1142    char buf[128];
1143    char locale[128];
1144    size_t len;
1145
1146    /* always use a '.' decimal point s.t. locale-hopping doesn't bite us */
1147    tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
1148    setlocale( LC_NUMERIC, "POSIX" );
1149    tr_snprintf( buf, sizeof( buf ), "%f", val->val.d );
1150    setlocale( LC_NUMERIC, locale );
1151
1152    len = strlen( buf );
1153    evbuffer_add_printf( evbuf, "%lu:", (unsigned long)len );
1154    evbuffer_add( evbuf, buf, len );
1155}
1156
1157static void
1158saveStringFunc( const tr_benc * val, void * evbuf )
1159{
1160    evbuffer_add_printf( evbuf, "%lu:", (unsigned long)val->val.s.len );
1161    evbuffer_add( evbuf, getStr(val), val->val.s.len );
1162}
1163
1164static void
1165saveDictBeginFunc( const tr_benc * val UNUSED, void * evbuf )
1166{
1167    evbuffer_add( evbuf, "d", 1 );
1168}
1169
1170static void
1171saveListBeginFunc( const tr_benc * val UNUSED, void * evbuf )
1172{
1173    evbuffer_add( evbuf, "l", 1 );
1174}
1175
1176static void
1177saveContainerEndFunc( const tr_benc * val UNUSED, void * evbuf )
1178{
1179    evbuffer_add( evbuf, "e", 1 );
1180}
1181
1182static const struct WalkFuncs saveFuncs = { saveIntFunc,
1183                                            saveBoolFunc,
1184                                            saveRealFunc,
1185                                            saveStringFunc,
1186                                            saveDictBeginFunc,
1187                                            saveListBeginFunc,
1188                                            saveContainerEndFunc };
1189
1190/***
1191****
1192***/
1193
1194static void
1195freeDummyFunc( const tr_benc * val UNUSED,
1196               void * buf          UNUSED  )
1197{}
1198
1199static void
1200freeStringFunc( const tr_benc * val,
1201                void *          freeme )
1202{
1203    if( stringIsAlloced( val ) )
1204        tr_ptrArrayAppend( freeme, val->val.s.str.ptr );
1205}
1206
1207static void
1208freeContainerBeginFunc( const tr_benc * val,
1209                        void *          freeme )
1210{
1211    tr_ptrArrayAppend( freeme, val->val.l.vals );
1212}
1213
1214static const struct WalkFuncs freeWalkFuncs = { freeDummyFunc,
1215                                                freeDummyFunc,
1216                                                freeDummyFunc,
1217                                                freeStringFunc,
1218                                                freeContainerBeginFunc,
1219                                                freeContainerBeginFunc,
1220                                                freeDummyFunc };
1221
1222void
1223tr_bencFree( tr_benc * val )
1224{
1225    if( isSomething( val ) )
1226    {
1227        tr_ptrArray a = TR_PTR_ARRAY_INIT;
1228        bencWalk( val, &freeWalkFuncs, &a );
1229        tr_ptrArrayDestruct( &a, tr_free );
1230    }
1231}
1232
1233/***
1234****
1235***/
1236
1237/** @brief Implementation helper class for tr_bencToBuffer(TR_FMT_JSON) */
1238struct ParentState
1239{
1240    int    bencType;
1241    int    childIndex;
1242    int    childCount;
1243};
1244
1245/** @brief Implementation helper class for tr_bencToBuffer(TR_FMT_JSON) */
1246struct jsonWalk
1247{
1248    tr_bool doIndent;
1249    tr_list * parents;
1250    struct evbuffer *  out;
1251};
1252
1253static void
1254jsonIndent( struct jsonWalk * data )
1255{
1256    if( data->doIndent )
1257    {
1258        char buf[1024];
1259        const int width = tr_list_size( data->parents ) * 4;
1260
1261        buf[0] = '\n';
1262        memset( buf+1, ' ', width );
1263        evbuffer_add( data->out, buf, 1+width );
1264    }
1265}
1266
1267static void
1268jsonChildFunc( struct jsonWalk * data )
1269{
1270    if( data->parents )
1271    {
1272        struct ParentState * parentState = data->parents->data;
1273
1274        switch( parentState->bencType )
1275        {
1276            case TR_TYPE_DICT:
1277            {
1278                const int i = parentState->childIndex++;
1279                if( !( i % 2 ) )
1280                    evbuffer_add( data->out, ": ", data->doIndent ? 2 : 1 );
1281                else {
1282                    const tr_bool isLast = parentState->childIndex == parentState->childCount;
1283                    if( !isLast ) {
1284                        evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
1285                        jsonIndent( data );
1286                    }
1287                }
1288                break;
1289            }
1290
1291            case TR_TYPE_LIST:
1292            {
1293                const tr_bool isLast = ++parentState->childIndex == parentState->childCount;
1294                if( !isLast ) {
1295                    evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
1296                    jsonIndent( data );
1297                }
1298                break;
1299            }
1300
1301            default:
1302                break;
1303        }
1304    }
1305}
1306
1307static void
1308jsonPushParent( struct jsonWalk * data,
1309                const tr_benc *   benc )
1310{
1311    struct ParentState * parentState = tr_new( struct ParentState, 1 );
1312
1313    parentState->bencType = benc->type;
1314    parentState->childIndex = 0;
1315    parentState->childCount = benc->val.l.count;
1316    tr_list_prepend( &data->parents, parentState );
1317}
1318
1319static void
1320jsonPopParent( struct jsonWalk * data )
1321{
1322    tr_free( tr_list_pop_front( &data->parents ) );
1323}
1324
1325static void
1326jsonIntFunc( const tr_benc * val,
1327             void *          vdata )
1328{
1329    struct jsonWalk * data = vdata;
1330
1331    evbuffer_add_printf( data->out, "%" PRId64, val->val.i );
1332    jsonChildFunc( data );
1333}
1334
1335static void
1336jsonBoolFunc( const tr_benc * val, void * vdata )
1337{
1338    struct jsonWalk * data = vdata;
1339
1340    if( val->val.b )
1341        evbuffer_add( data->out, "true", 4 );
1342    else
1343        evbuffer_add( data->out, "false", 5 );
1344
1345    jsonChildFunc( data );
1346}
1347
1348static void
1349jsonRealFunc( const tr_benc * val, void * vdata )
1350{
1351    struct jsonWalk * data = vdata;
1352    char locale[128];
1353
1354    if( fabs( val->val.d ) < 0.00001 )
1355        evbuffer_add( data->out, "0", 1 );
1356    else {
1357        /* json requires a '.' decimal point regardless of locale */
1358        tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
1359        setlocale( LC_NUMERIC, "POSIX" );
1360        evbuffer_add_printf( data->out, "%.4f", tr_truncd( val->val.d, 4 ) );
1361        setlocale( LC_NUMERIC, locale );
1362    }
1363
1364    jsonChildFunc( data );
1365}
1366
1367static void
1368jsonStringFunc( const tr_benc * val, void * vdata )
1369{
1370    struct jsonWalk * data = vdata;
1371    const unsigned char * it = (const unsigned char *) getStr(val);
1372    const unsigned char * end = it + val->val.s.len;
1373
1374    evbuffer_expand( data->out, val->val.s.len + 2 );
1375    evbuffer_add( data->out, "\"", 1 );
1376
1377    for( ; it!=end; ++it )
1378    {
1379        switch( *it )
1380        {
1381            case '\b': evbuffer_add( data->out, "\\b", 2 ); break;
1382            case '\f': evbuffer_add( data->out, "\\f", 2 ); break;
1383            case '\n': evbuffer_add( data->out, "\\n", 2 ); break;
1384            case '\r': evbuffer_add( data->out, "\\r", 2 ); break;
1385            case '\t': evbuffer_add( data->out, "\\t", 2 ); break;
1386            case '"': evbuffer_add( data->out, "\\\"", 2 ); break;
1387            case '\\': evbuffer_add( data->out, "\\\\", 2 ); break;
1388
1389            default:
1390                if( isascii( *it ) )
1391                    evbuffer_add( data->out, it, 1 );
1392                else {
1393                    const UTF8 * tmp = it;
1394                    UTF32        buf = 0;
1395                    UTF32 *      u32 = &buf;
1396                    ConversionResult result = ConvertUTF8toUTF32( &tmp, end, &u32, &buf + 1, 0 );
1397                    if((( result==conversionOK ) || (result==targetExhausted)) && (tmp!=it)) {
1398                        evbuffer_add_printf( data->out, "\\u%04x", (unsigned int)buf );
1399                        it = tmp - 1;
1400                    }
1401                }
1402        }
1403    }
1404    evbuffer_add( data->out, "\"", 1 );
1405    jsonChildFunc( data );
1406}
1407
1408static void
1409jsonDictBeginFunc( const tr_benc * val,
1410                   void *          vdata )
1411{
1412    struct jsonWalk * data = vdata;
1413
1414    jsonPushParent( data, val );
1415    evbuffer_add( data->out, "{", 1 );
1416    if( val->val.l.count )
1417        jsonIndent( data );
1418}
1419
1420static void
1421jsonListBeginFunc( const tr_benc * val,
1422                   void *          vdata )
1423{
1424    const size_t      nChildren = tr_bencListSize( val );
1425    struct jsonWalk * data = vdata;
1426
1427    jsonPushParent( data, val );
1428    evbuffer_add( data->out, "[", 1 );
1429    if( nChildren )
1430        jsonIndent( data );
1431}
1432
1433static void
1434jsonContainerEndFunc( const tr_benc * val,
1435                      void *          vdata )
1436{
1437    struct jsonWalk * data = vdata;
1438    int               emptyContainer = FALSE;
1439
1440    jsonPopParent( data );
1441    if( !emptyContainer )
1442        jsonIndent( data );
1443    if( tr_bencIsDict( val ) )
1444        evbuffer_add( data->out, "}", 1 );
1445    else /* list */
1446        evbuffer_add( data->out, "]", 1 );
1447    jsonChildFunc( data );
1448}
1449
1450static const struct WalkFuncs jsonWalkFuncs = { jsonIntFunc,
1451                                                jsonBoolFunc,
1452                                                jsonRealFunc,
1453                                                jsonStringFunc,
1454                                                jsonDictBeginFunc,
1455                                                jsonListBeginFunc,
1456                                                jsonContainerEndFunc };
1457
1458/***
1459****
1460***/
1461
1462static void
1463tr_bencListCopy( tr_benc * target, const tr_benc * src )
1464{
1465    int i = 0;
1466    const tr_benc * val;
1467
1468    while(( val = tr_bencListChild( (tr_benc*)src, i++ )))
1469    {
1470       if( tr_bencIsBool( val ) )
1471       {
1472           tr_bool boolVal = 0;
1473           tr_bencGetBool( val, &boolVal );
1474           tr_bencListAddBool( target, boolVal );
1475       }
1476       else if( tr_bencIsReal( val ) )
1477       {
1478           double realVal = 0;
1479           tr_bencGetReal( val, &realVal );
1480           tr_bencListAddReal( target, realVal );
1481       }
1482       else if( tr_bencIsInt( val ) )
1483       {
1484           int64_t intVal = 0;
1485           tr_bencGetInt( val, &intVal );
1486           tr_bencListAddInt( target, intVal );
1487       }
1488       else if( tr_bencIsString( val ) )
1489       {
1490           tr_bencListAddRaw( target, (const uint8_t*)getStr( val ), val->val.s.len );
1491       }
1492       else if( tr_bencIsDict( val ) )
1493       {
1494           tr_bencMergeDicts( tr_bencListAddDict( target, 0 ), val );
1495       }
1496       else if ( tr_bencIsList( val ) )
1497       {
1498           tr_bencListCopy( tr_bencListAddList( target, 0 ), val );
1499       }
1500       else
1501       {
1502           tr_err( "tr_bencListCopy skipping item" );
1503       }
1504   }
1505}
1506
1507static size_t
1508tr_bencDictSize( const tr_benc * dict )
1509{
1510    size_t count = 0;
1511
1512    if( tr_bencIsDict( dict ) )
1513        count = dict->val.l.count / 2;
1514
1515    return count;
1516}
1517
1518tr_bool
1519tr_bencDictChild( tr_benc * dict, size_t n, const char ** key, tr_benc ** val )
1520{
1521    tr_bool success = 0;
1522
1523    assert( tr_bencIsDict( dict ) );
1524
1525    if( tr_bencIsDict( dict ) && (n*2)+1 <= dict->val.l.count )
1526    {
1527        tr_benc * k = dict->val.l.vals + (n*2);
1528        tr_benc * v = dict->val.l.vals + (n*2) + 1;
1529        if(( success = tr_bencGetStr( k, key ) && isSomething( v )))
1530            *val = v;
1531    }
1532
1533    return success;
1534}
1535
1536void
1537tr_bencMergeDicts( tr_benc * target, const tr_benc * source )
1538{
1539    size_t i;
1540    const size_t sourceCount = tr_bencDictSize( source );
1541
1542    assert( tr_bencIsDict( target ) );
1543    assert( tr_bencIsDict( source ) );
1544
1545    for( i=0; i<sourceCount; ++i )
1546    {
1547        const char * key;
1548        tr_benc * val;
1549        tr_benc * t;
1550
1551        if( tr_bencDictChild( (tr_benc*)source, i, &key, &val ) )
1552        {
1553            if( tr_bencIsBool( val ) )
1554            {
1555                tr_bool boolVal;
1556                tr_bencGetBool( val, &boolVal );
1557                tr_bencDictAddBool( target, key, boolVal );
1558            }
1559            else if( tr_bencIsReal( val ) )
1560            {
1561                double realVal = 0;
1562                tr_bencGetReal( val, &realVal );
1563                tr_bencDictAddReal( target, key, realVal );
1564            }
1565            else if( tr_bencIsInt( val ) )
1566            {
1567                int64_t intVal = 0;
1568                tr_bencGetInt( val, &intVal );
1569                tr_bencDictAddInt( target, key, intVal );
1570            }
1571            else if( tr_bencIsString( val ) )
1572            {
1573                tr_bencDictAddRaw( target, key, getStr( val ), val->val.s.len );
1574            }
1575            else if( tr_bencIsDict( val ) && tr_bencDictFindDict( target, key, &t ) )
1576            {
1577                tr_bencMergeDicts( t, val );
1578            }
1579            else if( tr_bencIsList( val ) )
1580            {
1581                if( tr_bencDictFind( target, key ) == NULL )
1582                {
1583                    tr_bencListCopy( tr_bencDictAddList( target, key, tr_bencListSize( val ) ), val );
1584                }
1585            }
1586            else
1587            {
1588                tr_dbg( "tr_bencMergeDicts skipping \"%s\"", key );
1589            }
1590        }
1591    }
1592}
1593
1594/***
1595****
1596***/
1597
1598void
1599tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode, struct evbuffer * buf )
1600{
1601    evbuffer_drain( buf, EVBUFFER_LENGTH( buf ) );
1602    evbuffer_expand( buf, 4096 ); /* alloc a little memory to start off with */
1603
1604    switch( mode )
1605    {
1606        case TR_FMT_BENC:
1607            bencWalk( top, &saveFuncs, buf );
1608            break;
1609
1610        case TR_FMT_JSON:
1611        case TR_FMT_JSON_LEAN: {
1612            struct jsonWalk data;
1613            data.doIndent = mode==TR_FMT_JSON;
1614            data.out = buf;
1615            data.parents = NULL;
1616            bencWalk( top, &jsonWalkFuncs, &data );
1617            if( EVBUFFER_LENGTH( buf ) )
1618                evbuffer_add_printf( buf, "\n" );
1619            break;
1620        }
1621    }
1622}
1623
1624char*
1625tr_bencToStr( const tr_benc * top, tr_fmt_mode mode, int * len )
1626{
1627    char * ret;
1628    struct evbuffer * buf = evbuffer_new( );
1629    tr_bencToBuf( top, mode, buf );
1630    ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
1631    if( len != NULL )
1632        *len = (int) EVBUFFER_LENGTH( buf );
1633    evbuffer_free( buf );
1634    return ret;
1635}
1636
1637/* portability wrapper for mkstemp(). */
1638static int
1639tr_mkstemp( char * template )
1640{
1641#ifdef WIN32
1642    const int flags = O_RDWR | O_BINARY | O_CREAT | O_EXCL | _O_SHORT_LIVED;
1643    const mode_t mode = _S_IREAD | _S_IWRITE;
1644    mktemp( template );
1645    return open( template, flags, mode );
1646#else
1647    return mkstemp( template );
1648#endif
1649}
1650
1651/* portability wrapper for fsync(). */
1652static void
1653tr_fsync( int fd )
1654{
1655#ifdef WIN32
1656    _commit( fd );
1657#else
1658    fsync( fd );
1659#endif
1660}
1661
1662int
1663tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
1664{
1665    char * tmp;
1666    int fd;
1667    int err = 0;
1668    char buf[TR_PATH_MAX];
1669
1670    /* follow symlinks to find the "real" file, to make sure the temporary
1671     * we build with tr_mkstemp() is created on the right partition */
1672    if( tr_realpath( filename, buf ) != NULL )
1673        filename = buf;
1674
1675    /* if the file already exists, try to move it out of the way & keep it as a backup */
1676    tmp = tr_strdup_printf( "%s.tmp.XXXXXX", filename );
1677    fd = tr_mkstemp( tmp );
1678    if( fd >= 0 )
1679    {
1680        int len;
1681        char * str = tr_bencToStr( top, mode, &len );
1682        tr_dbg( "Writing %d bytes to temporary file \"%s\"", (int)len, tmp );
1683
1684        if( write( fd, str, len ) == (ssize_t)len )
1685        {
1686            tr_fsync( fd );
1687            close( fd );
1688
1689            if( !unlink( filename ) || ( errno == ENOENT ) )
1690            {
1691                tr_dbg( "Renaming \"%s\" as \"%s\"", tmp, filename );
1692
1693                if( !rename( tmp, filename ) )
1694                {
1695                    tr_inf( _( "Saved \"%s\"" ), filename );
1696                }
1697                else
1698                {
1699                    err = errno;
1700                    tr_err( _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
1701                    unlink( tmp );
1702                }
1703            }
1704            else
1705            {
1706                err = errno;
1707                tr_err( _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
1708                unlink( tmp );
1709            }
1710        }
1711        else
1712        {
1713            err = errno;
1714            tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
1715            close( fd );
1716            unlink( tmp );
1717        }
1718
1719        tr_free( str );
1720    }
1721    else
1722    {
1723        err = errno;
1724        tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
1725    }
1726
1727    tr_free( tmp );
1728    return err;
1729}
1730
1731/***
1732****
1733***/
1734
1735int
1736tr_bencLoadFile( tr_benc * setme, tr_fmt_mode mode, const char * filename )
1737{
1738    int err;
1739    size_t contentLen;
1740    uint8_t * content;
1741
1742    content = tr_loadFile( filename, &contentLen );
1743    if( !content && errno )
1744        err = errno;
1745    else if( !content )
1746        err = ENODATA;
1747    else {
1748        if( mode == TR_FMT_BENC )
1749            err = tr_bencLoad( content, contentLen, setme, NULL );
1750        else
1751            err = tr_jsonParse( filename, content, contentLen, setme, NULL );
1752    }
1753
1754    tr_free( content );
1755    return err;
1756}
1757
Note: See TracBrowser for help on using the repository browser.