source: trunk/libtransmission/bencode.c @ 5643

Last change on this file since 5643 was 5643, checked in by charles, 14 years ago

benc cleanup

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