source: trunk/libtransmission/metainfo.c @ 6073

Last change on this file since 6073 was 6073, checked in by charles, 13 years ago

#800 initial support for GetRight?-style fetching of data through http and ftp servers specified in the .torrent's "url-list" tag

  • Property svn:keywords set to Date Rev Author Id
File size: 18.4 KB
Line 
1/******************************************************************************
2 * $Id: metainfo.c 6073 2008-06-07 21:26:41Z charles $
3 *
4 * Copyright (c) 2005-2008 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 <assert.h>
26#include <ctype.h> /* isspace */
27#include <errno.h>
28#include <stdio.h>
29#include <stdlib.h>
30
31#include <sys/types.h>
32#include <sys/stat.h>
33#include <unistd.h> /* unlink, stat */
34
35#include <event.h> /* struct evbuffer */
36
37#include "transmission.h"
38#include "bencode.h"
39#include "crypto.h" /* tr_sha1 */
40#include "metainfo.h"
41#include "platform.h"
42#include "utils.h"
43
44/***********************************************************************
45 * Local prototypes
46 **********************************************************************/
47static int parseFiles( tr_info * inf, tr_benc * name,
48                       tr_benc * files, tr_benc * length );
49
50/***
51****
52***/
53
54#define WANTBYTES( want, got ) \
55    if( (want) > (got) ) { return; } else { (got) -= (want); }
56static void
57strlcat_utf8( void * dest, const void * src, size_t len, char skip )
58{
59    char       * s      = dest;
60    const char * append = src;
61    const char * p;
62
63    /* don't overwrite the nul at the end */
64    len--;
65
66    /* Go to the end of the destination string */
67    while( s[0] )
68    {
69        s++;
70        len--;
71    }
72
73    /* Now start appending, converting on the fly if necessary */
74    for( p = append; p[0]; )
75    {
76        /* skip over the requested character */
77        if( skip == p[0] )
78        {
79            p++;
80            continue;
81        }
82
83        if( !( p[0] & 0x80 ) )
84        {
85            /* ASCII character */
86            WANTBYTES( 1, len );
87            *(s++) = *(p++);
88            continue;
89        }
90
91        if( ( p[0] & 0xE0 ) == 0xC0 && ( p[1] & 0xC0 ) == 0x80 )
92        {
93            /* 2-bytes UTF-8 character */
94            WANTBYTES( 2, len );
95            *(s++) = *(p++); *(s++) = *(p++);
96            continue;
97        }
98
99        if( ( p[0] & 0xF0 ) == 0xE0 && ( p[1] & 0xC0 ) == 0x80 &&
100            ( p[2] & 0xC0 ) == 0x80 )
101        {
102            /* 3-bytes UTF-8 character */
103            WANTBYTES( 3, len );
104            *(s++) = *(p++); *(s++) = *(p++);
105            *(s++) = *(p++);
106            continue;
107        }
108
109        if( ( p[0] & 0xF8 ) == 0xF0 && ( p[1] & 0xC0 ) == 0x80 &&
110            ( p[2] & 0xC0 ) == 0x80 && ( p[3] & 0xC0 ) == 0x80 )
111        {
112            /* 4-bytes UTF-8 character */
113            WANTBYTES( 4, len );
114            *(s++) = *(p++); *(s++) = *(p++);
115            *(s++) = *(p++); *(s++) = *(p++);
116            continue;
117        }
118
119        /* ISO 8859-1 -> UTF-8 conversion */
120        WANTBYTES( 2, len );
121        *(s++) = 0xC0 | ( ( *p & 0xFF ) >> 6 );
122        *(s++) = 0x80 | ( *(p++) & 0x3F );
123    }
124}
125
126static void
127getTorrentFilename( const tr_handle  * handle,
128                    const tr_info    * inf,
129                    char             * buf,
130                    size_t             buflen )
131{
132    const char * dir = tr_getTorrentDir( handle );
133    char base[MAX_PATH_LENGTH];
134    snprintf( base, sizeof( base ), "%s.%16.16s.torrent", inf->name, inf->hashString );
135    tr_buildPath( buf, buflen, dir, base, NULL );
136}
137
138static void
139getTorrentOldFilename( const tr_handle * handle,
140                       const tr_info   * info,
141                       char            * name,
142                       size_t            len )
143{
144    const char * torDir = tr_getTorrentDir( handle );
145
146    if( !handle->tag )
147    {
148        tr_buildPath( name, len, torDir, info->hashString, NULL );
149    }
150    else
151    {
152        char base[1024];
153        snprintf( base, sizeof(base), "%s-%s", info->hashString, handle->tag );
154        tr_buildPath( name, len, torDir, base, NULL );
155    }
156}
157
158void
159tr_metainfoMigrate( tr_handle * handle,
160                    tr_info   * inf )
161{
162    struct stat new_sb;
163    char new_name[MAX_PATH_LENGTH];
164
165    getTorrentFilename( handle, inf, new_name, sizeof( new_name ) );
166
167    if( stat( new_name, &new_sb ) || ( ( new_sb.st_mode & S_IFMT ) != S_IFREG ) )
168    {
169        char old_name[MAX_PATH_LENGTH];
170        size_t contentLen;
171        uint8_t * content;
172
173        tr_mkdirp( tr_getTorrentDir( handle ), 0777 );
174        getTorrentOldFilename( handle, inf, old_name, sizeof( old_name ) );
175        if(( content = tr_loadFile( old_name, &contentLen )))
176        {
177            FILE * out;
178            errno = 0;
179            out = fopen( new_name, "wb+" );
180            if( !out )
181            {
182                tr_nerr( inf->name, _( "Couldn't create \"%1$s\": %2$s" ), new_name, tr_strerror( errno ) );
183            }
184            else
185            {
186                if( fwrite( content, sizeof( uint8_t ), contentLen, out ) == contentLen )
187                {
188                    tr_free( inf->torrent );
189                    inf->torrent = tr_strdup( new_name );
190                    tr_sessionSetTorrentFile( handle, inf->hashString, new_name );
191                    unlink( old_name );
192                }
193                fclose( out );
194            }
195        }
196
197        tr_free( content );
198    }
199}
200
201static char *
202announceToScrape( const char * announce )
203{
204    char * scrape = NULL;
205    const char * s;
206
207    /* To derive the scrape URL use the following steps:
208     * Begin with the announce URL. Find the last '/' in it.
209     * If the text immediately following that '/' isn't 'announce'
210     * it will be taken as a sign that that tracker doesn't support
211     * the scrape convention. If it does, substitute 'scrape' for
212     * 'announce' to find the scrape page.  */
213    if((( s = strrchr( announce, '/' ))) && !strncmp( ++s, "announce", 8 ))
214    {
215        struct evbuffer * buf = evbuffer_new( );
216        evbuffer_add( buf, announce, s-announce );
217        evbuffer_add( buf, "scrape", 6 );
218        evbuffer_add_printf( buf, "%s", s+8 );
219        scrape = tr_strdup( ( char * ) EVBUFFER_DATA( buf ) );
220        evbuffer_free( buf );
221    }
222
223    return scrape;
224}
225
226static void
227geturllist( tr_info * inf, tr_benc * meta )
228{
229    benc_val_t * urls;
230
231    if( tr_bencDictFindList( meta, "url-list", &urls ) )
232    {
233        int i;
234        const char * url;
235        const int n = tr_bencListSize( urls );
236
237        inf->webseedCount = 0;
238        inf->webseeds = tr_new0( char*, n );
239
240        for( i=0; i<n; ++i )
241            if( tr_bencGetStr( tr_bencListChild( urls, i ), &url ) )
242                inf->webseeds[inf->webseedCount++] = tr_strdup( url );
243    }
244}
245
246static int
247getannounce( tr_info * inf, tr_benc * meta )
248{
249    const char * str;
250    tr_tracker_info * trackers = NULL;
251    int trackerCount = 0;
252    tr_benc * tiers;
253
254    /* Announce-list */
255    if( tr_bencDictFindList( meta, "announce-list", &tiers ) )
256    {
257        int n;
258        int i, j;
259
260        n = 0;
261        for( i=0; i<tiers->val.l.count; ++i )
262            n += tiers->val.l.vals[i].val.l.count;
263
264        trackers = tr_new0( tr_tracker_info, n );
265        trackerCount = 0;
266
267        for( i=0; i<tiers->val.l.count; ++i ) {
268            const tr_benc * tier = &tiers->val.l.vals[i];
269            for( j=0; tr_bencIsList(tier) && j<tier->val.l.count; ++j ) {
270                const tr_benc * a = &tier->val.l.vals[j];
271                if( tr_bencIsString( a ) && tr_httpIsValidURL( a->val.s.s ) ) {
272                    tr_tracker_info * t = trackers + trackerCount++;
273                    t->tier = i;
274                    t->announce = tr_strndup( a->val.s.s, a->val.s.i );
275                    t->scrape = announceToScrape( a->val.s.s );
276                    /*fprintf( stderr, "tier %d: %s\n", i, a->val.s.s );*/
277                }
278            }
279        }
280
281        /* did we use any of the tiers? */
282        if( !trackerCount ) {
283            tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), "announce-list" );
284            tr_free( trackers );
285            trackers = NULL;
286        }
287    }
288
289    /* Regular announce value */
290    if( !trackerCount
291        && tr_bencDictFindStr( meta, "announce", &str )
292        && tr_httpIsValidURL( str ) )
293    {
294        trackers = tr_new0( tr_tracker_info, 1 );
295        trackers[trackerCount].tier = 0;
296        trackers[trackerCount].announce = tr_strdup( str );
297        trackers[trackerCount++].scrape = announceToScrape( str );
298        /*fprintf( stderr, "single announce: [%s]\n", str );*/
299    }
300
301    inf->trackers = trackers;
302    inf->trackerCount = trackerCount;
303
304    if( !inf->trackerCount )
305        tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), "announce" );
306
307    return inf->trackerCount ? TR_OK : TR_ERROR;
308}
309
310int
311tr_metainfoParse( const tr_handle  * handle,
312                  tr_info          * inf,
313                  const tr_benc    * meta_in )
314{
315    tr_piece_index_t i;
316    tr_benc * beInfo, * val, * val2;
317    tr_benc * meta = (tr_benc *) meta_in;
318    char buf[4096];
319
320    /* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
321     * from the Metainfo file. Note that the value will be a bencoded
322     * dictionary, given the definition of the info key above. */
323    if(( beInfo = tr_bencDictFindType( meta, "info", TYPE_DICT )))
324    {
325        int len;
326        char * str = tr_bencSave( beInfo, &len );
327        tr_sha1( inf->hash, str, len, NULL );
328        tr_free( str );
329    }
330    else
331    {
332        tr_err( _( "Missing metadata entry \"%s\"" ), "info" );
333        return TR_EINVALID;
334    }
335
336    tr_sha1_to_hex( inf->hashString, inf->hash );
337
338    /* comment */
339    memset( buf, '\0', sizeof( buf ) );
340    val = tr_bencDictFindFirst( meta, "comment.utf-8", "comment", NULL );
341    if( tr_bencIsString( val ) )
342        strlcat_utf8( buf, val->val.s.s, sizeof( buf ), 0 );
343    tr_free( inf->comment );
344    inf->comment = tr_strdup( buf );
345   
346    /* creator */
347    memset( buf, '\0', sizeof( buf ) );
348    val = tr_bencDictFindFirst( meta, "created by.utf-8", "created by", NULL );
349    if( tr_bencIsString( val ) )
350        strlcat_utf8( buf, val->val.s.s, sizeof( buf ), 0 );
351    tr_free( inf->creator );
352    inf->creator = tr_strdup( buf );
353   
354    /* Date created */
355    inf->dateCreated = 0;
356    val = tr_bencDictFind( meta, "creation date" );
357    if( tr_bencIsInt( val ) )
358        inf->dateCreated = val->val.i;
359   
360    /* Private torrent */
361    val  = tr_bencDictFind( beInfo, "private" );
362    val2 = tr_bencDictFind( meta,  "private" );
363    if( ( tr_bencIsInt(val) && val->val.i ) ||
364        ( tr_bencIsInt(val2) && val2->val.i ) )
365    {
366        inf->isPrivate = 1;
367    }
368   
369    /* Piece length */
370    val = tr_bencDictFind( beInfo, "piece length" );
371    if( !tr_bencIsInt( val ) )
372    {
373        if( val )
374            tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), "piece length" );
375        else
376            tr_nerr( inf->name, _( "Missing metadata entry \"%s\"" ), "piece length" );
377        goto fail;
378    }
379    inf->pieceSize = val->val.i;
380
381    /* Hashes */
382    val = tr_bencDictFind( beInfo, "pieces" );
383    if( !tr_bencIsString( val ) )
384    {
385        if( val )
386            tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), "pieces" );
387        else
388            tr_nerr( inf->name, _( "Missing metadata entry \"%s\"" ), "pieces" );
389        goto fail;
390    }
391    if( val->val.s.i % SHA_DIGEST_LENGTH )
392    {
393        tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), "pieces" );
394        goto fail;
395    }
396    inf->pieceCount = val->val.s.i / SHA_DIGEST_LENGTH;
397
398    inf->pieces = calloc ( inf->pieceCount, sizeof(tr_piece) );
399
400    for ( i=0; i<inf->pieceCount; ++i )
401    {
402        memcpy (inf->pieces[i].hash, &val->val.s.s[i*SHA_DIGEST_LENGTH], SHA_DIGEST_LENGTH);
403    }
404
405    /* get file or top directory name */
406    val = tr_bencDictFindFirst( beInfo, "name.utf-8", "name", NULL );
407    if( parseFiles( inf, tr_bencDictFindFirst( beInfo,
408                                               "name.utf-8", "name", NULL ),
409                    tr_bencDictFind( beInfo, "files" ),
410                    tr_bencDictFind( beInfo, "length" ) ) )
411    {
412        goto fail;
413    }
414
415    if( !inf->fileCount || !inf->totalSize )
416    {
417        tr_nerr( inf->name, _( "Torrent is corrupt" ) ); /* the content is missing! */
418        goto fail;
419    }
420
421    /* TODO add more tests so we don't crash on weird files */
422
423    if( (uint64_t) inf->pieceCount !=
424        ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
425    {
426        tr_nerr( inf->name, _( "Torrent is corrupt" ) ); /* size of hashes and files don't match */
427        goto fail;
428    }
429
430    /* get announce or announce-list */
431    if( getannounce( inf, meta ) )
432        goto fail;
433
434    /* get the url-list */
435    geturllist( inf, meta );
436
437    /* filename of Transmission's copy */
438    getTorrentFilename( handle, inf, buf, sizeof( buf ) );
439    tr_free( inf->torrent );
440    inf->torrent = tr_strdup( buf );
441
442    return TR_OK;
443
444  fail:
445    tr_metainfoFree( inf );
446    return TR_EINVALID;
447}
448
449void tr_metainfoFree( tr_info * inf )
450{
451    tr_file_index_t ff;
452    int i;
453
454    for( i=0; i<inf->webseedCount; ++i )
455        tr_free( inf->webseeds[i] );
456
457    for( ff=0; ff<inf->fileCount; ++ff )
458        tr_free( inf->files[ff].name );
459
460    tr_free( inf->webseeds );
461    tr_free( inf->pieces );
462    tr_free( inf->files );
463    tr_free( inf->comment );
464    tr_free( inf->creator );
465    tr_free( inf->torrent );
466    tr_free( inf->name );
467   
468    for( i=0; i<inf->trackerCount; ++i ) {
469        tr_free( inf->trackers[i].announce );
470        tr_free( inf->trackers[i].scrape );
471    }
472    tr_free( inf->trackers );
473
474    memset( inf, '\0', sizeof(tr_info) );
475}
476
477static int
478getfile( char ** setme, const char * prefix, tr_benc * name )
479{
480    const char ** list;
481    int           ii, jj;
482    char          buf[4096];
483
484    if( !tr_bencIsList( name ) )
485        return TR_EINVALID;
486
487    list = calloc( name->val.l.count, sizeof( list[0] ) );
488    if( !list )
489        return TR_EINVALID;
490
491    for( ii = jj = 0; name->val.l.count > ii; ii++ )
492    {
493        tr_benc * dir = &name->val.l.vals[ii];
494
495        if( !tr_bencIsString( dir ) )
496            continue;
497
498        if( 0 == strcmp( "..", dir->val.s.s ) )
499        {
500            if( 0 < jj )
501            {
502                jj--;
503            }
504        }
505        else if( 0 != strcmp( ".", dir->val.s.s ) )
506        {
507            list[jj] = dir->val.s.s;
508            jj++;
509        }
510    }
511
512    if( 0 == jj )
513    {
514        free( list );
515        return TR_EINVALID;
516    }
517
518    memset( buf, 0, sizeof( buf ) );
519    strlcat_utf8( buf, prefix, sizeof(buf), 0 );
520    for( ii = 0; jj > ii; ii++ )
521    {
522        strlcat_utf8( buf, TR_PATH_DELIMITER_STR, sizeof(buf), 0 );
523        strlcat_utf8( buf, list[ii], sizeof(buf), TR_PATH_DELIMITER );
524    }
525    free( list );
526
527    tr_free( *setme );
528    *setme = tr_strdup( buf );
529
530    return TR_OK;
531}
532
533void
534tr_metainfoRemoveSaved( const tr_handle * handle,
535                        const tr_info   * inf )
536{
537    char filename[MAX_PATH_LENGTH];
538
539    getTorrentFilename( handle, inf, filename, sizeof( filename ) );
540    unlink( filename );
541
542    getTorrentOldFilename( handle, inf, filename, sizeof( filename ) );
543    unlink( filename );
544}
545
546static int
547parseFiles( tr_info * inf, tr_benc * name,
548            tr_benc * files, tr_benc * length )
549{
550    tr_benc * item, * path;
551    int ii;
552    char buf[4096];
553
554    if( !tr_bencIsString( name ) )
555    {
556        if( name )
557            tr_err( _( "Invalid metadata entry \"%s\"" ), "name" );
558        else
559            tr_err( _( "Missing metadata entry \"%s\"" ), "name" );
560        return TR_EINVALID;
561    }
562
563    memset( buf, 0, sizeof( buf ) );
564    strlcat_utf8( buf, name->val.s.s, sizeof( buf ), 0 );
565    tr_free( inf->name );
566    inf->name = tr_strdup( buf );
567    if( !inf->name || !*inf->name )
568    {
569        tr_err( _( "Invalid metadata entry \"%s\"" ), "name" );
570        return TR_EINVALID;
571    }
572    inf->totalSize = 0;
573
574    if( tr_bencIsList( files ) )
575    {
576        /* Multi-file mode */
577        inf->isMultifile = 1;
578        inf->fileCount = files->val.l.count;
579        inf->files     = calloc( inf->fileCount, sizeof( inf->files[0] ) );
580
581        if( !inf->files )
582            return TR_EINVALID;
583
584        for( ii = 0; files->val.l.count > ii; ii++ )
585        {
586            item = &files->val.l.vals[ii];
587            path = tr_bencDictFindFirst( item, "path.utf-8", "path", NULL );
588            if( getfile( &inf->files[ii].name, inf->name, path ) )
589            {
590                if( path )
591                    tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), "path" );
592                else
593                    tr_nerr( inf->name, _( "Missing metadata entry \"%s\"" ), "path" );
594                return TR_EINVALID;
595            }
596            length = tr_bencDictFind( item, "length" );
597            if( !tr_bencIsInt( length ) )
598            {
599                if( length )
600                    tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), "length" );
601                else
602                    tr_nerr( inf->name, _( "Missing metadata entry \"%s\"" ), "length" );
603                return TR_EINVALID;
604            }
605            inf->files[ii].length = length->val.i;
606            inf->totalSize         += length->val.i;
607        }
608    }
609    else if( tr_bencIsInt( length ) )
610    {
611        char buf[4096];
612
613        /* Single-file mode */
614        inf->isMultifile = 0;
615        inf->fileCount = 1;
616        inf->files     = calloc( 1, sizeof( inf->files[0] ) );
617
618        if( !inf->files )
619            return TR_EINVALID;
620
621        memset( buf, 0, sizeof( buf ) );
622        strlcat_utf8( buf, name->val.s.s, sizeof(buf), TR_PATH_DELIMITER );
623        tr_free( inf->files[0].name );
624        inf->files[0].name = tr_strdup( buf );
625
626        inf->files[0].length = length->val.i;
627        inf->totalSize      += length->val.i;
628    }
629    else
630    {
631        tr_nerr( inf->name, _( "Invalid or missing metadata entries \"length\" and \"files\"" ) );
632    }
633
634    return TR_OK;
635}
Note: See TracBrowser for help on using the repository browser.