source: trunk/libtransmission/bencode.c @ 8160

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

(trunk libT) silence a spurious warning in the new bencode code

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