source: trunk/libtransmission/bencode.c @ 1639

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

Fix benc list/dict allocation.

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