source: trunk/libtransmission/metainfo.c @ 6601

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

allocate torrent/resume filenames on the heap instead of the stack

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