source: trunk/libtransmission/bencode.c @ 11300

Last change on this file since 11300 was 11300, checked in by charles, 11 years ago

(trunk libT) #3614 "Can't save benc files under uClibc 0.9.31" -- on some systems, calling unlink() on a file that doesn't exist returns 0 instead of -1 + ENOENT... so don't rely on that test. Instead, call stat() before unlink()ing the file.

  • Property svn:keywords set to Date Rev Author Id
File size: 43.5 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 11300 2010-10-11 21:27:31Z 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() */
31
32#include <event.h> /* struct evbuffer */
33
34#include "ConvertUTF.h"
35
36#include "transmission.h"
37#include "bencode.h"
38#include "fdlimit.h" /* tr_close_file() */
39#include "json.h"
40#include "list.h"
41#include "platform.h" /* TR_PATH_MAX */
42#include "ptrarray.h"
43#include "utils.h" /* tr_new(), tr_free() */
44
45#ifndef ENODATA
46 #define ENODATA EIO
47#endif
48
49/**
50***
51**/
52
53static tr_bool
54isContainer( const tr_benc * val )
55{
56    return tr_bencIsList( val ) || tr_bencIsDict( val );
57}
58
59static tr_bool
60isSomething( const tr_benc * val )
61{
62    return isContainer( val ) || tr_bencIsInt( val )
63                              || tr_bencIsString( val )
64                              || tr_bencIsReal( val )
65                              || tr_bencIsBool( val );
66}
67
68static void
69tr_bencInit( tr_benc * val, char 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, const char ** setme )
472{
473    const tr_bool success = tr_bencIsString( val );
474
475    if( success )
476        *setme = getStr( val );
477
478    return success;
479}
480
481tr_bool
482tr_bencGetBool( const tr_benc * val, tr_bool * setme )
483{
484    const char * str;
485    tr_bool success = FALSE;
486
487    if(( success = tr_bencIsBool( val )))
488        *setme = val->val.b;
489
490    if( !success && tr_bencIsInt( val ) )
491        if(( success = ( val->val.i==0 || val->val.i==1 ) ))
492            *setme = val->val.i!=0;
493
494    if( !success && tr_bencGetStr( val, &str ) )
495        if(( success = ( !strcmp(str,"true") || !strcmp(str,"false"))))
496            *setme = !strcmp(str,"true");
497
498    return success;
499}
500
501tr_bool
502tr_bencGetReal( const tr_benc * val, double * setme )
503{
504    tr_bool success = FALSE;
505
506    if( !success && (( success = tr_bencIsReal( val ))))
507        *setme = val->val.d;
508
509    if( !success && (( success = tr_bencIsInt( val ))))
510        *setme = val->val.i;
511
512    if( !success && tr_bencIsString(val) )
513    {
514        char * endptr;
515        char locale[128];
516        double d;
517
518        /* the json spec requires a '.' decimal point regardless of locale */
519        tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
520        setlocale( LC_NUMERIC, "POSIX" );
521        d  = strtod( getStr(val), &endptr );
522        setlocale( LC_NUMERIC, locale );
523
524        if(( success = ( getStr(val) != endptr ) && !*endptr ))
525            *setme = d;
526    }
527
528
529    return success;
530}
531
532tr_bool
533tr_bencDictFindInt( tr_benc * dict, const char * key, int64_t * setme )
534{
535    return tr_bencGetInt( tr_bencDictFind( dict, key ), setme );
536}
537
538tr_bool
539tr_bencDictFindBool( tr_benc * dict, const char * key, tr_bool * setme )
540{
541    return tr_bencGetBool( tr_bencDictFind( dict, key ), setme );
542}
543
544tr_bool
545tr_bencDictFindReal( tr_benc * dict, const char * key, double * setme )
546{
547    return tr_bencGetReal( tr_bencDictFind( dict, key ), setme );
548}
549
550tr_bool
551tr_bencDictFindStr( tr_benc *  dict, const char *  key, const char ** setme )
552{
553    return tr_bencGetStr( tr_bencDictFind( dict, key ), setme );
554}
555
556tr_bool
557tr_bencDictFindList( tr_benc * dict, const char * key, tr_benc ** setme )
558{
559    return tr_bencDictFindType( dict, key, TR_TYPE_LIST, setme );
560}
561
562tr_bool
563tr_bencDictFindDict( tr_benc * dict, const char * key, tr_benc ** setme )
564{
565    return tr_bencDictFindType( dict, key, TR_TYPE_DICT, setme );
566}
567
568tr_bool
569tr_bencDictFindRaw( tr_benc         * dict,
570                    const char      * key,
571                    const uint8_t  ** setme_raw,
572                    size_t          * setme_len )
573{
574    tr_benc * child;
575    const tr_bool found = tr_bencDictFindType( dict, key, TR_TYPE_STR, &child );
576
577    if( found ) {
578        *setme_raw = (uint8_t*) getStr(child);
579        *setme_len = child->val.s.len;
580    }
581
582    return found;
583}
584
585/***
586****
587***/
588
589void
590tr_bencInitRaw( tr_benc * val, const void * src, size_t byteCount )
591{
592    char * setme;
593    tr_bencInit( val, TR_TYPE_STR );
594
595    /* There's no way in benc notation to distinguish between
596     * zero-terminated strings and raw byte arrays.
597     * Because of this, tr_bencMergeDicts() and tr_bencListCopy()
598     * don't know whether or not a TR_TYPE_STR node needs a '\0'.
599     * Append one, een to the raw arrays, just to be safe. */
600
601    if( byteCount < sizeof( val->val.s.str.buf ) )
602        setme = val->val.s.str.buf;
603    else
604        setme = val->val.s.str.ptr = tr_new( char, byteCount + 1 );
605
606    memcpy( setme, src, byteCount );
607    setme[byteCount] = '\0';
608    val->val.s.len = byteCount;
609}
610
611void
612tr_bencInitStr( tr_benc * val, const void * str, int len )
613{
614    if( str == NULL )
615        len = 0;
616    else if( len < 0 )
617        len = strlen( str );
618
619    tr_bencInitRaw( val, str, len );
620}
621
622void
623tr_bencInitBool( tr_benc * b, int value )
624{
625    tr_bencInit( b, TR_TYPE_BOOL );
626    b->val.b = value != 0;
627}
628
629void
630tr_bencInitReal( tr_benc * b, double value )
631{
632    tr_bencInit( b, TR_TYPE_REAL );
633    b->val.d = value;
634}
635
636void
637tr_bencInitInt( tr_benc * b, int64_t value )
638{
639    tr_bencInit( b, TR_TYPE_INT );
640    b->val.i = value;
641}
642
643int
644tr_bencInitList( tr_benc * b, size_t reserveCount )
645{
646    tr_bencInit( b, TR_TYPE_LIST );
647    return tr_bencListReserve( b, reserveCount );
648}
649
650int
651tr_bencListReserve( tr_benc * b, size_t count )
652{
653    assert( tr_bencIsList( b ) );
654    return makeroom( b, count );
655}
656
657int
658tr_bencInitDict( tr_benc * b, size_t reserveCount )
659{
660    tr_bencInit( b, TR_TYPE_DICT );
661    return tr_bencDictReserve( b, reserveCount );
662}
663
664int
665tr_bencDictReserve( tr_benc * b, size_t reserveCount )
666{
667    assert( tr_bencIsDict( b ) );
668    return makeroom( b, reserveCount * 2 );
669}
670
671tr_benc *
672tr_bencListAdd( tr_benc * list )
673{
674    tr_benc * item;
675
676    assert( tr_bencIsList( list ) );
677
678    if( list->val.l.count == list->val.l.alloc )
679        tr_bencListReserve( list, LIST_SIZE );
680
681    assert( list->val.l.count < list->val.l.alloc );
682
683    item = &list->val.l.vals[list->val.l.count];
684    list->val.l.count++;
685    tr_bencInit( item, TR_TYPE_INT );
686
687    return item;
688}
689
690tr_benc *
691tr_bencListAddInt( tr_benc * list, int64_t val )
692{
693    tr_benc * node = tr_bencListAdd( list );
694
695    tr_bencInitInt( node, val );
696    return node;
697}
698
699tr_benc *
700tr_bencListAddReal( tr_benc * list, double val )
701{
702    tr_benc * node = tr_bencListAdd( list );
703    tr_bencInitReal( node, val );
704    return node;
705}
706
707tr_benc *
708tr_bencListAddBool( tr_benc * list, tr_bool val )
709{
710    tr_benc * node = tr_bencListAdd( list );
711    tr_bencInitBool( node, val );
712    return node;
713}
714
715tr_benc *
716tr_bencListAddStr( tr_benc * list, const char * val )
717{
718    tr_benc * node = tr_bencListAdd( list );
719    tr_bencInitStr( node, val, -1 );
720    return node;
721}
722
723tr_benc *
724tr_bencListAddRaw( tr_benc * list, const uint8_t * val, size_t len )
725{
726    tr_benc * node = tr_bencListAdd( list );
727    tr_bencInitRaw( node, val, len );
728    return node;
729}
730
731tr_benc*
732tr_bencListAddList( tr_benc * list,
733                    size_t    reserveCount )
734{
735    tr_benc * child = tr_bencListAdd( list );
736
737    tr_bencInitList( child, reserveCount );
738    return child;
739}
740
741tr_benc*
742tr_bencListAddDict( tr_benc * list,
743                    size_t    reserveCount )
744{
745    tr_benc * child = tr_bencListAdd( list );
746
747    tr_bencInitDict( child, reserveCount );
748    return child;
749}
750
751tr_benc *
752tr_bencDictAdd( tr_benc *    dict,
753                const char * key )
754{
755    tr_benc * keyval, * itemval;
756
757    assert( tr_bencIsDict( dict ) );
758    if( dict->val.l.count + 2 > dict->val.l.alloc )
759        makeroom( dict, 2 );
760    assert( dict->val.l.count + 2 <= dict->val.l.alloc );
761
762    keyval = dict->val.l.vals + dict->val.l.count++;
763    tr_bencInitStr( keyval, key, -1 );
764
765    itemval = dict->val.l.vals + dict->val.l.count++;
766    tr_bencInit( itemval, TR_TYPE_INT );
767
768    return itemval;
769}
770
771static tr_benc*
772dictFindOrAdd( tr_benc * dict, const char * key, int type )
773{
774    tr_benc * child;
775
776    /* see if it already exists, and if so, try to reuse it */
777    if(( child = tr_bencDictFind( dict, key ))) {
778        if( !tr_bencIsType( child, type ) ) {
779            tr_bencDictRemove( dict, key );
780            child = NULL;
781        }
782    }
783
784    /* if it doesn't exist, create it */
785    if( child == NULL )
786        child = tr_bencDictAdd( dict, key );
787
788    return child;
789}
790
791tr_benc*
792tr_bencDictAddInt( tr_benc *    dict,
793                   const char * key,
794                   int64_t      val )
795{
796    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_INT );
797    tr_bencInitInt( child, val );
798    return child;
799}
800
801tr_benc*
802tr_bencDictAddBool( tr_benc * dict, const char * key, tr_bool val )
803{
804    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_BOOL );
805    tr_bencInitBool( child, val );
806    return child;
807}
808
809tr_benc*
810tr_bencDictAddReal( tr_benc * dict, const char * key, double val )
811{
812    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_REAL );
813    tr_bencInitReal( child, val );
814    return child;
815}
816
817tr_benc*
818tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
819{
820    tr_benc * child;
821
822    /* see if it already exists, and if so, try to reuse it */
823    if(( child = tr_bencDictFind( dict, key ))) {
824        if( tr_bencIsString( child ) ) {
825            if( stringIsAlloced( child ) )
826                tr_free( child->val.s.str.ptr );
827        } else {
828            tr_bencDictRemove( dict, key );
829            child = NULL;
830        }
831    }
832
833    /* if it doesn't exist, create it */
834    if( child == NULL )
835        child = tr_bencDictAdd( dict, key );
836
837    /* set it */
838    tr_bencInitStr( child, val, -1 );
839
840    return child;
841}
842
843tr_benc*
844tr_bencDictAddRaw( tr_benc *    dict,
845                   const char * key,
846                   const void * src,
847                   size_t       len )
848{
849    tr_benc * child;
850
851    /* see if it already exists, and if so, try to reuse it */
852    if(( child = tr_bencDictFind( dict, key ))) {
853        if( tr_bencIsString( child ) ) {
854            if( stringIsAlloced( child ) )
855                tr_free( child->val.s.str.ptr );
856        } else {
857            tr_bencDictRemove( dict, key );
858            child = NULL;
859        }
860    }
861
862    /* if it doesn't exist, create it */
863    if( child == NULL )
864        child = tr_bencDictAdd( dict, key );
865
866    /* set it */
867    tr_bencInitRaw( child, src, len );
868
869    return child;
870}
871
872tr_benc*
873tr_bencDictAddList( tr_benc *    dict,
874                    const char * key,
875                    size_t       reserveCount )
876{
877    tr_benc * child = tr_bencDictAdd( dict, key );
878
879    tr_bencInitList( child, reserveCount );
880    return child;
881}
882
883tr_benc*
884tr_bencDictAddDict( tr_benc *    dict,
885                    const char * key,
886                    size_t       reserveCount )
887{
888    tr_benc * child = tr_bencDictAdd( dict, key );
889
890    tr_bencInitDict( child, reserveCount );
891    return child;
892}
893
894int
895tr_bencDictRemove( tr_benc *    dict,
896                   const char * key )
897{
898    int i = dictIndexOf( dict, key );
899
900    if( i >= 0 )
901    {
902        const int n = dict->val.l.count;
903        tr_bencFree( &dict->val.l.vals[i] );
904        tr_bencFree( &dict->val.l.vals[i + 1] );
905        if( i + 2 < n )
906        {
907            dict->val.l.vals[i]   = dict->val.l.vals[n - 2];
908            dict->val.l.vals[i + 1] = dict->val.l.vals[n - 1];
909        }
910        dict->val.l.count -= 2;
911    }
912    return i >= 0; /* return true if found */
913}
914
915/***
916****  BENC WALKING
917***/
918
919struct KeyIndex
920{
921    const char *  key;
922    int           index;
923};
924
925static int
926compareKeyIndex( const void * va,
927                 const void * vb )
928{
929    const struct KeyIndex * a = va;
930    const struct KeyIndex * b = vb;
931
932    return strcmp( a->key, b->key );
933}
934
935struct SaveNode
936{
937    const tr_benc *  val;
938    int              valIsVisited;
939    int              childCount;
940    int              childIndex;
941    int *            children;
942};
943
944static struct SaveNode*
945nodeNewDict( const tr_benc * val )
946{
947    int               i, j;
948    int               nKeys;
949    struct SaveNode * node;
950    struct KeyIndex * indices;
951
952    assert( tr_bencIsDict( val ) );
953
954    nKeys = val->val.l.count / 2;
955    node = tr_new0( struct SaveNode, 1 );
956    node->val = val;
957    node->children = tr_new0( int, nKeys * 2 );
958
959    /* ugh, a dictionary's children have to be sorted by key... */
960    indices = tr_new( struct KeyIndex, nKeys );
961    for( i = j = 0; i < ( nKeys * 2 ); i += 2, ++j )
962    {
963        indices[j].key = getStr(&val->val.l.vals[i]);
964        indices[j].index = i;
965    }
966    qsort( indices, j, sizeof( struct KeyIndex ), compareKeyIndex );
967    for( i = 0; i < j; ++i )
968    {
969        const int index = indices[i].index;
970        node->children[node->childCount++] = index;
971        node->children[node->childCount++] = index + 1;
972    }
973
974    assert( node->childCount == nKeys * 2 );
975    tr_free( indices );
976    return node;
977}
978
979static struct SaveNode*
980nodeNewList( const tr_benc * val )
981{
982    int               i, n;
983    struct SaveNode * node;
984
985    assert( tr_bencIsList( val ) );
986
987    n = val->val.l.count;
988    node = tr_new0( struct SaveNode, 1 );
989    node->val = val;
990    node->childCount = n;
991    node->children = tr_new0( int, n );
992    for( i = 0; i < n; ++i ) /* a list's children don't need to be reordered */
993        node->children[i] = i;
994
995    return node;
996}
997
998static struct SaveNode*
999nodeNewLeaf( const tr_benc * val )
1000{
1001    struct SaveNode * node;
1002
1003    assert( !isContainer( val ) );
1004
1005    node = tr_new0( struct SaveNode, 1 );
1006    node->val = val;
1007    return node;
1008}
1009
1010static struct SaveNode*
1011nodeNew( const tr_benc * val )
1012{
1013    struct SaveNode * node;
1014
1015    if( tr_bencIsList( val ) )
1016        node = nodeNewList( val );
1017    else if( tr_bencIsDict( val ) )
1018        node = nodeNewDict( val );
1019    else
1020        node = nodeNewLeaf( val );
1021
1022    return node;
1023}
1024
1025typedef void ( *BencWalkFunc )( const tr_benc * val, void * user_data );
1026
1027struct WalkFuncs
1028{
1029    BencWalkFunc    intFunc;
1030    BencWalkFunc    boolFunc;
1031    BencWalkFunc    realFunc;
1032    BencWalkFunc    stringFunc;
1033    BencWalkFunc    dictBeginFunc;
1034    BencWalkFunc    listBeginFunc;
1035    BencWalkFunc    containerEndFunc;
1036};
1037
1038/**
1039 * This function's previous recursive implementation was
1040 * easier to read, but was vulnerable to a smash-stacking
1041 * attack via maliciously-crafted bencoded data. (#667)
1042 */
1043static void
1044bencWalk( const tr_benc          * top,
1045          const struct WalkFuncs * walkFuncs,
1046          void                   * user_data )
1047{
1048    tr_ptrArray stack = TR_PTR_ARRAY_INIT;
1049
1050    tr_ptrArrayAppend( &stack, nodeNew( top ) );
1051
1052    while( !tr_ptrArrayEmpty( &stack ) )
1053    {
1054        struct SaveNode * node = tr_ptrArrayBack( &stack );
1055        const tr_benc *   val;
1056
1057        if( !node->valIsVisited )
1058        {
1059            val = node->val;
1060            node->valIsVisited = TRUE;
1061        }
1062        else if( node->childIndex < node->childCount )
1063        {
1064            const int index = node->children[node->childIndex++];
1065            val = node->val->val.l.vals +  index;
1066        }
1067        else /* done with this node */
1068        {
1069            if( isContainer( node->val ) )
1070                walkFuncs->containerEndFunc( node->val, user_data );
1071            tr_ptrArrayPop( &stack );
1072            tr_free( node->children );
1073            tr_free( node );
1074            continue;
1075        }
1076
1077        if( val ) switch( val->type )
1078            {
1079                case TR_TYPE_INT:
1080                    walkFuncs->intFunc( val, user_data );
1081                    break;
1082
1083                case TR_TYPE_BOOL:
1084                    walkFuncs->boolFunc( val, user_data );
1085                    break;
1086
1087                case TR_TYPE_REAL:
1088                    walkFuncs->realFunc( val, user_data );
1089                    break;
1090
1091                case TR_TYPE_STR:
1092                    walkFuncs->stringFunc( val, user_data );
1093                    break;
1094
1095                case TR_TYPE_LIST:
1096                    if( val != node->val )
1097                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
1098                    else
1099                        walkFuncs->listBeginFunc( val, user_data );
1100                    break;
1101
1102                case TR_TYPE_DICT:
1103                    if( val != node->val )
1104                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
1105                    else
1106                        walkFuncs->dictBeginFunc( val, user_data );
1107                    break;
1108
1109                default:
1110                    /* did caller give us an uninitialized val? */
1111                    tr_err( "%s", _( "Invalid metadata" ) );
1112                    break;
1113            }
1114    }
1115
1116    tr_ptrArrayDestruct( &stack, NULL );
1117}
1118
1119/****
1120*****
1121****/
1122
1123static void
1124saveIntFunc( const tr_benc * val, void * evbuf )
1125{
1126    evbuffer_add_printf( evbuf, "i%" PRId64 "e", val->val.i );
1127}
1128
1129static void
1130saveBoolFunc( const tr_benc * val, void * evbuf )
1131{
1132    if( val->val.b )
1133        evbuffer_add( evbuf, "i1e", 3 );
1134    else
1135        evbuffer_add( evbuf, "i0e", 3 );
1136}
1137
1138static void
1139saveRealFunc( const tr_benc * val, void * evbuf )
1140{
1141    char buf[128];
1142    char locale[128];
1143    size_t len;
1144
1145    /* always use a '.' decimal point s.t. locale-hopping doesn't bite us */
1146    tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
1147    setlocale( LC_NUMERIC, "POSIX" );
1148    tr_snprintf( buf, sizeof( buf ), "%f", val->val.d );
1149    setlocale( LC_NUMERIC, locale );
1150
1151    len = strlen( buf );
1152    evbuffer_add_printf( evbuf, "%lu:", (unsigned long)len );
1153    evbuffer_add( evbuf, buf, len );
1154}
1155
1156static void
1157saveStringFunc( const tr_benc * val, void * evbuf )
1158{
1159    evbuffer_add_printf( evbuf, "%lu:", (unsigned long)val->val.s.len );
1160    evbuffer_add( evbuf, getStr(val), val->val.s.len );
1161}
1162
1163static void
1164saveDictBeginFunc( const tr_benc * val UNUSED, void * evbuf )
1165{
1166    evbuffer_add( evbuf, "d", 1 );
1167}
1168
1169static void
1170saveListBeginFunc( const tr_benc * val UNUSED, void * evbuf )
1171{
1172    evbuffer_add( evbuf, "l", 1 );
1173}
1174
1175static void
1176saveContainerEndFunc( const tr_benc * val UNUSED, void * evbuf )
1177{
1178    evbuffer_add( evbuf, "e", 1 );
1179}
1180
1181static const struct WalkFuncs saveFuncs = { saveIntFunc,
1182                                            saveBoolFunc,
1183                                            saveRealFunc,
1184                                            saveStringFunc,
1185                                            saveDictBeginFunc,
1186                                            saveListBeginFunc,
1187                                            saveContainerEndFunc };
1188
1189/***
1190****
1191***/
1192
1193static void
1194freeDummyFunc( const tr_benc * val UNUSED,
1195               void * buf          UNUSED  )
1196{}
1197
1198static void
1199freeStringFunc( const tr_benc * val,
1200                void *          freeme )
1201{
1202    if( stringIsAlloced( val ) )
1203        tr_ptrArrayAppend( freeme, val->val.s.str.ptr );
1204}
1205
1206static void
1207freeContainerBeginFunc( const tr_benc * val,
1208                        void *          freeme )
1209{
1210    tr_ptrArrayAppend( freeme, val->val.l.vals );
1211}
1212
1213static const struct WalkFuncs freeWalkFuncs = { freeDummyFunc,
1214                                                freeDummyFunc,
1215                                                freeDummyFunc,
1216                                                freeStringFunc,
1217                                                freeContainerBeginFunc,
1218                                                freeContainerBeginFunc,
1219                                                freeDummyFunc };
1220
1221void
1222tr_bencFree( tr_benc * val )
1223{
1224    if( isSomething( val ) )
1225    {
1226        tr_ptrArray a = TR_PTR_ARRAY_INIT;
1227        bencWalk( val, &freeWalkFuncs, &a );
1228        tr_ptrArrayDestruct( &a, tr_free );
1229    }
1230}
1231
1232/***
1233****
1234***/
1235
1236/** @brief Implementation helper class for tr_bencToBuffer(TR_FMT_JSON) */
1237struct ParentState
1238{
1239    int    bencType;
1240    int    childIndex;
1241    int    childCount;
1242};
1243
1244/** @brief Implementation helper class for tr_bencToBuffer(TR_FMT_JSON) */
1245struct jsonWalk
1246{
1247    tr_bool doIndent;
1248    tr_list * parents;
1249    struct evbuffer *  out;
1250};
1251
1252static void
1253jsonIndent( struct jsonWalk * data )
1254{
1255    if( data->doIndent )
1256    {
1257        char buf[1024];
1258        const int width = tr_list_size( data->parents ) * 4;
1259
1260        buf[0] = '\n';
1261        memset( buf+1, ' ', width );
1262        evbuffer_add( data->out, buf, 1+width );
1263    }
1264}
1265
1266static void
1267jsonChildFunc( struct jsonWalk * data )
1268{
1269    if( data->parents )
1270    {
1271        struct ParentState * parentState = data->parents->data;
1272
1273        switch( parentState->bencType )
1274        {
1275            case TR_TYPE_DICT:
1276            {
1277                const int i = parentState->childIndex++;
1278                if( !( i % 2 ) )
1279                    evbuffer_add( data->out, ": ", data->doIndent ? 2 : 1 );
1280                else {
1281                    const tr_bool isLast = parentState->childIndex == parentState->childCount;
1282                    if( !isLast ) {
1283                        evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
1284                        jsonIndent( data );
1285                    }
1286                }
1287                break;
1288            }
1289
1290            case TR_TYPE_LIST:
1291            {
1292                const tr_bool isLast = ++parentState->childIndex == parentState->childCount;
1293                if( !isLast ) {
1294                    evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
1295                    jsonIndent( data );
1296                }
1297                break;
1298            }
1299
1300            default:
1301                break;
1302        }
1303    }
1304}
1305
1306static void
1307jsonPushParent( struct jsonWalk * data,
1308                const tr_benc *   benc )
1309{
1310    struct ParentState * parentState = tr_new( struct ParentState, 1 );
1311
1312    parentState->bencType = benc->type;
1313    parentState->childIndex = 0;
1314    parentState->childCount = benc->val.l.count;
1315    tr_list_prepend( &data->parents, parentState );
1316}
1317
1318static void
1319jsonPopParent( struct jsonWalk * data )
1320{
1321    tr_free( tr_list_pop_front( &data->parents ) );
1322}
1323
1324static void
1325jsonIntFunc( const tr_benc * val,
1326             void *          vdata )
1327{
1328    struct jsonWalk * data = vdata;
1329
1330    evbuffer_add_printf( data->out, "%" PRId64, val->val.i );
1331    jsonChildFunc( data );
1332}
1333
1334static void
1335jsonBoolFunc( const tr_benc * val, void * vdata )
1336{
1337    struct jsonWalk * data = vdata;
1338
1339    if( val->val.b )
1340        evbuffer_add( data->out, "true", 4 );
1341    else
1342        evbuffer_add( data->out, "false", 5 );
1343
1344    jsonChildFunc( data );
1345}
1346
1347static void
1348jsonRealFunc( const tr_benc * val, void * vdata )
1349{
1350    struct jsonWalk * data = vdata;
1351    char locale[128];
1352
1353    if( fabs( val->val.d - (int)val->val.d ) < 0.00001 )
1354        evbuffer_add_printf( data->out, "%d", (int)val->val.d );
1355    else {
1356        /* json requires a '.' decimal point regardless of locale */
1357        tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
1358        setlocale( LC_NUMERIC, "POSIX" );
1359        evbuffer_add_printf( data->out, "%.4f", tr_truncd( val->val.d, 4 ) );
1360        setlocale( LC_NUMERIC, locale );
1361    }
1362
1363    jsonChildFunc( data );
1364}
1365
1366static void
1367jsonStringFunc( const tr_benc * val, void * vdata )
1368{
1369    struct jsonWalk * data = vdata;
1370    const unsigned char * it = (const unsigned char *) getStr(val);
1371    const unsigned char * end = it + val->val.s.len;
1372
1373    evbuffer_expand( data->out, val->val.s.len + 2 );
1374    evbuffer_add( data->out, "\"", 1 );
1375
1376    for( ; it!=end; ++it )
1377    {
1378        switch( *it )
1379        {
1380            case '\b': evbuffer_add( data->out, "\\b", 2 ); break;
1381            case '\f': evbuffer_add( data->out, "\\f", 2 ); break;
1382            case '\n': evbuffer_add( data->out, "\\n", 2 ); break;
1383            case '\r': evbuffer_add( data->out, "\\r", 2 ); break;
1384            case '\t': evbuffer_add( data->out, "\\t", 2 ); break;
1385            case '"': evbuffer_add( data->out, "\\\"", 2 ); break;
1386            case '\\': evbuffer_add( data->out, "\\\\", 2 ); break;
1387
1388            default:
1389                if( isascii( *it ) )
1390                    evbuffer_add( data->out, it, 1 );
1391                else {
1392                    const UTF8 * tmp = it;
1393                    UTF32        buf = 0;
1394                    UTF32 *      u32 = &buf;
1395                    ConversionResult result = ConvertUTF8toUTF32( &tmp, end, &u32, &buf + 1, 0 );
1396                    if((( result==conversionOK ) || (result==targetExhausted)) && (tmp!=it)) {
1397                        evbuffer_add_printf( data->out, "\\u%04x", (unsigned int)buf );
1398                        it = tmp - 1;
1399                    }
1400                }
1401        }
1402    }
1403    evbuffer_add( data->out, "\"", 1 );
1404    jsonChildFunc( data );
1405}
1406
1407static void
1408jsonDictBeginFunc( const tr_benc * val,
1409                   void *          vdata )
1410{
1411    struct jsonWalk * data = vdata;
1412
1413    jsonPushParent( data, val );
1414    evbuffer_add( data->out, "{", 1 );
1415    if( val->val.l.count )
1416        jsonIndent( data );
1417}
1418
1419static void
1420jsonListBeginFunc( const tr_benc * val,
1421                   void *          vdata )
1422{
1423    const size_t      nChildren = tr_bencListSize( val );
1424    struct jsonWalk * data = vdata;
1425
1426    jsonPushParent( data, val );
1427    evbuffer_add( data->out, "[", 1 );
1428    if( nChildren )
1429        jsonIndent( data );
1430}
1431
1432static void
1433jsonContainerEndFunc( const tr_benc * val,
1434                      void *          vdata )
1435{
1436    struct jsonWalk * data = vdata;
1437    int               emptyContainer = FALSE;
1438
1439    jsonPopParent( data );
1440    if( !emptyContainer )
1441        jsonIndent( data );
1442    if( tr_bencIsDict( val ) )
1443        evbuffer_add( data->out, "}", 1 );
1444    else /* list */
1445        evbuffer_add( data->out, "]", 1 );
1446    jsonChildFunc( data );
1447}
1448
1449static const struct WalkFuncs jsonWalkFuncs = { jsonIntFunc,
1450                                                jsonBoolFunc,
1451                                                jsonRealFunc,
1452                                                jsonStringFunc,
1453                                                jsonDictBeginFunc,
1454                                                jsonListBeginFunc,
1455                                                jsonContainerEndFunc };
1456
1457/***
1458****
1459***/
1460
1461static void
1462tr_bencListCopy( tr_benc * target, const tr_benc * src )
1463{
1464    int i = 0;
1465    const tr_benc * val;
1466
1467    while(( val = tr_bencListChild( (tr_benc*)src, i++ )))
1468    {
1469       if( tr_bencIsBool( val ) )
1470       {
1471           tr_bool boolVal = 0;
1472           tr_bencGetBool( val, &boolVal );
1473           tr_bencListAddBool( target, boolVal );
1474       }
1475       else if( tr_bencIsReal( val ) )
1476       {
1477           double realVal = 0;
1478           tr_bencGetReal( val, &realVal );
1479           tr_bencListAddReal( target, realVal );
1480       }
1481       else if( tr_bencIsInt( val ) )
1482       {
1483           int64_t intVal = 0;
1484           tr_bencGetInt( val, &intVal );
1485           tr_bencListAddInt( target, intVal );
1486       }
1487       else if( tr_bencIsString( val ) )
1488       {
1489           tr_bencListAddRaw( target, (const uint8_t*)getStr( val ), val->val.s.len );
1490       }
1491       else if( tr_bencIsDict( val ) )
1492       {
1493           tr_bencMergeDicts( tr_bencListAddDict( target, 0 ), val );
1494       }
1495       else if ( tr_bencIsList( val ) )
1496       {
1497           tr_bencListCopy( tr_bencListAddList( target, 0 ), val );
1498       }
1499       else
1500       {
1501           tr_err( "tr_bencListCopy skipping item" );
1502       }
1503   }
1504}
1505
1506static size_t
1507tr_bencDictSize( const tr_benc * dict )
1508{
1509    size_t count = 0;
1510
1511    if( tr_bencIsDict( dict ) )
1512        count = dict->val.l.count / 2;
1513
1514    return count;
1515}
1516
1517tr_bool
1518tr_bencDictChild( tr_benc * dict, size_t n, const char ** key, tr_benc ** val )
1519{
1520    tr_bool success = 0;
1521
1522    assert( tr_bencIsDict( dict ) );
1523
1524    if( tr_bencIsDict( dict ) && (n*2)+1 <= dict->val.l.count )
1525    {
1526        tr_benc * k = dict->val.l.vals + (n*2);
1527        tr_benc * v = dict->val.l.vals + (n*2) + 1;
1528        if(( success = tr_bencGetStr( k, key ) && isSomething( v )))
1529            *val = v;
1530    }
1531
1532    return success;
1533}
1534
1535void
1536tr_bencMergeDicts( tr_benc * target, const tr_benc * source )
1537{
1538    size_t i;
1539    const size_t sourceCount = tr_bencDictSize( source );
1540
1541    assert( tr_bencIsDict( target ) );
1542    assert( tr_bencIsDict( source ) );
1543
1544    for( i=0; i<sourceCount; ++i )
1545    {
1546        const char * key;
1547        tr_benc * val;
1548        tr_benc * t;
1549
1550        if( tr_bencDictChild( (tr_benc*)source, i, &key, &val ) )
1551        {
1552            if( tr_bencIsBool( val ) )
1553            {
1554                tr_bool boolVal;
1555                tr_bencGetBool( val, &boolVal );
1556                tr_bencDictAddBool( target, key, boolVal );
1557            }
1558            else if( tr_bencIsReal( val ) )
1559            {
1560                double realVal = 0;
1561                tr_bencGetReal( val, &realVal );
1562                tr_bencDictAddReal( target, key, realVal );
1563            }
1564            else if( tr_bencIsInt( val ) )
1565            {
1566                int64_t intVal = 0;
1567                tr_bencGetInt( val, &intVal );
1568                tr_bencDictAddInt( target, key, intVal );
1569            }
1570            else if( tr_bencIsString( val ) )
1571            {
1572                tr_bencDictAddRaw( target, key, getStr( val ), val->val.s.len );
1573            }
1574            else if( tr_bencIsDict( val ) && tr_bencDictFindDict( target, key, &t ) )
1575            {
1576                tr_bencMergeDicts( t, val );
1577            }
1578            else if( tr_bencIsList( val ) )
1579            {
1580                if( tr_bencDictFind( target, key ) == NULL )
1581                {
1582                    tr_bencListCopy( tr_bencDictAddList( target, key, tr_bencListSize( val ) ), val );
1583                }
1584            }
1585            else
1586            {
1587                tr_dbg( "tr_bencMergeDicts skipping \"%s\"", key );
1588            }
1589        }
1590    }
1591}
1592
1593/***
1594****
1595***/
1596
1597void
1598tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode, struct evbuffer * buf )
1599{
1600    evbuffer_drain( buf, EVBUFFER_LENGTH( buf ) );
1601    evbuffer_expand( buf, 4096 ); /* alloc a little memory to start off with */
1602
1603    switch( mode )
1604    {
1605        case TR_FMT_BENC:
1606            bencWalk( top, &saveFuncs, buf );
1607            break;
1608
1609        case TR_FMT_JSON:
1610        case TR_FMT_JSON_LEAN: {
1611            struct jsonWalk data;
1612            data.doIndent = mode==TR_FMT_JSON;
1613            data.out = buf;
1614            data.parents = NULL;
1615            bencWalk( top, &jsonWalkFuncs, &data );
1616            if( EVBUFFER_LENGTH( buf ) )
1617                evbuffer_add_printf( buf, "\n" );
1618            break;
1619        }
1620    }
1621}
1622
1623char*
1624tr_bencToStr( const tr_benc * top, tr_fmt_mode mode, int * len )
1625{
1626    char * ret;
1627    struct evbuffer * buf = evbuffer_new( );
1628    tr_bencToBuf( top, mode, buf );
1629    ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
1630    if( len != NULL )
1631        *len = (int) EVBUFFER_LENGTH( buf );
1632    evbuffer_free( buf );
1633    return ret;
1634}
1635
1636/* portability wrapper for mkstemp(). */
1637static int
1638tr_mkstemp( char * template )
1639{
1640#ifdef WIN32
1641    const int flags = O_RDWR | O_BINARY | O_CREAT | O_EXCL | _O_SHORT_LIVED;
1642    const mode_t mode = _S_IREAD | _S_IWRITE;
1643    mktemp( template );
1644    return open( template, flags, mode );
1645#else
1646    return mkstemp( template );
1647#endif
1648}
1649
1650/* portability wrapper for fsync(). */
1651static void
1652tr_fsync( int fd )
1653{
1654#ifdef WIN32
1655    _commit( fd );
1656#else
1657    fsync( fd );
1658#endif
1659}
1660
1661int
1662tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
1663{
1664    char * tmp;
1665    int fd;
1666    int err = 0;
1667    char buf[TR_PATH_MAX];
1668
1669    /* follow symlinks to find the "real" file, to make sure the temporary
1670     * we build with tr_mkstemp() is created on the right partition */
1671    if( tr_realpath( filename, buf ) != NULL )
1672        filename = buf;
1673
1674    /* if the file already exists, try to move it out of the way & keep it as a backup */
1675    tmp = tr_strdup_printf( "%s.tmp.XXXXXX", filename );
1676    fd = tr_mkstemp( tmp );
1677    if( fd >= 0 )
1678    {
1679        int len;
1680        char * str = tr_bencToStr( top, mode, &len );
1681        tr_dbg( "Writing %d bytes to temporary file \"%s\"", (int)len, tmp );
1682
1683        if( write( fd, str, len ) == (ssize_t)len )
1684        {
1685            struct stat sb;
1686            const tr_bool already_exists = !stat( filename, &sb ) && S_ISREG( sb.st_mode );
1687
1688            tr_fsync( fd );
1689            tr_close_file( fd );
1690
1691            if( !already_exists || !unlink( filename ) )
1692            {
1693                tr_dbg( "Renaming \"%s\" as \"%s\"", tmp, filename );
1694
1695                if( !rename( tmp, filename ) )
1696                {
1697                    tr_inf( _( "Saved \"%s\"" ), filename );
1698                }
1699                else
1700                {
1701                    err = errno;
1702                    tr_err( _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
1703                    unlink( tmp );
1704                }
1705            }
1706            else
1707            {
1708                err = errno;
1709                tr_err( _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
1710                unlink( tmp );
1711            }
1712        }
1713        else
1714        {
1715            err = errno;
1716            tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
1717            tr_close_file( fd );
1718            unlink( tmp );
1719        }
1720
1721        tr_free( str );
1722    }
1723    else
1724    {
1725        err = errno;
1726        tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
1727    }
1728
1729    tr_free( tmp );
1730    return err;
1731}
1732
1733/***
1734****
1735***/
1736
1737int
1738tr_bencLoadFile( tr_benc * setme, tr_fmt_mode mode, const char * filename )
1739{
1740    int err;
1741    size_t contentLen;
1742    uint8_t * content;
1743
1744    content = tr_loadFile( filename, &contentLen );
1745    if( !content && errno )
1746        err = errno;
1747    else if( !content )
1748        err = ENODATA;
1749    else {
1750        if( mode == TR_FMT_BENC )
1751            err = tr_bencLoad( content, contentLen, setme, NULL );
1752        else
1753            err = tr_jsonParse( filename, content, contentLen, setme, NULL );
1754    }
1755
1756    tr_free( content );
1757    return err;
1758}
1759
Note: See TracBrowser for help on using the repository browser.