source: trunk/libtransmission/bencode.c @ 11079

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

(trunk libT) #3462 "minor json formatting optimization: omit unnecessary floating-point precision" -- done.

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