source: trunk/libtransmission/metainfo.c @ 5034

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

#706: save a little more memory by doing the same for tr_info.comment and tr_info.creator

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