source: trunk/libtransmission/bencode.c @ 6073

Last change on this file since 6073 was 6073, checked in by charles, 13 years ago

#800 initial support for GetRight?-style fetching of data through http and ftp servers specified in the .torrent's "url-list" tag

  • Property svn:keywords set to Date Rev Author Id
File size: 31.0 KB
Line 
1/******************************************************************************
2 * $Id: bencode.c 6073 2008-06-07 21:26:41Z charles $
3 *
4 * Copyright (c) 2005-2008 Transmission authors and contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *****************************************************************************/
24
25#include <assert.h>
26#include <ctype.h> /* isdigit, isprint, isspace */
27#include <errno.h>
28#include <stdarg.h>
29#include <stdio.h>
30#include <stdlib.h>
31
32#include <event.h> /* evbuffer */
33
34#include "transmission.h"
35#include "bencode.h"
36#include "list.h"
37#include "ptrarray.h"
38#include "utils.h" /* tr_new(), tr_free() */
39
40const tr_benc BENC_NULL = { 0, { 0 } };
41
42/**
43***
44**/
45
46int
47tr_bencIsType( const tr_benc * val, int type )
48{
49    return ( ( val != NULL ) && ( val->type == type ) );
50}
51
52static int
53isContainer( const tr_benc * val )
54{
55    return tr_bencIsList(val) || tr_bencIsDict(val);
56}
57static int
58isSomething( const tr_benc * val )
59{
60    return isContainer(val) || tr_bencIsInt(val) || tr_bencIsString(val);
61}
62
63/***
64****  tr_bencParse()
65****  tr_bencLoad()
66***/
67
68/**
69 * The initial i and trailing e are beginning and ending delimiters.
70 * You can have negative numbers such as i-3e. You cannot prefix the
71 * number with a zero such as i04e. However, i0e is valid. 
72 * Example: i3e represents the integer "3"
73 * NOTE: The maximum number of bit of this integer is unspecified,
74 * but to handle it as a signed 64bit integer is mandatory to handle
75 * "large files" aka .torrent for more that 4Gbyte
76 */
77int
78tr_bencParseInt( const uint8_t  * buf,
79                 const uint8_t  * bufend,
80                 const uint8_t ** setme_end, 
81                 int64_t        * setme_val )
82{
83    int err = TR_OK;
84    char * endptr;
85    const void * begin;
86    const void * end;
87    int64_t val;
88
89    if( buf >= bufend )
90        return TR_ERROR;
91    if( *buf != 'i' )
92        return TR_ERROR;
93
94    begin = buf + 1;
95    end = memchr( begin, 'e', (bufend-buf)-1 );
96    if( end == NULL )
97        return TR_ERROR;
98
99    errno = 0;
100    val = strtoll( begin, &endptr, 10 );
101    if( errno || ( endptr != end ) ) /* incomplete parse */
102        err = TR_ERROR;
103    else if( val && *(const char*)begin=='0' ) /* no leading zeroes! */
104        err = TR_ERROR;
105    else {
106        *setme_end = end + 1;
107        *setme_val = val;
108    }
109
110    return err;
111}
112
113
114/**
115 * Byte strings are encoded as follows:
116 * <string length encoded in base ten ASCII>:<string data>
117 * Note that there is no constant beginning delimiter, and no ending delimiter.
118 * Example: 4:spam represents the string "spam"
119 */
120int
121tr_bencParseStr( const uint8_t  * buf,
122                 const uint8_t  * bufend,
123                 const uint8_t ** setme_end,
124                 uint8_t       ** setme_str,
125                 size_t         * setme_strlen )
126{
127    size_t len;
128    const void * end;
129    char * endptr;
130
131    if( buf >= bufend )
132        return TR_ERROR;
133
134    if( !isdigit( *buf  ) )
135        return TR_ERROR;
136
137    end = memchr( buf, ':', bufend-buf );
138    if( end == NULL )
139        return TR_ERROR;
140
141    errno = 0;
142    len = strtoul( (const char*)buf, &endptr, 10 );
143    if( errno || endptr!=end )
144        return TR_ERROR;
145
146    if( (const uint8_t*)end + 1 + len > bufend )
147        return TR_ERROR;
148
149    *setme_end = end + 1 + len;
150    *setme_str = (uint8_t*) tr_strndup( end + 1, len );
151    *setme_strlen = len;
152    return TR_OK;
153}
154
155/* setting to 1 to help expose bugs with tr_bencListAdd and tr_bencDictAdd */
156#define LIST_SIZE 8 /* number of items to increment list/dict buffer by */
157
158static int
159makeroom( tr_benc * val, int count )
160{
161    assert( TYPE_LIST == val->type || TYPE_DICT == val->type );
162
163    if( val->val.l.count + count > val->val.l.alloc )
164    {
165        /* We need a bigger boat */
166        const int len = val->val.l.alloc + count +
167            ( count % LIST_SIZE ? LIST_SIZE - ( count % LIST_SIZE ) : 0 );
168        void * new = realloc( val->val.l.vals, len * sizeof( tr_benc ) );
169        if( NULL == new )
170            return 1;
171
172        val->val.l.alloc = len;
173        val->val.l.vals  = new;
174    }
175
176    return 0;
177}
178
179static tr_benc*
180getNode( tr_benc * top, tr_ptrArray * parentStack, int type )
181{
182    tr_benc * parent;
183
184    assert( top != NULL );
185    assert( parentStack != NULL );
186
187    if( tr_ptrArrayEmpty( parentStack ) )
188        return top;
189
190    parent = tr_ptrArrayBack( parentStack );
191    assert( parent != NULL );
192
193    /* dictionary keys must be strings */
194    if( ( parent->type == TYPE_DICT )
195        && ( type != TYPE_STR )
196        && ( ! ( parent->val.l.count % 2 ) ) )
197        return NULL;
198
199    makeroom( parent, 1 );
200    return parent->val.l.vals + parent->val.l.count++;
201}
202
203/**
204 * This function's previous recursive implementation was
205 * easier to read, but was vulnerable to a smash-stacking
206 * attack via maliciously-crafted bencoded data. (#667)
207 */
208int
209tr_bencParse( const void     * buf_in,
210              const void     * bufend_in,
211              tr_benc        * top,
212              const uint8_t ** setme_end )
213{
214    int err;
215    const uint8_t * buf = buf_in;
216    const uint8_t * bufend = bufend_in;
217    tr_ptrArray * parentStack = tr_ptrArrayNew( );
218
219    tr_bencInit( top, 0 );
220
221    while( buf != bufend )
222    {
223        if( buf > bufend ) /* no more text to parse... */
224            return 1;
225
226        if( *buf=='i' ) /* int */
227        {
228            int64_t val;
229            const uint8_t * end;
230            int err;
231            tr_benc * node;
232
233            if(( err = tr_bencParseInt( buf, bufend, &end, &val )))
234                return err;
235
236            node = getNode( top, parentStack, TYPE_INT );
237            if( !node )
238                return TR_ERROR;
239
240            tr_bencInitInt( node, val );
241            buf = end;
242
243            if( tr_ptrArrayEmpty( parentStack ) )
244                break;
245        }
246        else if( *buf=='l' ) /* list */
247        {
248            tr_benc * node = getNode( top, parentStack, TYPE_LIST );
249            if( !node )
250                return TR_ERROR;
251            tr_bencInit( node, TYPE_LIST );
252            tr_ptrArrayAppend( parentStack, node );
253            ++buf;
254        }
255        else if( *buf=='d' ) /* dict */
256        {
257            tr_benc * node = getNode( top, parentStack, TYPE_DICT );
258            if( !node )
259                return TR_ERROR;
260            tr_bencInit( node, TYPE_DICT );
261            tr_ptrArrayAppend( parentStack, node );
262            ++buf;
263        }
264        else if( *buf=='e' ) /* end of list or dict */
265        {
266            tr_benc * node;
267            ++buf;
268            if( tr_ptrArrayEmpty( parentStack ) )
269                return TR_ERROR;
270
271            node = tr_ptrArrayBack( parentStack );
272            if( tr_bencIsDict( node ) && ( node->val.l.count % 2 ) )
273                return TR_ERROR; /* odd # of children in dict */
274
275            tr_ptrArrayPop( parentStack );
276            if( tr_ptrArrayEmpty( parentStack ) )
277                break;
278        }
279        else if( isdigit(*buf) ) /* string? */
280        {
281            const uint8_t * end;
282            uint8_t * str;
283            size_t str_len;
284            int err;
285            tr_benc * node;
286
287            if(( err = tr_bencParseStr( buf, bufend, &end, &str, &str_len )))
288                return err;
289
290            node = getNode( top, parentStack, TYPE_STR );
291            if( !node )
292                return TR_ERROR;
293
294            tr_bencInitStr( node, str, str_len, 0 );
295            buf = end;
296
297            if( tr_ptrArrayEmpty( parentStack ) )
298                break;
299        }
300        else /* invalid bencoded text... march past it */
301        {
302            ++buf;
303        }
304    }
305
306    err = !isSomething( top ) || !tr_ptrArrayEmpty( parentStack );
307
308    if( !err && ( setme_end != NULL ) )
309        *setme_end = buf;
310
311    tr_ptrArrayFree( parentStack, NULL );
312    return err;
313}
314
315int
316tr_bencLoad( const void  * buf_in,
317             int           buflen,
318             tr_benc     * setme_benc,
319             char       ** setme_end )
320{
321    const uint8_t * buf = buf_in;
322    const uint8_t * end;
323    const int ret = tr_bencParse( buf, buf+buflen, setme_benc, &end );
324    if( !ret && setme_end )
325        *setme_end = (char*) end;
326    return ret;
327}
328
329/***
330****
331***/
332
333static int
334dictIndexOf( tr_benc * val, const char * key )
335{
336    int len, ii;
337
338    if( !tr_bencIsDict( val ) )
339        return -1;
340
341    len = strlen( key );
342   
343    for( ii = 0; ii + 1 < val->val.l.count; ii += 2 )
344    {
345        if( TYPE_STR  != val->val.l.vals[ii].type ||
346            len       != val->val.l.vals[ii].val.s.i ||
347            0 != memcmp( val->val.l.vals[ii].val.s.s, key, len ) )
348        {
349            continue;
350        }
351        return ii;
352    }
353
354    return -1;
355}
356
357tr_benc *
358tr_bencDictFind( tr_benc * val, const char * key )
359{
360    const int i = dictIndexOf( val, key );
361    return i<0 ? NULL : &val->val.l.vals[i+1];
362}
363
364tr_benc*
365tr_bencDictFindType( tr_benc * val, const char * key, int type )
366{
367    tr_benc * ret = tr_bencDictFind( val, key );
368    return ret && ret->type == type ? ret : NULL;
369}
370
371tr_benc *
372tr_bencDictFindFirst( tr_benc * val, ... )
373{
374    const char * key;
375    tr_benc * ret;
376    va_list      ap;
377
378    ret = NULL;
379    va_start( ap, val );
380    while(( key = va_arg( ap, const char * )))
381        if(( ret = tr_bencDictFind( val, key )))
382            break;
383    va_end( ap );
384
385    return ret;
386}
387
388int
389tr_bencListSize( const tr_benc * list )
390{
391    return tr_bencIsList( list ) ? list->val.l.count : 0;
392}
393
394tr_benc*
395tr_bencListChild( tr_benc * val, int i )
396{
397    tr_benc * ret = NULL;
398    if( tr_bencIsList( val ) && ( i >= 0 ) && ( i < val->val.l.count ) )
399        ret = val->val.l.vals + i;
400    return ret;
401}
402
403int
404tr_bencGetInt ( const tr_benc * val, int64_t * setme )
405{
406    const int success = tr_bencIsInt( val );
407    if( success )
408        *setme = val->val.i ;
409    return success;
410}
411
412int
413tr_bencGetStr( const tr_benc * val, const char ** setme )
414{
415    const int success = tr_bencIsString( val );
416    if( success )
417        *setme = val->val.s.s;
418    return success;
419}
420
421int
422tr_bencDictFindInt( tr_benc * dict, const char * key, int64_t * setme )
423{
424    int found = FALSE;
425    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_INT );
426    if( child )
427        found = tr_bencGetInt( child, setme );
428    return found;
429}
430
431int
432tr_bencDictFindDouble( tr_benc * dict, const char * key, double * setme )
433{
434    const char * str;
435    const int success = tr_bencDictFindStr( dict, key, &str );
436    if( success )
437        *setme = strtod( str, NULL );
438    return success;
439}
440
441int
442tr_bencDictFindList( tr_benc * dict, const char * key, tr_benc ** setme )
443{
444    int found = FALSE;
445    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_LIST );
446    if( child ) {
447        *setme = child;
448        found = TRUE;
449    }
450    return found;
451}
452
453int
454tr_bencDictFindDict( tr_benc * dict, const char * key, tr_benc ** setme )
455{
456    int found = FALSE;
457    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_DICT );
458    if( child ) {
459        *setme = child;
460        found = TRUE;
461    }
462    return found;
463}
464
465int
466tr_bencDictFindStr( tr_benc * dict, const char * key, const char ** setme )
467{
468    int found = FALSE;
469    tr_benc * child = tr_bencDictFindType( dict, key, TYPE_STR );
470    if( child ) {
471        *setme = child->val.s.s;
472        found = TRUE;
473    }
474    return found;
475}
476
477/***
478****
479***/
480
481void
482_tr_bencInitStr( tr_benc * val, char * str, int len, int nofree )
483{
484    tr_bencInit( val, TYPE_STR );
485    val->val.s.s      = str;
486    val->val.s.nofree = nofree;
487    if( 0 >= len )
488    {
489        len = ( NULL == str ? 0 : strlen( str ) );
490    }
491    val->val.s.i = len;
492}
493
494void
495tr_bencInitRaw( tr_benc * val, const void * src, size_t byteCount )
496{
497    tr_bencInit( val, TYPE_STR );
498    val->val.s.i = byteCount;
499    val->val.s.s = tr_memdup( src, byteCount );
500    val->val.s.nofree = 0;
501}
502
503int
504tr_bencInitStrDup( tr_benc * val, const char * str )
505{
506    char * newStr = tr_strdup( str );
507    if( newStr == NULL )
508        return 1;
509
510    _tr_bencInitStr( val, newStr, 0, 0 );
511    return 0;
512}
513
514void
515tr_bencInitInt( tr_benc * val, int64_t num )
516{
517    tr_bencInit( val, TYPE_INT );
518    val->val.i = num;
519}
520
521int
522tr_bencInitList( tr_benc * val, int reserveCount )
523{
524    tr_bencInit( val, TYPE_LIST );
525    return tr_bencListReserve( val, reserveCount );
526}
527
528int
529tr_bencListReserve( tr_benc * val, int count )
530{
531    assert( tr_bencIsList( val ) );
532    return makeroom( val, count );
533}
534
535int
536tr_bencInitDict( tr_benc * val, int reserveCount )
537{
538    tr_bencInit( val, TYPE_DICT );
539    return tr_bencDictReserve( val, reserveCount );
540}
541
542int
543tr_bencDictReserve( tr_benc * val, int count )
544{
545    assert( tr_bencIsDict( val ) );
546    return makeroom( val, count * 2 );
547}
548
549tr_benc *
550tr_bencListAdd( tr_benc * list )
551{
552    tr_benc * item;
553
554    assert( tr_bencIsList( list ) );
555
556    if( list->val.l.count == list->val.l.alloc )
557        tr_bencListReserve( list, LIST_SIZE );
558
559    assert( list->val.l.count < list->val.l.alloc );
560
561    item = &list->val.l.vals[list->val.l.count];
562    list->val.l.count++;
563    tr_bencInit( item, TYPE_INT );
564
565    return item;
566}
567tr_benc *
568tr_bencListAddInt( tr_benc * list, int64_t val )
569{
570    tr_benc * node = tr_bencListAdd( list );
571    tr_bencInitInt( node, val );
572    return node;
573}
574tr_benc *
575tr_bencListAddStr( tr_benc * list, const char * val )
576{
577    tr_benc * node = tr_bencListAdd( list );
578    tr_bencInitStrDup( node, val );
579    return node;
580}
581tr_benc*
582tr_bencListAddList( tr_benc * list, int reserveCount )
583{
584    tr_benc * child = tr_bencListAdd( list );
585    tr_bencInitList( child, reserveCount );
586    return child;
587}
588tr_benc*
589tr_bencListAddDict( tr_benc * list, int reserveCount )
590{
591    tr_benc * child = tr_bencListAdd( list );
592    tr_bencInitDict( child, reserveCount );
593    return child;
594}
595
596tr_benc *
597tr_bencDictAdd( tr_benc * dict, const char * key )
598{
599    tr_benc * keyval, * itemval;
600
601    assert( tr_bencIsDict( dict ) );
602    if( dict->val.l.count + 2 > dict->val.l.alloc )
603        makeroom( dict, 2 );
604    assert( dict->val.l.count + 2 <= dict->val.l.alloc );
605
606    keyval = dict->val.l.vals + dict->val.l.count++;
607    tr_bencInitStrDup( keyval, key );
608
609    itemval = dict->val.l.vals + dict->val.l.count++;
610    tr_bencInit( itemval, TYPE_INT );
611
612    return itemval;
613}
614tr_benc*
615tr_bencDictAddInt( tr_benc * dict, const char * key, int64_t val )
616{
617    tr_benc * child = tr_bencDictAdd( dict, key );
618    tr_bencInitInt( child, val );
619    return child;
620}
621tr_benc*
622tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
623{
624    tr_benc * child = tr_bencDictAdd( dict, key );
625    tr_bencInitStrDup( child, val );
626    return child;
627}
628tr_benc*
629tr_bencDictAddDouble( tr_benc * dict, const char * key, double d )
630{
631    char buf[128];
632    snprintf( buf, sizeof( buf ), "%f", d );
633    return tr_bencDictAddStr( dict, key, buf );
634}
635tr_benc*
636tr_bencDictAddList( tr_benc * dict, const char * key, int reserveCount )
637{
638    tr_benc * child = tr_bencDictAdd( dict, key );
639    tr_bencInitList( child, reserveCount );
640    return child;
641}
642tr_benc*
643tr_bencDictAddDict( tr_benc * dict, const char * key, int reserveCount )
644{
645    tr_benc * child = tr_bencDictAdd( dict, key );
646    tr_bencInitDict( child, reserveCount );
647    return child;
648}
649tr_benc*
650tr_bencDictAddRaw( tr_benc * dict, const char * key, const void * src, size_t len )
651{
652    tr_benc * child = tr_bencDictAdd( dict, key );
653    tr_bencInitRaw( child, src, len );
654    return child;
655}
656
657int
658tr_bencDictRemove( tr_benc * dict, const char * key )
659{
660    int i = dictIndexOf( dict, key );
661    if( i >= 0 )
662    {
663        const int n = dict->val.l.count;
664        tr_bencFree( &dict->val.l.vals[i] );
665        tr_bencFree( &dict->val.l.vals[i+1] );
666        if( i + 2 < n )
667        {
668            dict->val.l.vals[i]   = dict->val.l.vals[n-2];
669            dict->val.l.vals[i+1] = dict->val.l.vals[n-1];
670        }
671        dict->val.l.count -= 2;
672    }
673    return i >= 0; /* return true if found */
674}
675
676
677/***
678****  BENC WALKING
679***/
680
681struct KeyIndex
682{
683    const char * key;
684    int index;
685};
686
687static int
688compareKeyIndex( const void * va, const void * vb )
689{
690    const struct KeyIndex * a = va;
691    const struct KeyIndex * b = vb;
692    return strcmp( a->key, b->key );
693}
694
695struct SaveNode
696{
697    const tr_benc * val;
698    int valIsVisited;
699    int childCount;
700    int childIndex;
701    int * children;
702};
703
704static struct SaveNode*
705nodeNewDict( const tr_benc * val )
706{
707    int i, j;
708    int nKeys;
709    struct SaveNode * node;
710    struct KeyIndex * indices;
711
712    assert( tr_bencIsDict( val ) );
713
714    nKeys = val->val.l.count / 2;
715    node = tr_new0( struct SaveNode, 1 );
716    node->val = val;
717    node->children = tr_new0( int, nKeys * 2 );
718
719    /* ugh, a dictionary's children have to be sorted by key... */
720    indices = tr_new( struct KeyIndex, nKeys );
721    for( i=j=0; i<(nKeys*2); i+=2, ++j ) {
722        indices[j].key = val->val.l.vals[i].val.s.s;
723        indices[j].index = i;
724    }
725    qsort( indices, j, sizeof(struct KeyIndex), compareKeyIndex );
726    for( i=0; i<j; ++i ) {
727        const int index = indices[i].index;
728        node->children[ node->childCount++ ] = index;
729        node->children[ node->childCount++ ] = index + 1;
730    }
731
732    assert( node->childCount == nKeys * 2 );
733    tr_free( indices );
734    return node;
735}
736
737static struct SaveNode*
738nodeNewList( const tr_benc * val )
739{
740    int i, n;
741    struct SaveNode * node;
742
743    assert( tr_bencIsList( val ) );
744
745    n = val->val.l.count;
746    node = tr_new0( struct SaveNode, 1 );
747    node->val = val;
748    node->childCount = n;
749    node->children = tr_new0( int, n );
750    for( i=0; i<n; ++i ) /* a list's children don't need to be reordered */
751        node->children[i] = i;
752
753    return node;
754}
755
756static struct SaveNode*
757nodeNewLeaf( const tr_benc * val )
758{
759    struct SaveNode * node;
760
761    assert( !isContainer( val ) );
762
763    node = tr_new0( struct SaveNode, 1 );
764    node->val = val;
765    return node;
766}
767
768static struct SaveNode*
769nodeNew( const tr_benc * val )
770{
771    struct SaveNode * node;
772
773    if( tr_bencIsList( val ) )
774        node = nodeNewList( val );
775    else if( tr_bencIsDict( val ) )
776        node = nodeNewDict( val );
777    else
778        node = nodeNewLeaf( val );
779
780    return node;
781}
782
783typedef void (*BencWalkFunc)( const tr_benc * val, void * user_data );
784
785struct WalkFuncs
786{
787    BencWalkFunc intFunc;
788    BencWalkFunc stringFunc;
789    BencWalkFunc dictBeginFunc;
790    BencWalkFunc listBeginFunc;
791    BencWalkFunc containerEndFunc;
792};
793
794/**
795 * This function's previous recursive implementation was
796 * easier to read, but was vulnerable to a smash-stacking
797 * attack via maliciously-crafted bencoded data. (#667)
798 */
799static void
800bencWalk( const tr_benc      * top,
801          struct WalkFuncs   * walkFuncs,
802          void               * user_data )
803{
804    tr_ptrArray * stack = tr_ptrArrayNew( );
805    tr_ptrArrayAppend( stack, nodeNew( top ) );
806
807    while( !tr_ptrArrayEmpty( stack ) )
808    {
809        struct SaveNode * node = tr_ptrArrayBack( stack );
810        const tr_benc * val;
811
812        if( !node->valIsVisited )
813        {
814            val = node->val;
815            node->valIsVisited = TRUE;
816        }
817        else if( node->childIndex < node->childCount )
818        {
819            const int index = node->children[ node->childIndex++ ];
820            val = node->val->val.l.vals +  index;
821        }
822        else /* done with this node */
823        {
824            if( isContainer( node->val ) )
825                walkFuncs->containerEndFunc( node->val, user_data );
826            tr_ptrArrayPop( stack );
827            tr_free( node->children );
828            tr_free( node );
829            continue;
830        }
831
832        if( val ) switch( val->type )
833        {
834            case TYPE_INT:
835                walkFuncs->intFunc( val, user_data );
836                break;
837
838            case TYPE_STR:
839                walkFuncs->stringFunc( val, user_data );
840                break;
841
842            case TYPE_LIST:
843                if( val != node->val )
844                    tr_ptrArrayAppend( stack, nodeNew( val ) );
845                else
846                    walkFuncs->listBeginFunc( val, user_data );
847                break;
848
849            case TYPE_DICT:
850                if( val != node->val )
851                    tr_ptrArrayAppend( stack, nodeNew( val ) );
852                else
853                    walkFuncs->dictBeginFunc( val, user_data );
854                break;
855
856            default:
857                /* did caller give us an uninitialized val? */
858                tr_err( _( "Invalid metadata" ) );
859                break;
860        }
861    }
862
863    tr_ptrArrayFree( stack, NULL );
864}
865
866/****
867*****
868****/
869
870static void
871saveIntFunc( const tr_benc * val, void * evbuf )
872{
873    evbuffer_add_printf( evbuf, "i%"PRId64"e", val->val.i );
874}
875static void
876saveStringFunc( const tr_benc * val, void * vevbuf )
877{
878    struct evbuffer * evbuf = vevbuf;
879    evbuffer_add_printf( evbuf, "%d:", val->val.s.i );
880    evbuffer_add( evbuf, val->val.s.s, val->val.s.i );
881}
882static void
883saveDictBeginFunc( const tr_benc * val UNUSED, void * evbuf )
884{
885    evbuffer_add_printf( evbuf, "d" );
886}
887static void
888saveListBeginFunc( const tr_benc * val UNUSED, void * evbuf )
889{
890    evbuffer_add_printf( evbuf, "l" );
891}
892static void
893saveContainerEndFunc( const tr_benc * val UNUSED, void * evbuf )
894{
895    evbuffer_add_printf( evbuf, "e" );
896}
897char*
898tr_bencSave( const tr_benc * top, int * len )
899{
900    char * ret;
901    struct WalkFuncs walkFuncs;
902    struct evbuffer * out = evbuffer_new( );
903
904    walkFuncs.intFunc = saveIntFunc;
905    walkFuncs.stringFunc = saveStringFunc;
906    walkFuncs.dictBeginFunc = saveDictBeginFunc;
907    walkFuncs.listBeginFunc = saveListBeginFunc;
908    walkFuncs.containerEndFunc = saveContainerEndFunc;
909    bencWalk( top, &walkFuncs, out );
910   
911    if( len != NULL )
912        *len = EVBUFFER_LENGTH( out );
913    ret = tr_strndup( (char*) EVBUFFER_DATA( out ), EVBUFFER_LENGTH( out ) );
914    evbuffer_free( out );
915    return ret;
916}
917
918/***
919****
920***/
921
922static void
923freeDummyFunc( const tr_benc * val UNUSED, void * buf UNUSED  )
924{
925}
926static void
927freeStringFunc( const tr_benc * val, void * freeme )
928{
929    if( !val->val.s.nofree )
930        tr_ptrArrayAppend( freeme, val->val.s.s );
931}
932static void
933freeContainerBeginFunc( const tr_benc * val, void * freeme )
934{
935    tr_ptrArrayAppend( freeme, val->val.l.vals );
936}
937void
938tr_bencFree( tr_benc * val )
939{
940    if( val && val->type )
941    {
942        tr_ptrArray * freeme = tr_ptrArrayNew( );
943        struct WalkFuncs walkFuncs;
944
945        walkFuncs.intFunc = freeDummyFunc;
946        walkFuncs.stringFunc = freeStringFunc;
947        walkFuncs.dictBeginFunc = freeContainerBeginFunc;
948        walkFuncs.listBeginFunc = freeContainerBeginFunc;
949        walkFuncs.containerEndFunc = freeDummyFunc;
950        bencWalk( val, &walkFuncs, freeme );
951
952        tr_ptrArrayFree( freeme, tr_free );
953    }
954}
955
956/***
957****
958***/
959
960struct WalkPrint
961{
962    int depth;
963    FILE * out;
964};
965static void
966printLeadingSpaces( struct WalkPrint * data )
967{
968    const int width = data->depth * 2;
969    fprintf( data->out, "%*.*s", width, width, " " );
970}
971static void
972printIntFunc( const tr_benc * val, void * vdata )
973{
974    struct WalkPrint * data = vdata;
975    printLeadingSpaces( data );
976    fprintf( data->out, "int:  %"PRId64"\n", val->val.i );
977}
978static void
979printStringFunc( const tr_benc * val, void * vdata )
980{
981    int ii;
982    struct WalkPrint * data = vdata;
983    printLeadingSpaces( data );
984    fprintf( data->out, "string:  " );
985    for( ii = 0; val->val.s.i > ii; ii++ )
986    {
987        if( '\\' == val->val.s.s[ii] ) {
988            putc( '\\', data->out );
989            putc( '\\', data->out );
990        } else if( isprint( val->val.s.s[ii] ) ) {
991            putc( val->val.s.s[ii], data->out );
992        } else {
993            fprintf( data->out, "\\x%02x", val->val.s.s[ii] );
994        }
995    }
996    fprintf( data->out, "\n" );
997}
998static void
999printListBeginFunc( const tr_benc * val UNUSED, void * vdata )
1000{
1001    struct WalkPrint * data = vdata;
1002    printLeadingSpaces( data );
1003    fprintf( data->out, "list\n" );
1004    ++data->depth;
1005}
1006static void
1007printDictBeginFunc( const tr_benc * val UNUSED, void * vdata )
1008{
1009    struct WalkPrint * data = vdata;
1010    printLeadingSpaces( data );
1011    fprintf( data->out, "dict\n" );
1012    ++data->depth;
1013}
1014static void
1015printContainerEndFunc( const tr_benc * val UNUSED, void * vdata )
1016{
1017    struct WalkPrint * data = vdata;
1018    --data->depth;
1019}
1020void
1021tr_bencPrint( const tr_benc * val )
1022{
1023    struct WalkFuncs walkFuncs;
1024    struct WalkPrint walkPrint;
1025
1026    walkFuncs.intFunc = printIntFunc;
1027    walkFuncs.stringFunc = printStringFunc;
1028    walkFuncs.dictBeginFunc = printDictBeginFunc;
1029    walkFuncs.listBeginFunc = printListBeginFunc;
1030    walkFuncs.containerEndFunc = printContainerEndFunc;
1031
1032    walkPrint.out = stderr;
1033    walkPrint.depth = 0;
1034    bencWalk( val, &walkFuncs, &walkPrint );
1035}
1036
1037/***
1038****
1039***/
1040
1041struct ParentState
1042{
1043    int bencType;
1044    int childIndex;
1045    int childCount;
1046};
1047 
1048struct jsonWalk
1049{
1050    tr_list * parents;
1051    struct evbuffer * out;
1052};
1053
1054static void
1055jsonIndent( struct jsonWalk * data )
1056{
1057    const int width = tr_list_size( data->parents ) * 4;
1058    evbuffer_add_printf( data->out, "\n%*.*s", width, width, " " );
1059}
1060
1061static void
1062jsonChildFunc( struct jsonWalk * data )
1063{
1064    if( data->parents )
1065    {
1066        struct ParentState * parentState = data->parents->data;
1067
1068        switch( parentState->bencType )
1069        {
1070            case TYPE_DICT: {
1071                const int i = parentState->childIndex++;
1072                if( ! ( i % 2 ) )
1073                    evbuffer_add_printf( data->out, ": " );
1074                else {
1075                    evbuffer_add_printf( data->out, ", " );
1076                    jsonIndent( data );
1077                }
1078                break;
1079            }
1080
1081            case TYPE_LIST: {
1082                ++parentState->childIndex;
1083                evbuffer_add_printf( data->out, ", " );
1084                jsonIndent( data );
1085                break;
1086            }
1087
1088            default:
1089                break;
1090        }
1091    }
1092}
1093
1094static void
1095jsonPushParent( struct jsonWalk * data, const tr_benc * benc )
1096{
1097    struct ParentState * parentState = tr_new( struct ParentState, 1 );
1098    parentState->bencType = benc->type;
1099    parentState->childIndex = 0;
1100    parentState->childCount = benc->val.l.count;
1101    tr_list_prepend( &data->parents, parentState );
1102}
1103
1104static void
1105jsonPopParent( struct jsonWalk * data )
1106{
1107    tr_free( tr_list_pop_front( &data->parents ) );
1108}
1109
1110static void
1111jsonIntFunc( const tr_benc * val, void * vdata )
1112{
1113    struct jsonWalk * data = vdata;
1114    evbuffer_add_printf( data->out, "%"PRId64, val->val.i );
1115    jsonChildFunc( data );
1116}
1117static void
1118jsonStringFunc( const tr_benc * val, void * vdata )
1119{
1120    struct jsonWalk * data = vdata;
1121    const char *it, *end;
1122    evbuffer_add_printf( data->out, "\"" );
1123    for( it=val->val.s.s, end=it+val->val.s.i; it!=end; ++it )
1124    {
1125        switch( *it ) {
1126            case '/' : evbuffer_add_printf( data->out, "\\/" ); break;
1127            case '\b': evbuffer_add_printf( data->out, "\\b" ); break;
1128            case '\f': evbuffer_add_printf( data->out, "\\f" ); break;
1129            case '\n': evbuffer_add_printf( data->out, "\\n" ); break;
1130            case '\r': evbuffer_add_printf( data->out, "\\r" ); break;
1131            case '\t': evbuffer_add_printf( data->out, "\\t" ); break;
1132            case '"' : evbuffer_add_printf( data->out, "\\\"" ); break;
1133            case '\\': evbuffer_add_printf( data->out, "\\\\" ); break;
1134            default: {
1135                if( isascii( *it ) )
1136                    evbuffer_add_printf( data->out, "%c", *it );
1137                else
1138                    evbuffer_add_printf( data->out, "\\u%0x", (unsigned int)*it );
1139                break;
1140            }
1141        }
1142    }
1143    evbuffer_add_printf( data->out, "\"" );
1144    jsonChildFunc( data );
1145}
1146static void
1147jsonDictBeginFunc( const tr_benc * val, void * vdata )
1148{
1149    struct jsonWalk * data = vdata;
1150    jsonPushParent( data, val );
1151    evbuffer_add_printf( data->out, "{" );
1152    if( val->val.l.count )
1153        jsonIndent( data );
1154}
1155static void
1156jsonListBeginFunc( const tr_benc * val, void * vdata )
1157{
1158    const int nChildren = tr_bencListSize( val );
1159    struct jsonWalk * data = vdata;
1160    jsonPushParent( data, val );
1161    evbuffer_add_printf( data->out, "[" );
1162    if( nChildren )
1163        jsonIndent( data );
1164}
1165static void
1166jsonContainerEndFunc( const tr_benc * val, void * vdata )
1167{
1168    size_t i;
1169    struct jsonWalk * data = vdata;
1170    char * str;
1171    int emptyContainer = FALSE;
1172
1173    /* trim out the trailing comma, if any */
1174    str = (char*) EVBUFFER_DATA( data->out );
1175    for( i=EVBUFFER_LENGTH( data->out )-1; i>0; --i ) {
1176        if( isspace( str[i] ) ) continue;
1177        if( str[i]==',' )
1178            EVBUFFER_LENGTH( data->out ) = i;
1179        if( str[i]=='{' || str[i]=='[' )
1180            emptyContainer = TRUE;
1181        break;
1182    }
1183
1184    jsonPopParent( data );
1185    if( !emptyContainer )
1186        jsonIndent( data );
1187    if( tr_bencIsDict( val ) )
1188        evbuffer_add_printf( data->out, "}" );
1189    else /* list */
1190        evbuffer_add_printf( data->out, "]" );
1191    jsonChildFunc( data );
1192}
1193char*
1194tr_bencSaveAsJSON( const tr_benc * top, int * len )
1195{
1196    char * ret;
1197    struct WalkFuncs walkFuncs;
1198    struct jsonWalk data;
1199
1200    data.out = evbuffer_new( );
1201    data.parents = NULL;
1202
1203    walkFuncs.intFunc = jsonIntFunc;
1204    walkFuncs.stringFunc = jsonStringFunc;
1205    walkFuncs.dictBeginFunc = jsonDictBeginFunc;
1206    walkFuncs.listBeginFunc = jsonListBeginFunc;
1207    walkFuncs.containerEndFunc = jsonContainerEndFunc;
1208
1209    bencWalk( top, &walkFuncs, &data );
1210   
1211    if( EVBUFFER_LENGTH( data.out ) )
1212        evbuffer_add_printf( data.out, "\n" );
1213    if( len != NULL )
1214        *len = EVBUFFER_LENGTH( data.out );
1215    ret = tr_strndup( (char*) EVBUFFER_DATA( data.out ), EVBUFFER_LENGTH( data.out ) );
1216    evbuffer_free( data.out );
1217    return ret;
1218}
1219
1220/***
1221****
1222***/
1223
1224int
1225tr_bencSaveFile( const char * filename,  const tr_benc * b )
1226{
1227    int err = TR_OK;
1228    int len;
1229    char * content = tr_bencSave( b, &len );
1230    FILE * out = NULL;
1231
1232    out = fopen( filename, "wb+" );
1233    if( !out )
1234    {
1235        tr_err( _( "Couldn't open \"%1$s\": %2$s" ),
1236                filename, tr_strerror( errno ) );
1237        err = TR_EINVALID;
1238    }
1239    else if( fwrite( content, sizeof( char ), len, out ) != (size_t)len )
1240    {
1241        tr_err( _( "Couldn't save file \"%1$s\": %2$s" ),
1242                filename, tr_strerror( errno ) );
1243        err = TR_EINVALID;
1244    }
1245
1246    if( !err )
1247        tr_dbg( "tr_bencSaveFile saved \"%s\"", filename );
1248    tr_free( content );
1249    if( out )
1250        fclose( out );
1251    return err;
1252}
1253
1254int
1255tr_bencLoadFile( const char * filename, tr_benc * b )
1256{
1257    int ret;
1258    size_t contentLen;
1259    uint8_t * content = tr_loadFile( filename, &contentLen );
1260    ret = content ? tr_bencLoad( content, contentLen, b, NULL )
1261                  : TR_ERROR_IO_OTHER;
1262    tr_free( content );
1263    return ret;
1264}
Note: See TracBrowser for help on using the repository browser.