source: trunk/libtransmission/metainfo.c @ 12293

Last change on this file since 12293 was 12293, checked in by jordan, 11 years ago

(trunk libT) more malloc pruning. *yawn*

tr_metainfoGetBasename(): avoid an unnecessary malloc() + free()
getannounce(): avoid an unnecessary malloc() + free() per each tracker

  • Property svn:keywords set to Date Rev Author Id
File size: 17.1 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 12293 2011-04-01 04:13:51Z 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
357static void
358geturllist( tr_info * inf,
359            tr_benc * meta )
360{
361    tr_benc * urls;
362    const char * url;
363
364    if( tr_bencDictFindList( meta, "url-list", &urls ) )
365    {
366        int          i;
367        const int    n = tr_bencListSize( urls );
368
369        inf->webseedCount = 0;
370        inf->webseeds = tr_new0( char*, n );
371
372        for( i = 0; i < n; ++i )
373            if( tr_bencGetStr( tr_bencListChild( urls, i ), &url ) )
374                inf->webseeds[inf->webseedCount++] = tr_strdup( url );
375    }
376    else if( tr_bencDictFindStr( meta, "url-list", &url ) ) /* handle single items in webseeds */
377    {
378        inf->webseedCount = 1;
379        inf->webseeds = tr_new0( char*, 1 );
380        inf->webseeds[0] = tr_strdup( url );
381    }
382}
383
384static const char*
385tr_metainfoParseImpl( const tr_session  * session,
386                      tr_info           * inf,
387                      bool              * hasInfoDict,
388                      int               * infoDictLength,
389                      const tr_benc     * meta_in )
390{
391    int64_t         i;
392    size_t          raw_len;
393    const char *    str;
394    const uint8_t * raw;
395    tr_benc *       d;
396    tr_benc *       infoDict = NULL;
397    tr_benc *       meta = (tr_benc *) meta_in;
398    bool            b;
399    bool            isMagnet = false;
400
401    /* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
402     * from the Metainfo file. Note that the value will be a bencoded
403     * dictionary, given the definition of the info key above. */
404    b = tr_bencDictFindDict( meta, "info", &infoDict );
405    if( hasInfoDict != NULL )
406        *hasInfoDict = b;
407    if( !b )
408    {
409        /* no info dictionary... is this a magnet link? */
410        if( tr_bencDictFindDict( meta, "magnet-info", &d ) )
411        {
412            isMagnet = true;
413
414            /* get the info-hash */
415            if( !tr_bencDictFindRaw( d, "info_hash", &raw, &raw_len ) )
416                return "info_hash";
417            if( raw_len != SHA_DIGEST_LENGTH )
418                return "info_hash";
419            memcpy( inf->hash, raw, raw_len );
420            tr_sha1_to_hex( inf->hashString, inf->hash );
421
422            /* maybe get the display name */
423            if( tr_bencDictFindStr( d, "display-name", &str ) ) {
424                tr_free( inf->name );
425                inf->name = tr_strdup( str );
426            }
427
428            if( !inf->name )
429                inf->name = tr_strdup( inf->hashString );
430        }
431        else /* not a magnet link and has no info dict... */
432        {
433            return "info";
434        }
435    }
436    else
437    {
438        int len;
439        char * bstr = tr_bencToStr( infoDict, TR_FMT_BENC, &len );
440        tr_sha1( inf->hash, bstr, len, NULL );
441        tr_sha1_to_hex( inf->hashString, inf->hash );
442
443        if( infoDictLength != NULL )
444            *infoDictLength = len;
445
446        tr_free( bstr );
447    }
448
449    /* name */
450    if( !isMagnet ) {
451        if( !tr_bencDictFindStr( infoDict, "name.utf-8", &str ) )
452            if( !tr_bencDictFindStr( infoDict, "name", &str ) )
453                str = "";
454        if( !str || !*str )
455            return "name";
456        tr_free( inf->name );
457        inf->name = tr_utf8clean( str, -1 );
458    }
459
460    /* comment */
461    if( !tr_bencDictFindStr( meta, "comment.utf-8", &str ) )
462        if( !tr_bencDictFindStr( meta, "comment", &str ) )
463            str = "";
464    tr_free( inf->comment );
465    inf->comment = tr_utf8clean( str, -1 );
466
467    /* created by */
468    if( !tr_bencDictFindStr( meta, "created by.utf-8", &str ) )
469        if( !tr_bencDictFindStr( meta, "created by", &str ) )
470            str = "";
471    tr_free( inf->creator );
472    inf->creator = tr_utf8clean( str, -1 );
473
474    /* creation date */
475    if( !tr_bencDictFindInt( meta, "creation date", &i ) )
476        i = 0;
477    inf->dateCreated = i;
478
479    /* private */
480    if( !tr_bencDictFindInt( infoDict, "private", &i ) )
481        if( !tr_bencDictFindInt( meta, "private", &i ) )
482            i = 0;
483    inf->isPrivate = i != 0;
484
485    /* piece length */
486    if( !isMagnet ) {
487        if( !tr_bencDictFindInt( infoDict, "piece length", &i ) || ( i < 1 ) )
488            return "piece length";
489        inf->pieceSize = i;
490    }
491
492    /* pieces */
493    if( !isMagnet ) {
494        if( !tr_bencDictFindRaw( infoDict, "pieces", &raw, &raw_len ) )
495            return "pieces";
496        if( raw_len % SHA_DIGEST_LENGTH )
497            return "pieces";
498        inf->pieceCount = raw_len / SHA_DIGEST_LENGTH;
499        inf->pieces = tr_new0( tr_piece, inf->pieceCount );
500        for( i = 0; i < inf->pieceCount; ++i )
501            memcpy( inf->pieces[i].hash, &raw[i * SHA_DIGEST_LENGTH],
502                    SHA_DIGEST_LENGTH );
503    }
504
505    /* files */
506    if( !isMagnet ) {
507        if( ( str = parseFiles( inf, tr_bencDictFind( infoDict, "files" ),
508                                     tr_bencDictFind( infoDict, "length" ) ) ) )
509            return str;
510        if( !inf->fileCount || !inf->totalSize )
511            return "files";
512        if( (uint64_t) inf->pieceCount !=
513           ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
514            return "files";
515    }
516
517    /* get announce or announce-list */
518    if( ( str = getannounce( inf, meta ) ) )
519        return str;
520
521    /* get the url-list */
522    geturllist( inf, meta );
523
524    /* filename of Transmission's copy */
525    tr_free( inf->torrent );
526    inf->torrent = session ?  getTorrentFilename( session, inf ) : NULL;
527
528    return NULL;
529}
530
531bool
532tr_metainfoParse( const tr_session * session,
533                  const tr_benc    * meta_in,
534                  tr_info          * inf,
535                  bool             * hasInfoDict,
536                  int              * infoDictLength )
537{
538    const char * badTag = tr_metainfoParseImpl( session,
539                                                inf,
540                                                hasInfoDict,
541                                                infoDictLength,
542                                                meta_in );
543    const bool success = badTag == NULL;
544
545    if( badTag )
546    {
547        tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), badTag );
548        tr_metainfoFree( inf );
549    }
550
551    return success;
552}
553
554void
555tr_metainfoFree( tr_info * inf )
556{
557    int i;
558    tr_file_index_t ff;
559
560    for( i = 0; i < inf->webseedCount; ++i )
561        tr_free( inf->webseeds[i] );
562
563    for( ff = 0; ff < inf->fileCount; ++ff )
564        tr_free( inf->files[ff].name );
565
566    tr_free( inf->webseeds );
567    tr_free( inf->pieces );
568    tr_free( inf->files );
569    tr_free( inf->comment );
570    tr_free( inf->creator );
571    tr_free( inf->torrent );
572    tr_free( inf->name );
573
574    for( i = 0; i < inf->trackerCount; ++i )
575    {
576        tr_free( inf->trackers[i].announce );
577        tr_free( inf->trackers[i].scrape );
578    }
579    tr_free( inf->trackers );
580
581    memset( inf, '\0', sizeof( tr_info ) );
582}
583
584void
585tr_metainfoRemoveSaved( const tr_session * session, const tr_info * inf )
586{
587    char * filename;
588
589    filename = getTorrentFilename( session, inf );
590    unlink( filename );
591    tr_free( filename );
592
593    filename = getOldTorrentFilename( session, inf );
594    unlink( filename );
595    tr_free( filename );
596}
Note: See TracBrowser for help on using the repository browser.