source: trunk/libtransmission/bencode.c @ 1719

Last change on this file since 1719 was 1719, checked in by joshe, 15 years ago

Escape nonprintable characters in TYPE_STR values in tr_bencPrint output.

  • Property svn:keywords set to Date Rev Author Id
File size: 10.6 KB
Line 
1/******************************************************************************
2 * $Id: bencode.c 1719 2007-04-15 06:21:12Z joshe $
3 *
4 * Copyright (c) 2005-2007 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 "transmission.h"
26
27/* setting to 1 to help expose bugs with tr_bencListAdd and tr_bencDictAdd */
28#define LIST_SIZE   20 /* number of items to increment list/dict buffer by */
29
30static int makeroom( benc_val_t * val, int count )
31{
32    int    len;
33    void * new;
34
35    assert( TYPE_LIST == val->type || TYPE_DICT == val->type );
36
37    if( val->val.l.count + count <= val->val.l.alloc )
38    {
39        return 0;
40    }
41
42    /* We need a bigger boat */
43    len = val->val.l.alloc + count +
44        ( count % LIST_SIZE ? LIST_SIZE - ( count % LIST_SIZE ) : 0 );
45    new = realloc( val->val.l.vals, len * sizeof( benc_val_t ) );
46    if( NULL == new )
47    {
48        return 1;
49    }
50
51    val->val.l.alloc = len;
52    val->val.l.vals  = new;
53
54    return 0;
55}
56
57int _tr_bencLoad( char * buf, int len, benc_val_t * val, char ** end )
58{
59    char * p, * e, * foo;
60
61    if( NULL == buf || 1 >= len )
62    {
63        return 1;
64    }
65
66    if( !end )
67    {
68        /* So we only have to check once */
69        end = &foo;
70    }
71
72    if( buf[0] == 'i' )
73    {
74        int64_t num;
75
76        e = memchr( &buf[1], 'e', len - 1 );
77        if( NULL == e )
78        {
79            return 1;
80        }
81
82        /* Integer: i1242e */
83        *e = '\0';
84        num = strtoll( &buf[1], &p, 10 );
85        *e = 'e';
86
87        if( p != e )
88        {
89            return 1;
90        }
91
92        tr_bencInitInt( val, num );
93        *end = p + 1;
94    }
95    else if( buf[0] == 'l' || buf[0] == 'd' )
96    {
97        /* List: l<item1><item2>e
98           Dict: d<string1><item1><string2><item2>e
99           A dictionary is just a special kind of list with an even
100           count of items, and where even items are strings. */
101        char * cur;
102        char   is_dict;
103        char   str_expected;
104
105        is_dict      = ( buf[0] == 'd' );
106        cur          = &buf[1];
107        str_expected = 1;
108        tr_bencInit( val, ( is_dict ? TYPE_DICT : TYPE_LIST ) );
109        while( cur - buf < len && cur[0] != 'e' )
110        {
111            if( makeroom( val, 1 ) ||
112                tr_bencLoad( cur, len - (cur - buf),
113                             &val->val.l.vals[val->val.l.count], &p ) )
114            {
115                tr_bencFree( val );
116                return 1;
117            }
118            val->val.l.count++;
119            if( is_dict && str_expected &&
120                val->val.l.vals[val->val.l.count - 1].type != TYPE_STR )
121            {
122                tr_bencFree( val );
123                return 1;
124            }
125            str_expected = !str_expected;
126
127            cur = p;
128        }
129
130        if( is_dict && ( val->val.l.count & 1 ) )
131        {
132            tr_bencFree( val );
133            return 1;
134        }
135
136        *end = cur + 1;
137    }
138    else
139    {
140        int    slen;
141        char * sbuf;
142
143        e = memchr( buf, ':', len );
144        if( NULL == e )
145        {
146            return 1;
147        }
148
149        /* String: 12:whateverword */
150        e[0] = '\0';
151        slen = strtol( buf, &p, 10 );
152        e[0] = ':';
153
154        if( p != e || 0 > slen || len - ( ( p + 1 ) - buf ) < slen )
155        {
156            return 1;
157        }
158
159        sbuf = malloc( slen + 1 );
160        if( NULL == sbuf )
161        {
162            return 1;
163        }
164
165        memcpy( sbuf, p + 1, slen );
166        sbuf[slen] = '\0';
167        tr_bencInitStr( val, sbuf, slen, 0 );
168
169        *end = p + 1 + val->val.s.i;
170    }
171
172    val->begin = buf;
173    val->end   = *end;
174
175    return 0;
176}
177
178static void __bencPrint( benc_val_t * val, int space )
179{
180    int ii;
181
182    for( ii = 0; ii < space; ii++ )
183    {
184        putc( ' ', stderr );
185    }
186
187    switch( val->type )
188    {
189        case TYPE_INT:
190            fprintf( stderr, "int:  %"PRIu64"\n", val->val.i );
191            break;
192
193        case TYPE_STR:
194            for( ii = 0; val->val.s.i > ii; ii++ )
195            {
196                if( '\\' == val->val.s.s[ii] )
197                {
198                    putc( '\\', stderr );
199                    putc( '\\', stderr );
200                }
201                else if( isprint( val->val.s.s[ii] ) )
202                {
203                    putc( val->val.s.s[ii], stderr );
204                }
205                else
206                {
207                    fprintf( stderr, "\\x%02x", val->val.s.s[ii] );
208                }
209            }
210            putc( '\n', stderr );
211            break;
212
213        case TYPE_LIST:
214            fprintf( stderr, "list\n" );
215            for( ii = 0; ii < val->val.l.count; ii++ )
216            {
217                __bencPrint( &val->val.l.vals[ii], space + 1 );
218            }
219            break;
220
221        case TYPE_DICT:
222            fprintf( stderr, "dict\n" );
223            for( ii = 0; ii < val->val.l.count; ii++ )
224            {
225                __bencPrint( &val->val.l.vals[ii], space + 1 );
226            }
227            break;
228    }
229}
230
231void tr_bencPrint( benc_val_t * val )
232{
233    __bencPrint( val, 0 );
234}
235
236void tr_bencFree( benc_val_t * val )
237{
238    int i;
239
240    switch( val->type )
241    {
242        case TYPE_INT:
243            break;
244
245        case TYPE_STR:
246            if( !val->val.s.nofree )
247            {
248                free( val->val.s.s );
249            }
250            break;
251
252        case TYPE_LIST:
253        case TYPE_DICT:
254            for( i = 0; i < val->val.l.count; i++ )
255            {
256                tr_bencFree( &val->val.l.vals[i] );
257            }
258            free( val->val.l.vals );
259            break;
260    }
261}
262
263benc_val_t * tr_bencDictFind( benc_val_t * val, const char * key )
264{
265    int len, ii;
266
267    if( val->type != TYPE_DICT )
268    {
269        return NULL;
270    }
271
272    len = strlen( key );
273   
274    for( ii = 0; ii + 1 < val->val.l.count; ii += 2 )
275    {
276        if( TYPE_STR  != val->val.l.vals[ii].type ||
277            len       != val->val.l.vals[ii].val.s.i ||
278            0 != memcmp( val->val.l.vals[ii].val.s.s, key, len ) )
279        {
280            continue;
281        }
282        return &val->val.l.vals[ii+1];
283    }
284
285    return NULL;
286}
287
288benc_val_t * tr_bencDictFindFirst( benc_val_t * val, ... )
289{
290    const char * key;
291    benc_val_t * ret;
292    va_list      ap;
293
294    va_start( ap, val );
295    while( ( key = va_arg( ap, const char * ) ) )
296    {
297        ret = tr_bencDictFind( val, key );
298        if( NULL != ret )
299        {
300            break;
301        }
302    }
303    va_end( ap );
304
305    return ret;
306}
307
308char * tr_bencStealStr( benc_val_t * val )
309{
310    assert( TYPE_STR == val->type );
311    val->val.s.nofree = 1;
312    return val->val.s.s;
313}
314
315void _tr_bencInitStr( benc_val_t * val, char * str, int len, int nofree )
316{
317    tr_bencInit( val, TYPE_STR );
318    val->val.s.s      = str;
319    val->val.s.nofree = nofree;
320    if( 0 >= len )
321    {
322        len = ( NULL == str ? 0 : strlen( str ) );
323    }
324    val->val.s.i = len;
325}
326
327int tr_bencInitStrDup( benc_val_t * val, const char * str )
328{
329    char * new = NULL;
330
331    if( NULL != str )
332    {
333        new = strdup( str );
334        if( NULL == new )
335        {
336            return 1;
337        }
338    }
339
340    _tr_bencInitStr( val, new, 0, 0 );
341
342    return 0;
343}
344
345void tr_bencInitInt( benc_val_t * val, int64_t num )
346{
347    tr_bencInit( val, TYPE_INT );
348    val->val.i = num;
349}
350
351int tr_bencListReserve( benc_val_t * val, int count )
352{
353    assert( TYPE_LIST == val->type );
354
355    if( makeroom( val, count ) )
356    {
357        return 1;
358    }
359
360    return 0;
361}
362
363int tr_bencDictReserve( benc_val_t * val, int count )
364{
365    assert( TYPE_DICT == val->type );
366
367    if( makeroom( val, count * 2 ) )
368    {
369        return 1;
370    }
371
372    return 0;
373}
374
375benc_val_t * tr_bencListAdd( benc_val_t * list )
376{
377    benc_val_t * item;
378
379    assert( TYPE_LIST == list->type );
380    assert( list->val.l.count < list->val.l.alloc );
381
382    item = &list->val.l.vals[list->val.l.count];
383    list->val.l.count++;
384    tr_bencInit( item, TYPE_INT );
385
386    return item;
387}
388
389benc_val_t * tr_bencDictAdd( benc_val_t * dict, const char * key )
390{
391    benc_val_t * keyval, * itemval;
392
393    assert( TYPE_DICT == dict->type );
394    assert( dict->val.l.count + 2 <= dict->val.l.alloc );
395
396    keyval  = &dict->val.l.vals[dict->val.l.count];
397    dict->val.l.count++;
398    itemval = &dict->val.l.vals[dict->val.l.count];
399    dict->val.l.count++;
400
401    tr_bencInitStr( keyval, key, -1, 1 );
402    tr_bencInit( itemval, TYPE_INT );
403
404    return itemval;
405}
406
407char * tr_bencSaveMalloc( benc_val_t * val, int * len )
408{
409    char * buf   = NULL;
410    int alloc = 0;
411
412    *len = 0;
413    if( tr_bencSave( val, &buf, len, &alloc ) )
414    {
415        if( NULL != buf )
416        {
417            free(buf);
418        }
419        *len = 0;
420        return NULL;
421    }
422
423    return buf;
424}
425
426int tr_bencSave( benc_val_t * val, char ** buf, int * used, int * max )
427{
428    int ii;   
429
430    switch( val->type )
431    {
432        case TYPE_INT:
433            if( tr_sprintf( buf, used, max, "i%"PRIu64"e", val->val.i ) )
434            {
435                return 1;
436            }
437            break;
438
439        case TYPE_STR:
440            if( tr_sprintf( buf, used, max, "%i:", val->val.s.i ) ||
441                tr_concat( buf, used,  max, val->val.s.s, val->val.s.i ) )
442            {
443                return 1;
444            }
445            break;
446
447        case TYPE_LIST:
448        case TYPE_DICT:
449            if( tr_sprintf( buf, used, max,
450                            (TYPE_LIST == val->type ? "l" : "d") ) )
451            {
452                return 1;
453            }
454            for( ii = 0; val->val.l.count > ii; ii++ )
455            {
456                if( tr_bencSave( val->val.l.vals + ii, buf, used, max ) )
457                {
458                    return 1;
459                }
460            }
461            if( tr_sprintf( buf, used, max, "e" ) )
462            {
463                return 1;
464            }
465            break;
466    }
467
468    return 0;
469}
Note: See TracBrowser for help on using the repository browser.