source: trunk/libtransmission/metainfo.c @ 12848

Last change on this file since 12848 was 12848, checked in by jordan, 9 years ago

(trunk libT) #4437 "Multi file webseeds don't work" -- handle multifile torrents with web seed urls that incorrectly don't end with a slash.

  • Property svn:keywords set to Date Rev Author Id
File size: 18.2 KB
Line 
1/*
2 * This file Copyright (C) Mnemosyne LLC
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: metainfo.c 12848 2011-09-06 16:45:48Z jordan $
11 */
12
13#include <assert.h>
14#include <errno.h>
15#include <stdio.h> /* fopen(), fwrite(), fclose() */
16#include <string.h> /* strlen() */
17
18#include <sys/types.h>
19#include <sys/stat.h>
20#include <unistd.h> /* unlink, stat */
21
22#include <event2/buffer.h>
23
24#include "transmission.h"
25#include "session.h"
26#include "bencode.h"
27#include "crypto.h" /* tr_sha1 */
28#include "metainfo.h"
29#include "platform.h" /* tr_getTorrentDir() */
30#include "utils.h"
31
32/***
33****
34***/
35
36char*
37tr_metainfoGetBasename( const tr_info * inf )
38{
39    size_t i;
40    const size_t name_len = strlen( inf->name );
41    char * ret = tr_strdup_printf( "%s.%16.16s", inf->name, inf->hashString );
42
43    for( i=0; i<name_len; ++i )
44        if( ret[i] == '/' )
45            ret[i] = '_';
46
47
48    return ret;
49}
50
51static char*
52getTorrentFilename( const tr_session * session, const tr_info * inf )
53{
54    char * base = tr_metainfoGetBasename( inf );
55    char * filename = tr_strdup_printf( "%s" TR_PATH_DELIMITER_STR "%s.torrent",
56                                        tr_getTorrentDir( session ), base );
57    tr_free( base );
58    return filename;
59}
60
61static char*
62getOldTorrentFilename( const tr_session * session, const tr_info * inf )
63{
64    int i;
65    char * path;
66    struct stat sb;
67    const int tagCount = 5;
68    const char * tags[] = { "beos", "cli", "daemon", "macosx", "wx" };
69
70    /* test the beos, cli, daemon, macosx, wx tags */
71    for( i=0; i<tagCount; ++i ) {
72        path = tr_strdup_printf( "%s%c%s-%s", tr_getTorrentDir( session ), '/', inf->hashString, tags[i] );
73        if( !stat( path, &sb ) && ( ( sb.st_mode & S_IFMT ) == S_IFREG ) )
74            return path;
75        tr_free( path );
76    }
77
78    /* test a non-tagged file */
79    path = tr_buildPath( tr_getTorrentDir( session ), inf->hashString, NULL );
80    if( !stat( path, &sb ) && ( ( sb.st_mode & S_IFMT ) == S_IFREG ) )
81        return path;
82    tr_free( path );
83
84    /* return the -gtk form by default, since that's the most common case.
85       don't bother testing stat() on it since this is the last candidate
86       and we don't want to return NULL anyway */
87    return tr_strdup_printf( "%s%c%s-%s", tr_getTorrentDir( session ), '/', inf->hashString, "gtk" );
88}
89
90/* this is for really old versions of T and will probably be removed someday */
91void
92tr_metainfoMigrate( tr_session * session,
93                    tr_info *   inf )
94{
95    struct stat new_sb;
96    char *      name = getTorrentFilename( session, inf );
97
98    if( stat( name, &new_sb ) || ( ( new_sb.st_mode & S_IFMT ) != S_IFREG ) )
99    {
100        char *    old_name = getOldTorrentFilename( session, inf );
101        size_t    contentLen;
102        uint8_t * content;
103
104        tr_mkdirp( tr_getTorrentDir( session ), 0777 );
105        if( ( content = tr_loadFile( old_name, &contentLen ) ) )
106        {
107            FILE * out;
108            errno = 0;
109            out = fopen( name, "wb+" );
110            if( !out )
111            {
112                tr_nerr( inf->name, _( "Couldn't create \"%1$s\": %2$s" ),
113                        name, tr_strerror( errno ) );
114            }
115            else
116            {
117                if( fwrite( content, sizeof( uint8_t ), contentLen, out )
118                    == contentLen )
119                {
120                    tr_free( inf->torrent );
121                    inf->torrent = tr_strdup( name );
122                    tr_sessionSetTorrentFile( session, inf->hashString, name );
123                    unlink( old_name );
124                }
125                fclose( out );
126            }
127        }
128
129        tr_free( content );
130        tr_free( old_name );
131    }
132
133    tr_free( name );
134}
135
136/***
137****
138***/
139
140static bool
141path_is_suspicious( const char * path )
142{
143    return ( path == NULL )
144        || ( strstr( path, "../" ) != NULL );
145}
146
147static bool
148getfile( char ** setme, const char * root, tr_benc * path, struct evbuffer * buf )
149{
150    bool success = false;
151
152    if( tr_bencIsList( path ) )
153    {
154        int i;
155        const int n = tr_bencListSize( path );
156
157        evbuffer_drain( buf, evbuffer_get_length( buf ) );
158        evbuffer_add( buf, root, strlen( root ) );
159        for( i = 0; i < n; ++i )
160        {
161            const char * str;
162            if( tr_bencGetStr( tr_bencListChild( path, i ), &str ) )
163            {
164                evbuffer_add( buf, TR_PATH_DELIMITER_STR, 1 );
165                evbuffer_add( buf, str, strlen( str ) );
166            }
167        }
168
169        *setme = tr_utf8clean( (char*)evbuffer_pullup( buf, -1 ), evbuffer_get_length( buf ) );
170        /* fprintf( stderr, "[%s]\n", *setme ); */
171        success = true;
172    }
173
174    if( ( *setme != NULL ) && path_is_suspicious( *setme ) )
175    {
176        tr_free( *setme );
177        *setme = NULL;
178        success = false;
179    }
180
181    return success;
182}
183
184static const char*
185parseFiles( tr_info * inf, tr_benc * files, const tr_benc * length )
186{
187    int64_t len;
188
189    inf->totalSize = 0;
190
191    if( tr_bencIsList( files ) ) /* multi-file mode */
192    {
193        tr_file_index_t i;
194        struct evbuffer * buf = evbuffer_new( );
195
196        inf->isMultifile = 1;
197        inf->fileCount   = tr_bencListSize( files );
198        inf->files       = tr_new0( tr_file, inf->fileCount );
199
200        for( i = 0; i < inf->fileCount; ++i )
201        {
202            tr_benc * file;
203            tr_benc * path;
204
205            file = tr_bencListChild( files, i );
206            if( !tr_bencIsDict( file ) )
207                return "files";
208
209            if( !tr_bencDictFindList( file, "path.utf-8", &path ) )
210                if( !tr_bencDictFindList( file, "path", &path ) )
211                    return "path";
212
213            if( !getfile( &inf->files[i].name, inf->name, path, buf ) )
214                return "path";
215
216            if( !tr_bencDictFindInt( file, "length", &len ) )
217                return "length";
218
219            inf->files[i].length = len;
220            inf->totalSize      += len;
221        }
222
223        evbuffer_free( buf );
224    }
225    else if( tr_bencGetInt( length, &len ) ) /* single-file mode */
226    {
227        if( path_is_suspicious( inf->name ) )
228            return "path";
229
230        inf->isMultifile      = 0;
231        inf->fileCount        = 1;
232        inf->files            = tr_new0( tr_file, 1 );
233        inf->files[0].name    = tr_strdup( inf->name );
234        inf->files[0].length  = len;
235        inf->totalSize       += len;
236    }
237    else
238    {
239        return "length";
240    }
241
242    return NULL;
243}
244
245static char *
246tr_convertAnnounceToScrape( const char * announce )
247{
248    char *       scrape = NULL;
249    const char * s;
250
251    /* To derive the scrape URL use the following steps:
252     * Begin with the announce URL. Find the last '/' in it.
253     * If the text immediately following that '/' isn't 'announce'
254     * it will be taken as a sign that that tracker doesn't support
255     * the scrape convention. If it does, substitute 'scrape' for
256     * 'announce' to find the scrape page. */
257    if( ( ( s = strrchr( announce, '/' ) ) ) && !strncmp( ++s, "announce", 8 ) )
258    {
259        const char * prefix = announce;
260        const size_t prefix_len = s - announce;
261        const char * suffix = s + 8;
262        const size_t suffix_len = strlen( suffix );
263        const size_t alloc_len = prefix_len + 6 + suffix_len + 1;
264        char * walk = scrape = tr_new( char, alloc_len );
265        memcpy( walk, prefix, prefix_len ); walk += prefix_len;
266        memcpy( walk, "scrape", 6 );        walk += 6;
267        memcpy( walk, suffix, suffix_len ); walk += suffix_len;
268        *walk++ = '\0';
269        assert( walk - scrape == (int)alloc_len );
270    }
271
272    return scrape;
273}
274
275static const char*
276getannounce( tr_info * inf, tr_benc * meta )
277{
278    const char *      str;
279    tr_tracker_info * trackers = NULL;
280    int               trackerCount = 0;
281    tr_benc *         tiers;
282
283    /* Announce-list */
284    if( tr_bencDictFindList( meta, "announce-list", &tiers ) )
285    {
286        int       n;
287        int       i, j, validTiers;
288        const int numTiers = tr_bencListSize( tiers );
289
290        n = 0;
291        for( i = 0; i < numTiers; ++i )
292            n += tr_bencListSize( tr_bencListChild( tiers, i ) );
293
294        trackers = tr_new0( tr_tracker_info, n );
295
296        for( i = 0, validTiers = 0; i < numTiers; ++i )
297        {
298            tr_benc * tier = tr_bencListChild( tiers, i );
299            const int tierSize = tr_bencListSize( tier );
300            bool anyAdded = false;
301            for( j = 0; j < tierSize; ++j )
302            {
303                if( tr_bencGetStr( tr_bencListChild( tier, j ), &str ) )
304                {
305                    char * url = tr_strstrip( tr_strdup( str ) );
306                    if( !tr_urlIsValidTracker( url ) )
307                        tr_free( url );
308                    else {
309                        tr_tracker_info * t = trackers + trackerCount;
310                        t->tier = validTiers;
311                        t->announce = url;
312                        t->scrape = tr_convertAnnounceToScrape( url );
313                        t->id = trackerCount;
314
315                        anyAdded = true;
316                        ++trackerCount;
317                    }
318                }
319            }
320
321            if( anyAdded )
322                ++validTiers;
323        }
324
325        /* did we use any of the tiers? */
326        if( !trackerCount )
327        {
328            tr_free( trackers );
329            trackers = NULL;
330        }
331    }
332
333    /* Regular announce value */
334    if( !trackerCount
335      && tr_bencDictFindStr( meta, "announce", &str ) )
336    {
337        char * url = tr_strstrip( tr_strdup( str ) );
338        if( !tr_urlIsValidTracker( url ) )
339            tr_free( url );
340        else {
341            trackers = tr_new0( tr_tracker_info, 1 );
342            trackers[trackerCount].tier = 0;
343            trackers[trackerCount].announce = url;
344            trackers[trackerCount].scrape = tr_convertAnnounceToScrape( url );
345            trackers[trackerCount].id = 0;
346            trackerCount++;
347            /*fprintf( stderr, "single announce: [%s]\n", url );*/
348        }
349    }
350
351    inf->trackers = trackers;
352    inf->trackerCount = trackerCount;
353
354    return NULL;
355}
356
357/**
358 * @brief Ensure that the URLs for multfile torrents end in a slash.
359 *
360 * See http://bittorrent.org/beps/bep_0019.html#metadata-extension
361 * for background on how the trailing slash is used for "url-list"
362 * fields.
363 *
364 * This function is to workaround some .torrent generators, such as
365 * mktorrent and very old versions of utorrent, that don't add the
366 * trailing slash for multifile torrents if omitted by the end user.
367 */
368static char*
369fix_webseed_url( const tr_info * inf, const char * url )
370{
371    char * ret = NULL;
372    const size_t len = strlen( url );
373
374    if( tr_urlIsValid( url, len ) )
375    {
376        if( ( inf->fileCount > 1 ) && ( len > 0 ) && ( url[len-1] != '/' ) )
377            ret = tr_strdup_printf( "%*.*s/", (int)len, (int)len, url );
378        else
379            ret = tr_strndup( url, len );
380    }
381
382    return ret;
383}
384
385static void
386geturllist( tr_info * inf,
387            tr_benc * meta )
388{
389    tr_benc * urls;
390    const char * url;
391
392    if( tr_bencDictFindList( meta, "url-list", &urls ) )
393    {
394        int          i;
395        const int    n = tr_bencListSize( urls );
396
397        inf->webseedCount = 0;
398        inf->webseeds = tr_new0( char*, n );
399
400        for( i = 0; i < n; ++i )
401        {
402            if( tr_bencGetStr( tr_bencListChild( urls, i ), &url ) )
403            {
404                char * fixed_url = fix_webseed_url( inf, url );
405
406                if( fixed_url != NULL )
407                    inf->webseeds[inf->webseedCount++] = fixed_url;
408            }
409        }
410    }
411    else if( tr_bencDictFindStr( meta, "url-list", &url ) ) /* handle single items in webseeds */
412    {
413        char * fixed_url = fix_webseed_url( inf, url );
414
415        if( fixed_url != NULL )
416        {
417            inf->webseedCount = 1;
418            inf->webseeds = tr_new0( char*, 1 );
419            inf->webseeds[0] = fixed_url;
420        }
421    }
422}
423
424static const char*
425tr_metainfoParseImpl( const tr_session  * session,
426                      tr_info           * inf,
427                      bool              * hasInfoDict,
428                      int               * infoDictLength,
429                      const tr_benc     * meta_in )
430{
431    int64_t         i;
432    size_t          raw_len;
433    const char *    str;
434    const uint8_t * raw;
435    tr_benc *       d;
436    tr_benc *       infoDict = NULL;
437    tr_benc *       meta = (tr_benc *) meta_in;
438    bool            b;
439    bool            isMagnet = false;
440
441    /* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
442     * from the Metainfo file. Note that the value will be a bencoded
443     * dictionary, given the definition of the info key above. */
444    b = tr_bencDictFindDict( meta, "info", &infoDict );
445    if( hasInfoDict != NULL )
446        *hasInfoDict = b;
447    if( !b )
448    {
449        /* no info dictionary... is this a magnet link? */
450        if( tr_bencDictFindDict( meta, "magnet-info", &d ) )
451        {
452            isMagnet = true;
453
454            /* get the info-hash */
455            if( !tr_bencDictFindRaw( d, "info_hash", &raw, &raw_len ) )
456                return "info_hash";
457            if( raw_len != SHA_DIGEST_LENGTH )
458                return "info_hash";
459            memcpy( inf->hash, raw, raw_len );
460            tr_sha1_to_hex( inf->hashString, inf->hash );
461
462            /* maybe get the display name */
463            if( tr_bencDictFindStr( d, "display-name", &str ) ) {
464                tr_free( inf->name );
465                inf->name = tr_strdup( str );
466            }
467
468            if( !inf->name )
469                inf->name = tr_strdup( inf->hashString );
470        }
471        else /* not a magnet link and has no info dict... */
472        {
473            return "info";
474        }
475    }
476    else
477    {
478        int len;
479        char * bstr = tr_bencToStr( infoDict, TR_FMT_BENC, &len );
480        tr_sha1( inf->hash, bstr, len, NULL );
481        tr_sha1_to_hex( inf->hashString, inf->hash );
482
483        if( infoDictLength != NULL )
484            *infoDictLength = len;
485
486        tr_free( bstr );
487    }
488
489    /* name */
490    if( !isMagnet ) {
491        if( !tr_bencDictFindStr( infoDict, "name.utf-8", &str ) )
492            if( !tr_bencDictFindStr( infoDict, "name", &str ) )
493                str = "";
494        if( !str || !*str )
495            return "name";
496        tr_free( inf->name );
497        inf->name = tr_utf8clean( str, -1 );
498    }
499
500    /* comment */
501    if( !tr_bencDictFindStr( meta, "comment.utf-8", &str ) )
502        if( !tr_bencDictFindStr( meta, "comment", &str ) )
503            str = "";
504    tr_free( inf->comment );
505    inf->comment = tr_utf8clean( str, -1 );
506
507    /* created by */
508    if( !tr_bencDictFindStr( meta, "created by.utf-8", &str ) )
509        if( !tr_bencDictFindStr( meta, "created by", &str ) )
510            str = "";
511    tr_free( inf->creator );
512    inf->creator = tr_utf8clean( str, -1 );
513
514    /* creation date */
515    if( !tr_bencDictFindInt( meta, "creation date", &i ) )
516        i = 0;
517    inf->dateCreated = i;
518
519    /* private */
520    if( !tr_bencDictFindInt( infoDict, "private", &i ) )
521        if( !tr_bencDictFindInt( meta, "private", &i ) )
522            i = 0;
523    inf->isPrivate = i != 0;
524
525    /* piece length */
526    if( !isMagnet ) {
527        if( !tr_bencDictFindInt( infoDict, "piece length", &i ) || ( i < 1 ) )
528            return "piece length";
529        inf->pieceSize = i;
530    }
531
532    /* pieces */
533    if( !isMagnet ) {
534        if( !tr_bencDictFindRaw( infoDict, "pieces", &raw, &raw_len ) )
535            return "pieces";
536        if( raw_len % SHA_DIGEST_LENGTH )
537            return "pieces";
538        inf->pieceCount = raw_len / SHA_DIGEST_LENGTH;
539        inf->pieces = tr_new0( tr_piece, inf->pieceCount );
540        for( i = 0; i < inf->pieceCount; ++i )
541            memcpy( inf->pieces[i].hash, &raw[i * SHA_DIGEST_LENGTH],
542                    SHA_DIGEST_LENGTH );
543    }
544
545    /* files */
546    if( !isMagnet ) {
547        if( ( str = parseFiles( inf, tr_bencDictFind( infoDict, "files" ),
548                                     tr_bencDictFind( infoDict, "length" ) ) ) )
549            return str;
550        if( !inf->fileCount || !inf->totalSize )
551            return "files";
552        if( (uint64_t) inf->pieceCount !=
553           ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
554            return "files";
555    }
556
557    /* get announce or announce-list */
558    if( ( str = getannounce( inf, meta ) ) )
559        return str;
560
561    /* get the url-list */
562    geturllist( inf, meta );
563
564    /* filename of Transmission's copy */
565    tr_free( inf->torrent );
566    inf->torrent = session ?  getTorrentFilename( session, inf ) : NULL;
567
568    return NULL;
569}
570
571bool
572tr_metainfoParse( const tr_session * session,
573                  const tr_benc    * meta_in,
574                  tr_info          * inf,
575                  bool             * hasInfoDict,
576                  int              * infoDictLength )
577{
578    const char * badTag = tr_metainfoParseImpl( session,
579                                                inf,
580                                                hasInfoDict,
581                                                infoDictLength,
582                                                meta_in );
583    const bool success = badTag == NULL;
584
585    if( badTag )
586    {
587        tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), badTag );
588        tr_metainfoFree( inf );
589    }
590
591    return success;
592}
593
594void
595tr_metainfoFree( tr_info * inf )
596{
597    int i;
598    tr_file_index_t ff;
599
600    for( i = 0; i < inf->webseedCount; ++i )
601        tr_free( inf->webseeds[i] );
602
603    for( ff = 0; ff < inf->fileCount; ++ff )
604        tr_free( inf->files[ff].name );
605
606    tr_free( inf->webseeds );
607    tr_free( inf->pieces );
608    tr_free( inf->files );
609    tr_free( inf->comment );
610    tr_free( inf->creator );
611    tr_free( inf->torrent );
612    tr_free( inf->name );
613
614    for( i = 0; i < inf->trackerCount; ++i )
615    {
616        tr_free( inf->trackers[i].announce );
617        tr_free( inf->trackers[i].scrape );
618    }
619    tr_free( inf->trackers );
620
621    memset( inf, '\0', sizeof( tr_info ) );
622}
623
624void
625tr_metainfoRemoveSaved( const tr_session * session, const tr_info * inf )
626{
627    char * filename;
628
629    filename = getTorrentFilename( session, inf );
630    unlink( filename );
631    tr_free( filename );
632
633    filename = getOldTorrentFilename( session, inf );
634    unlink( filename );
635    tr_free( filename );
636}
Note: See TracBrowser for help on using the repository browser.