source: trunk/libtransmission/metainfo.c @ 1579

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

Merge PEX branch, I hope this works.

  • Property svn:keywords set to Date Rev Author Id
File size: 20.6 KB
Line 
1/******************************************************************************
2 * $Id: metainfo.c 1579 2007-03-23 08:28:01Z 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#define TORRENT_MAX_SIZE (5*1024*1024)
28
29/***********************************************************************
30 * Local prototypes
31 **********************************************************************/
32static void savedname( char * name, size_t len, const char * hash,
33                       const char * tag );
34static char * readtorrent( const char * path, const char * hash,
35                           const char * tag, size_t * len );
36static int savetorrent( const char * hash, const char * tag,
37                        const uint8_t * buf, size_t buflen );
38static int getfile( char * buf, int size,
39                    const char * prefix, const benc_val_t * name );
40static int getannounce( tr_info_t * inf, benc_val_t * meta );
41static char * announceToScrape( const char * announce );
42static void strcatUTF8( char *, int, const char *, int );
43
44/***********************************************************************
45 * tr_metainfoParse
46 ***********************************************************************
47 *
48 **********************************************************************/
49int tr_metainfoParse( tr_info_t * inf, const char * tag, const char * path,
50                      const char * savedHash, int saveCopy )
51{
52    char       * buf;
53    benc_val_t   meta, * beInfo, * list, * val;
54    int          i;
55    size_t       len;
56
57    assert( NULL == path || NULL == savedHash );
58    /* if savedHash isn't null, saveCopy should be false */
59    assert( NULL == savedHash || !saveCopy );
60
61    /* read the torrent data */
62    buf = readtorrent( path, savedHash, tag, &len );
63    if( NULL == buf )
64    {
65        return 1;
66    }
67
68    /* Parse bencoded infos */
69    if( tr_bencLoad( buf, len, &meta, NULL ) )
70    {
71        tr_err( "Error while parsing bencoded data" );
72        free( buf );
73        return 1;
74    }
75
76    /* Get info hash */
77    beInfo = tr_bencDictFind( &meta, "info" );
78    if( NULL == beInfo || TYPE_DICT != beInfo->type )
79    {
80        tr_err( "%s \"info\" dictionary", ( beInfo ? "Invalid" : "Missing" ) );
81        tr_bencFree( &meta );
82        free( buf );
83        return 1;
84    }
85    SHA1( (uint8_t *) beInfo->begin,
86          (long) beInfo->end - (long) beInfo->begin, inf->hash );
87    for( i = 0; i < SHA_DIGEST_LENGTH; i++ )
88    {
89        snprintf( inf->hashString + i * 2, sizeof( inf->hashString ) - i * 2,
90                  "%02x", inf->hash[i] );
91    }
92
93    /* Save a copy of the torrent file */
94    if( saveCopy )
95    {
96        if( savetorrent( inf->hashString, tag, (uint8_t *) buf, len ) )
97        {
98            tr_bencFree( &meta );
99            free( buf );
100            return 1;
101        }
102    }
103
104    /* We won't need this anymore */
105    free( buf );
106
107    /* Torrent file name */
108    if( NULL == path || saveCopy )
109    {
110        savedname( inf->torrent, sizeof inf->torrent, inf->hashString, tag );
111    }
112    else
113    {
114        snprintf( inf->torrent, MAX_PATH_LENGTH, "%s", path );
115    }
116
117    /* Comment info */
118    val = tr_bencDictFindFirst( &meta, "comment.utf-8", "comment", NULL );
119    if( NULL != val && TYPE_STR == val->type )
120    {
121        strcatUTF8( inf->comment, sizeof( inf->comment ), val->val.s.s, 0 );
122    }
123   
124    /* Creator info */
125    val = tr_bencDictFindFirst( &meta, "created by.utf-8", "created by", NULL );
126    if( NULL != val && TYPE_STR == val->type )
127    {
128        strcatUTF8( inf->creator, sizeof( inf->creator ), val->val.s.s, 0 );
129    }
130   
131    /* Date created */
132    inf->dateCreated = 0;
133    val = tr_bencDictFind( &meta, "creation date" );
134    if( NULL != val && TYPE_INT == val->type )
135    {
136        inf->dateCreated = val->val.i;
137    }
138   
139    /* Private torrent */
140    if( tr_bencDictFind( beInfo, "private" ) ||
141        tr_bencDictFind( &meta, "private" ) )
142    {
143        inf->flags |= TR_FLAG_PRIVATE;
144    }
145   
146    /* Piece length */
147    val = tr_bencDictFind( beInfo, "piece length" );
148    if( NULL == val || TYPE_INT != val->type )
149    {
150        tr_err( "%s \"piece length\" entry", ( val ? "Invalid" : "Missing" ) );
151        goto fail;
152    }
153    inf->pieceSize = val->val.i;
154
155    /* Hashes */
156    val = tr_bencDictFind( beInfo, "pieces" );
157    if( NULL == val || TYPE_STR != val->type )
158    {
159        tr_err( "%s \"pieces\" entry", ( val ? "Invalid" : "Missing" ) );
160        goto fail;
161    }
162    if( val->val.s.i % SHA_DIGEST_LENGTH )
163    {
164        tr_err( "Invalid \"piece\" string (size is %d)", val->val.s.i );
165        goto fail;
166    }
167    inf->pieceCount = val->val.s.i / SHA_DIGEST_LENGTH;
168    inf->pieces = (uint8_t *) tr_bencStealStr( val );
169
170    /* TODO add more tests so we don't crash on weird files */
171
172    /* get file or top directory name */
173    val = tr_bencDictFindFirst( beInfo, "name.utf-8", "name", NULL );
174    if( NULL == val || TYPE_STR != val->type )
175    {
176        tr_err( "%s \"name\" string", ( val ? "Invalid" : "Missing" ) );
177        goto fail;
178    }
179    strcatUTF8( inf->name, sizeof( inf->name ), val->val.s.s, 1 );
180    if( '\0' == inf->name[0] )
181    {
182        tr_err( "Invalid \"name\" string" );
183        goto fail;
184    }
185    inf->totalSize = 0;
186
187    if( ( list = tr_bencDictFind( beInfo, "files" ) ) )
188    {
189        /* Multi-file mode */
190        inf->multifile = 1;
191        inf->fileCount = list->val.l.count;
192        inf->files     = calloc( inf->fileCount, sizeof( tr_file_t ) );
193
194        for( i = 0; i < list->val.l.count; i++ )
195        {
196            val = tr_bencDictFindFirst( &list->val.l.vals[i],
197                                        "path.utf-8", "path", NULL );
198            if( getfile( inf->files[i].name, sizeof( inf->files[i].name ),
199                         inf->name, val ) )
200            {
201                tr_err( "%s \"path\" entry", ( val ? "Invalid" : "Missing" ) );
202                goto fail;
203            }
204            val = tr_bencDictFind( &list->val.l.vals[i], "length" );
205            inf->files[i].length  = val->val.i;
206            inf->totalSize       += val->val.i;
207        }
208    }
209    else
210    {
211        /* Single-file mode */
212        inf->multifile = 0;
213        inf->fileCount = 1;
214        inf->files     = calloc( sizeof( tr_file_t ), 1 );
215
216        strcatUTF8( inf->files[0].name, sizeof( inf->files[0].name),
217                    val->val.s.s, 1 );
218       
219        val = tr_bencDictFind( beInfo, "length" );
220        if( NULL == val || TYPE_INT != val->type )
221        {
222            tr_err( "%s \"length\" entry", ( val ? "Invalid" : "Missing" ) );
223            goto fail;
224        }
225        inf->files[0].length  = val->val.i;
226        inf->totalSize       += val->val.i;
227    }
228
229    if( (uint64_t) inf->pieceCount !=
230        ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
231    {
232        tr_err( "Size of hashes and files don't match" );
233        goto fail;
234    }
235
236    /* get announce or announce-list */
237    if( getannounce( inf, &meta ) )
238    {
239        goto fail;
240    }
241
242    tr_bencFree( &meta );
243    return 0;
244
245  fail:
246    tr_metainfoFree( inf );
247    tr_bencFree( &meta );
248    return 1;
249}
250
251void tr_metainfoFree( tr_info_t * inf )
252{
253    int ii, jj;
254
255    free( inf->pieces );
256    free( inf->files );
257   
258    for( ii = 0; ii < inf->trackerTiers; ii++ )
259    {
260        for( jj = 0; jj < inf->trackerList[ii].count; jj++ )
261        {
262            free( inf->trackerList[ii].list[jj].address );
263            free( inf->trackerList[ii].list[jj].announce );
264            free( inf->trackerList[ii].list[jj].scrape );
265        }
266        free( inf->trackerList[ii].list );
267    }
268    free( inf->trackerList );
269}
270
271static int getfile( char * buf, int size,
272                    const char * prefix, const benc_val_t * name )
273{
274    const benc_val_t * dir;
275    const char      ** list;
276    int                ii, jj;
277
278    if( TYPE_LIST != name->type )
279    {
280        return 1;
281    }
282
283    list = calloc( name->val.l.count, sizeof( list[0] ) );
284    if( NULL == list )
285    {
286        return 1;
287    }
288
289    for( ii = jj = 0; name->val.l.count > ii; ii++ )
290    {
291        if( TYPE_STR != name->val.l.vals[ii].type )
292        {
293            continue;
294        }
295        dir = &name->val.l.vals[ii];
296        if( 0 == strcmp( "..", dir->val.s.s ) )
297        {
298            if( 0 < jj )
299            {
300                jj--;
301            }
302        }
303        else if( 0 != strcmp( ".", dir->val.s.s ) )
304        {
305            list[jj] = dir->val.s.s;
306            jj++;
307        }
308    }
309
310    if( 0 == jj )
311    {
312        return 1;
313    }
314
315    strcatUTF8( buf, size, prefix, 0 );
316    for( ii = 0; jj > ii; ii++ )
317    {
318        strcatUTF8( buf, size, "/", 0 );
319        strcatUTF8( buf, size, list[ii], 1 );
320    }
321    free( list );
322
323    return 0;
324}
325
326static int getannounce( tr_info_t * inf, benc_val_t * meta )
327{
328    benc_val_t              * val, * subval, * urlval;
329    char                    * address, * announce;
330    int                       ii, jj, port, random;
331    tr_tracker_info_t * sublist;
332    int subcount;
333    void * swapping;
334
335    /* Announce-list */
336    val = tr_bencDictFind( meta, "announce-list" );
337    if( NULL != val && TYPE_LIST == val->type && 0 < val->val.l.count )
338    {
339        inf->trackerTiers = 0;
340        inf->trackerList = calloc( sizeof( inf->trackerList[0] ),
341                                   val->val.l.count );
342
343        /* iterate through the announce-list's tiers */
344        for( ii = 0; ii < val->val.l.count; ii++ )
345        {
346            subval = &val->val.l.vals[ii];
347            if( TYPE_LIST != subval->type || 0 >= subval->val.l.count )
348            {
349                continue;
350            }
351            subcount = 0;
352            sublist = calloc( sizeof( sublist[0] ), subval->val.l.count );
353
354            /* iterate through the tier's items */
355            for( jj = 0; jj < subval->val.l.count; jj++ )
356            {
357                urlval = &subval->val.l.vals[jj];
358                if( TYPE_STR != urlval->type ||
359                    tr_httpParseUrl( urlval->val.s.s, urlval->val.s.i,
360                                     &address, &port, &announce ) )
361                {
362                    continue;
363                }
364
365                /* place the item info in a random location in the sublist */
366                random = tr_rand( subcount + 1 );
367                if( random != subcount )
368                {
369                    sublist[subcount] = sublist[random];
370                }
371                sublist[random].address  = address;
372                sublist[random].port     = port;
373                sublist[random].announce = announce;
374                sublist[random].scrape   = announceToScrape( announce );
375                subcount++;
376            }
377
378            /* just use sublist as is if it's full */
379            if( subcount == subval->val.l.count )
380            {
381                inf->trackerList[inf->trackerTiers].list = sublist;
382                inf->trackerList[inf->trackerTiers].count = subcount;
383                inf->trackerTiers++;
384            }
385            /* if we skipped some of the tier's items then trim the sublist */
386            else if( 0 < subcount )
387            {
388                inf->trackerList[inf->trackerTiers].list = calloc( sizeof( sublist[0] ), subcount );
389                memcpy( inf->trackerList[inf->trackerTiers].list, sublist,
390                        sizeof( sublist[0] ) * subcount );
391                inf->trackerList[inf->trackerTiers].count = subcount;
392                inf->trackerTiers++;
393                free( sublist );
394            }
395            /* drop the whole sublist if we didn't use any items at all */
396            else
397            {
398                free( sublist );
399            }
400        }
401
402        /* did we use any of the tiers? */
403        if( 0 == inf->trackerTiers )
404        {
405            tr_inf( "No valid entries in \"announce-list\"" );
406            free( inf->trackerList );
407            inf->trackerList = NULL;
408        }
409        /* trim unused sublist pointers */
410        else if( inf->trackerTiers < val->val.l.count )
411        {
412            swapping = inf->trackerList;
413            inf->trackerList = calloc( sizeof( inf->trackerList[0] ),
414                                       inf->trackerTiers );
415            memcpy( inf->trackerList, swapping,
416                    sizeof( inf->trackerList[0] ) * inf->trackerTiers );
417            free( swapping );
418        }
419    }
420
421    /* Regular announce value */
422    if( 0 == inf->trackerTiers )
423    {
424        val = tr_bencDictFind( meta, "announce" );
425        if( NULL == val || TYPE_STR != val->type )
426        {
427            tr_err( "No \"announce\" entry" );
428            return 1;
429        }
430
431        if( tr_httpParseUrl( val->val.s.s, val->val.s.i,
432                             &address, &port, &announce ) )
433        {
434            tr_err( "Invalid announce URL (%s)", val->val.s.s );
435            return 1;
436        }
437
438        sublist                   = calloc( sizeof( sublist[0] ), 1 );
439        sublist[0].address        = address;
440        sublist[0].port           = port;
441        sublist[0].announce       = announce;
442        sublist[0].scrape         = announceToScrape( announce );
443        inf->trackerList          = calloc( sizeof( inf->trackerList[0] ), 1 );
444        inf->trackerList[0].list  = sublist;
445        inf->trackerList[0].count = 1;
446        inf->trackerTiers         = 1;
447    }
448
449    return 0;
450}
451
452static char * announceToScrape( const char * announce )
453{   
454    char old[]  = "announce";
455    int  oldlen = 8;
456    char new[]  = "scrape";
457    int  newlen = 6;
458    char * slash, * scrape;
459    size_t scrapelen, used;
460
461    slash = strrchr( announce, '/' );
462    if( NULL == slash )
463    {
464        return NULL;
465    }
466    slash++;
467   
468    if( 0 != strncmp( slash, old, oldlen ) )
469    {
470        return NULL;
471    }
472
473    scrapelen = strlen( announce ) - oldlen + newlen;
474    scrape = calloc( scrapelen + 1, 1 );
475    if( NULL == scrape )
476    {
477        return NULL;
478    }
479    assert( ( size_t )( slash - announce ) < scrapelen );
480    memcpy( scrape, announce, slash - announce );
481    used = slash - announce;
482    strncat( scrape, new, scrapelen - used );
483    used += newlen;
484    assert( strlen( scrape ) == used );
485    if( used < scrapelen )
486    {
487        assert( strlen( slash + oldlen ) == scrapelen - used );
488        strncat( scrape, slash + oldlen, scrapelen - used );
489    }
490
491    return scrape;
492}
493
494void savedname( char * name, size_t len, const char * hash, const char * tag )
495{
496    if( NULL == tag )
497    {
498        snprintf( name, len, "%s/%s", tr_getTorrentsDirectory(), hash );
499    }
500    else
501    {
502        snprintf( name, len, "%s/%s-%s",
503                  tr_getTorrentsDirectory(), hash, tag );
504    }
505}
506
507void tr_metainfoRemoveSaved( const char * hashString, const char * tag )
508{
509    char file[MAX_PATH_LENGTH];
510
511    savedname( file, sizeof file, hashString, tag );
512    unlink(file);
513}
514
515char * readtorrent( const char * path, const char * hash, const char * tag,
516                    size_t * len )
517{
518    char         hashpath[MAX_PATH_LENGTH], * buf;
519    struct stat  sb;
520    FILE       * file;
521    int          lasterr, save;
522
523    if( NULL != hash )
524    {
525        savedname( hashpath, sizeof hashpath, hash, tag );
526        path = hashpath;
527    }
528
529    /* try to stat the file */
530    save = 0;
531    if( stat( path, &sb ) )
532    {
533        if( ENOENT != errno || NULL == hash )
534        {
535            tr_err( "Could not stat file (%s)", path );
536            return NULL;
537        }
538        /* it doesn't exist, check for an old file without a tag */
539        /* XXX this should go away at some point */
540        lasterr = errno;
541        savedname( hashpath, sizeof hashpath, hash, NULL );
542        if( stat( path, &sb ) )
543        {
544            savedname( hashpath, sizeof hashpath, hash, tag );
545            errno = lasterr;
546            tr_err( "Could not stat file (%s)", path );
547            return NULL;
548        }
549        save = 1;
550    }
551
552    if( ( sb.st_mode & S_IFMT ) != S_IFREG )
553    {
554        tr_err( "Not a regular file (%s)", path );
555        return NULL;
556    }
557    if( sb.st_size > TORRENT_MAX_SIZE )
558    {
559        tr_err( "Torrent file is too big (%d bytes)", ( int )sb.st_size );
560        return NULL;
561    }
562
563    /* Load the torrent file into our buffer */
564    file = fopen( path, "rb" );
565    if( !file )
566    {
567        tr_err( "Could not open file (%s)", path );
568        return NULL;
569    }
570    buf = malloc( sb.st_size );
571    if( NULL == buf )
572    {
573        tr_err( "Could not allocate memory (%d bytes)", ( int )sb.st_size );
574    }
575    fseek( file, 0, SEEK_SET );
576    if( fread( buf, sb.st_size, 1, file ) != 1 )
577    {
578        tr_err( "Read error (%s)", path );
579        free( buf );
580        fclose( file );
581        return NULL;
582    }
583    fclose( file );
584
585    /* save a new tagged copy of the old untagged torrent */
586    if( save )
587    {
588        savetorrent( hash, tag, (uint8_t *) buf, sb.st_size );
589    }
590
591    *len = sb.st_size;
592
593    return buf;
594}
595
596/* Save a copy of the torrent file in the saved torrent directory */
597int savetorrent( const char * hash, const char * tag,
598                 const uint8_t * buf, size_t buflen )
599{
600    char   path[MAX_PATH_LENGTH];
601    FILE * file;
602
603    savedname( path, sizeof path, hash, tag );
604    file = fopen( path, "wb" );
605    if( !file )
606    {
607        tr_err( "Could not open file (%s) (%s)", path, strerror( errno ) );
608        return 1;
609    }
610    fseek( file, 0, SEEK_SET );
611    if( fwrite( buf, 1, buflen, file ) != buflen )
612    {
613        tr_err( "Could not write file (%s) (%s)", path, strerror( errno ) );
614        fclose( file );
615        return 1;
616    }
617    fclose( file );
618
619    return 0;
620}
621
622/***********************************************************************
623 * strcatUTF8
624 ***********************************************************************
625 * According to the official specification, all strings in the torrent
626 * file are supposed to be UTF-8 encoded. However, there are
627 * non-compliant torrents around... If we encounter an invalid UTF-8
628 * character, we assume it is ISO 8859-1 and convert it to UTF-8.
629 **********************************************************************/
630#define WANTBYTES( want, got ) \
631    if( (want) > (got) ) { return; } else { (got) -= (want); }
632static void strcatUTF8( char * s, int len, const char * append, int deslash )
633{
634    const char * p;
635
636    /* don't overwrite the nul at the end */
637    len--;
638
639    /* Go to the end of the destination string */
640    while( s[0] )
641    {
642        s++;
643        len--;
644    }
645
646    /* Now start appending, converting on the fly if necessary */
647    for( p = append; p[0]; )
648    {
649        /* skip over / if requested */
650        if( deslash && '/' == p[0] )
651        {
652            p++;
653            continue;
654        }
655
656        if( !( p[0] & 0x80 ) )
657        {
658            /* ASCII character */
659            WANTBYTES( 1, len );
660            *(s++) = *(p++);
661            continue;
662        }
663
664        if( ( p[0] & 0xE0 ) == 0xC0 && ( p[1] & 0xC0 ) == 0x80 )
665        {
666            /* 2-bytes UTF-8 character */
667            WANTBYTES( 2, len );
668            *(s++) = *(p++); *(s++) = *(p++);
669            continue;
670        }
671
672        if( ( p[0] & 0xF0 ) == 0xE0 && ( p[1] & 0xC0 ) == 0x80 &&
673            ( p[2] & 0xC0 ) == 0x80 )
674        {
675            /* 3-bytes UTF-8 character */
676            WANTBYTES( 3, len );
677            *(s++) = *(p++); *(s++) = *(p++);
678            *(s++) = *(p++);
679            continue;
680        }
681
682        if( ( p[0] & 0xF8 ) == 0xF0 && ( p[1] & 0xC0 ) == 0x80 &&
683            ( p[2] & 0xC0 ) == 0x80 && ( p[3] & 0xC0 ) == 0x80 )
684        {
685            /* 4-bytes UTF-8 character */
686            WANTBYTES( 4, len );
687            *(s++) = *(p++); *(s++) = *(p++);
688            *(s++) = *(p++); *(s++) = *(p++);
689            continue;
690        }
691
692        /* ISO 8859-1 -> UTF-8 conversion */
693        WANTBYTES( 2, len );
694        *(s++) = 0xC0 | ( ( *p & 0xFF ) >> 6 );
695        *(s++) = 0x80 | ( *(p++) & 0x3F );
696    }
697}
Note: See TracBrowser for help on using the repository browser.