source: trunk/libtransmission/metainfo.c @ 5611

Last change on this file since 5611 was 5611, checked in by charles, 14 years ago

'resume' cleanup

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