transmission/libtransmission/metainfo.c

480 lines
14 KiB
C
Raw Normal View History

2006-07-16 19:39:23 +00:00
/******************************************************************************
* $Id$
*
2008-01-01 17:20:20 +00:00
* Copyright (c) 2005-2008 Transmission authors and contributors
2006-07-16 19:39:23 +00:00
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
2007-11-09 20:07:52 +00:00
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
2007-07-12 17:51:45 +00:00
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h> /* unlink, stat */
#include <event.h> /* struct evbuffer */
2006-07-16 19:39:23 +00:00
#include "transmission.h"
2007-07-09 20:10:42 +00:00
#include "bencode.h"
#include "crypto.h" /* tr_sha1 */
2007-07-09 20:10:42 +00:00
#include "metainfo.h"
#include "platform.h"
#include "utils.h"
2006-07-16 19:39:23 +00:00
2007-10-20 15:17:36 +00:00
/***
****
***/
static char*
2008-04-14 11:52:50 +00:00
getTorrentFilename( const tr_handle * handle,
const tr_info * inf )
2008-04-14 11:52:50 +00:00
{
return tr_strdup_printf( "%s%c%s.%16.16s.torrent",
tr_getTorrentDir( handle ),
TR_PATH_DELIMITER,
inf->name,
inf->hashString );
2008-04-14 11:52:50 +00:00
}
static char*
2008-08-20 21:01:17 +00:00
getOldTorrentFilename( const tr_handle * handle,
const tr_info * inf )
{
char * ret;
struct evbuffer * buf = evbuffer_new( );
2008-08-20 21:01:17 +00:00
evbuffer_add_printf( buf, "%s%c%s", tr_getTorrentDir( handle ),
TR_PATH_DELIMITER,
inf->hashString );
if( handle->tag )
evbuffer_add_printf( buf, "-%s", handle->tag );
2008-08-20 21:01:17 +00:00
ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
evbuffer_free( buf );
return ret;
}
2008-04-14 11:52:50 +00:00
void
tr_metainfoMigrate( tr_handle * handle,
tr_info * inf )
2008-04-14 11:52:50 +00:00
{
struct stat new_sb;
2008-08-21 16:12:17 +00:00
char * name = getTorrentFilename( handle, inf );
2008-04-14 11:52:50 +00:00
2008-08-21 16:12:17 +00:00
if( stat( name, &new_sb ) || ( ( new_sb.st_mode & S_IFMT ) != S_IFREG ) )
2008-04-14 11:52:50 +00:00
{
2008-08-20 21:01:17 +00:00
char * old_name = getOldTorrentFilename( handle, inf );
2008-04-14 11:52:50 +00:00
size_t contentLen;
uint8_t * content;
tr_mkdirp( tr_getTorrentDir( handle ), 0777 );
2008-04-14 11:52:50 +00:00
if(( content = tr_loadFile( old_name, &contentLen )))
{
FILE * out;
errno = 0;
2008-08-21 16:12:17 +00:00
out = fopen( name, "wb+" );
if( !out )
{
2008-08-21 16:12:17 +00:00
tr_nerr( inf->name, _( "Couldn't create \"%1$s\": %2$s" ),
name, tr_strerror( errno ) );
}
else
{
2008-08-21 16:12:17 +00:00
if( fwrite( content, sizeof( uint8_t ), contentLen, out )
== contentLen )
{
tr_free( inf->torrent );
2008-08-21 16:12:17 +00:00
inf->torrent = tr_strdup( name );
tr_sessionSetTorrentFile( handle, inf->hashString, name );
unlink( old_name );
}
fclose( out );
}
2008-04-14 11:52:50 +00:00
}
tr_free( content );
tr_free( old_name );
2008-04-14 11:52:50 +00:00
}
2008-08-21 16:12:17 +00:00
tr_free( name );
2008-04-14 11:52:50 +00:00
}
2008-08-20 21:01:17 +00:00
/***
****
***/
static int
getfile( char ** setme, const char * root, tr_benc * path )
{
int err;
if( !tr_bencIsList( path ) )
{
err = TR_EINVALID;
}
else
{
struct evbuffer * buf = evbuffer_new( );
int n = tr_bencListSize( path );
int i;
evbuffer_add( buf, root, strlen( root ) );
for( i=0; i<n; ++i ) {
const char * str;
2008-08-21 16:12:17 +00:00
if( tr_bencGetStr( tr_bencListChild( path, i ), &str )
&& strcmp( str, ".." ) ) {
2008-08-20 21:01:17 +00:00
evbuffer_add( buf, TR_PATH_DELIMITER_STR, 1 );
evbuffer_add( buf, str, strlen( str ) );
}
}
*setme = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
/* fprintf( stderr, "[%s]\n", *setme ); */
evbuffer_free( buf );
err = TR_OK;
}
return err;
}
static const char*
2008-08-21 16:12:17 +00:00
parseFiles( tr_info * inf, tr_benc * files, const tr_benc * length )
2008-08-20 21:01:17 +00:00
{
2008-08-21 16:12:17 +00:00
int64_t len;
2008-08-20 21:01:17 +00:00
inf->totalSize = 0;
if( tr_bencIsList( files ) ) /* multi-file mode */
{
2008-08-21 16:12:17 +00:00
tr_file_index_t i;
2008-08-20 21:01:17 +00:00
inf->isMultifile = 1;
inf->fileCount = tr_bencListSize( files );
inf->files = tr_new0( tr_file, inf->fileCount );
for( i=0; i<inf->fileCount; ++i )
{
tr_benc * file;
tr_benc * path;
int64_t length;
file = tr_bencListChild( files, i );
if( !tr_bencIsDict( file ) )
return "files";
if( !tr_bencDictFindList( file, "path.utf-8", &path ) )
if( !tr_bencDictFindList( file, "path", &path ) )
return "path";
if( getfile( &inf->files[i].name, inf->name, path ) )
return "path";
if( !tr_bencDictFindInt( file, "length", &length ) )
return "length";
inf->files[i].length = length;
inf->totalSize += length;
}
}
2008-08-21 16:12:17 +00:00
else if( tr_bencGetInt( length, &len ) ) /* single-file mode */
2008-08-20 21:01:17 +00:00
{
inf->isMultifile = 0;
inf->fileCount = 1;
inf->files = tr_new0( tr_file, 1 );
inf->files[0].name = tr_strdup( inf->name );
2008-08-21 16:12:17 +00:00
inf->files[0].length = len;
inf->totalSize += len;
2008-08-20 21:01:17 +00:00
}
else
{
return "length";
}
return NULL;
}
2008-04-24 03:26:36 +00:00
static char *
announceToScrape( const char * announce )
{
char * scrape = NULL;
const char * s;
/* To derive the scrape URL use the following steps:
* Begin with the announce URL. Find the last '/' in it.
* If the text immediately following that '/' isn't 'announce'
* it will be taken as a sign that that tracker doesn't support
* the scrape convention. If it does, substitute 'scrape' for
* 'announce' to find the scrape page. */
if((( s = strrchr( announce, '/' ))) && !strncmp( ++s, "announce", 8 ))
{
struct evbuffer * buf = evbuffer_new( );
evbuffer_add( buf, announce, s-announce );
evbuffer_add( buf, "scrape", 6 );
evbuffer_add_printf( buf, "%s", s+8 );
2008-08-21 16:12:17 +00:00
scrape = tr_strdup( EVBUFFER_DATA( buf ) );
2008-04-24 03:26:36 +00:00
evbuffer_free( buf );
}
return scrape;
}
2008-08-20 21:01:17 +00:00
static const char*
2008-04-24 03:26:36 +00:00
getannounce( tr_info * inf, tr_benc * meta )
{
const char * str;
tr_tracker_info * trackers = NULL;
int trackerCount = 0;
tr_benc * tiers;
/* Announce-list */
if( tr_bencDictFindList( meta, "announce-list", &tiers ) )
{
int n;
int i, j;
2008-08-21 16:12:17 +00:00
const int numTiers = tr_bencListSize( tiers );
2008-04-24 03:26:36 +00:00
n = 0;
2008-08-21 16:12:17 +00:00
for( i=0; i<numTiers; ++i )
n += tr_bencListSize( tr_bencListChild( tiers, i ) );
2008-04-24 03:26:36 +00:00
trackers = tr_new0( tr_tracker_info, n );
trackerCount = 0;
2008-08-21 16:12:17 +00:00
for( i=0; i<numTiers; ++i ) {
tr_benc * tier = tr_bencListChild( tiers, i );
const int tierSize = tr_bencListSize( tier );
for( j=0; j<tierSize; ++j ) {
if( tr_bencGetStr( tr_bencListChild( tier, j ), &str ) ) {
char * url = tr_strstrip( tr_strdup( str ) );
if( tr_httpIsValidURL( url ) ) {
tr_tracker_info * t = trackers + trackerCount++;
t->tier = i;
t->announce = tr_strdup( url );
t->scrape = announceToScrape( url );
}
tr_free( url );
2008-04-24 03:26:36 +00:00
}
}
}
/* did we use any of the tiers? */
if( !trackerCount ) {
tr_free( trackers );
trackers = NULL;
}
}
/* Regular announce value */
if( !trackerCount
&& tr_bencDictFindStr( meta, "announce", &str ) )
2008-04-24 03:26:36 +00:00
{
char * url = tr_strstrip( tr_strdup( str ) );
if( tr_httpIsValidURL( url ) )
{
trackers = tr_new0( tr_tracker_info, 1 );
trackers[trackerCount].tier = 0;
trackers[trackerCount].announce = tr_strdup( url );
trackers[trackerCount++].scrape = announceToScrape( url );
/*fprintf( stderr, "single announce: [%s]\n", url );*/
}
tr_free( url );
2008-04-24 03:26:36 +00:00
}
inf->trackers = trackers;
inf->trackerCount = trackerCount;
2008-08-20 21:01:17 +00:00
return inf->trackerCount ? NULL : "announce";
}
static void
geturllist( tr_info * inf, tr_benc * meta )
{
tr_benc * urls;
2008-08-20 21:01:17 +00:00
if( tr_bencDictFindList( meta, "url-list", &urls ) )
{
int i;
const char * url;
const int n = tr_bencListSize( urls );
inf->webseedCount = 0;
inf->webseeds = tr_new0( char*, n );
2008-08-20 21:01:17 +00:00
for( i=0; i<n; ++i )
if( tr_bencGetStr( tr_bencListChild( urls, i ), &url ) )
inf->webseeds[inf->webseedCount++] = tr_strdup( url );
}
2008-04-24 03:26:36 +00:00
}
2008-08-20 21:01:17 +00:00
static const char*
tr_metainfoParseImpl( const tr_handle * handle,
tr_info * inf,
const tr_benc * meta_in )
2007-12-21 22:18:40 +00:00
{
2008-08-20 19:21:57 +00:00
int64_t i;
2008-08-20 21:01:17 +00:00
size_t raw_len;
2008-08-20 19:21:57 +00:00
const char * str;
const uint8_t * raw;
tr_benc * beInfo;
tr_benc * meta = (tr_benc *) meta_in;
2007-12-21 22:18:40 +00:00
/* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
* from the Metainfo file. Note that the value will be a bencoded
* dictionary, given the definition of the info key above. */
2008-08-20 21:01:17 +00:00
if( !tr_bencDictFindDict( meta, "info", &beInfo ) )
return "info";
else {
2007-12-21 22:18:40 +00:00
int len;
char * str = tr_bencSave( beInfo, &len );
tr_sha1( inf->hash, str, len, NULL );
2008-08-20 19:21:57 +00:00
tr_sha1_to_hex( inf->hashString, inf->hash );
2007-12-21 22:18:40 +00:00
tr_free( str );
}
2008-08-20 19:21:57 +00:00
/* name */
if( !tr_bencDictFindStr( beInfo, "name.utf-8", &str ) )
if( !tr_bencDictFindStr( beInfo, "name", &str ) )
2008-08-20 21:01:17 +00:00
str = "";
if( !str || !*str )
return "name";
2008-08-20 19:21:57 +00:00
tr_free( inf->name );
inf->name = tr_strdup( str );
2006-07-16 19:39:23 +00:00
/* comment */
2008-08-20 19:21:57 +00:00
if( !tr_bencDictFindStr( meta, "comment.utf-8", &str ) )
if( !tr_bencDictFindStr( meta, "comment", &str ) )
str = "";
tr_free( inf->comment );
2008-08-20 19:21:57 +00:00
inf->comment = tr_strdup( str );
2008-08-20 21:01:17 +00:00
/* created by */
2008-08-20 19:21:57 +00:00
if( !tr_bencDictFindStr( meta, "created by.utf-8", &str ) )
if( !tr_bencDictFindStr( meta, "created by", &str ) )
str = "";
tr_free( inf->creator );
2008-08-20 19:21:57 +00:00
inf->creator = tr_strdup( str );
2008-08-20 21:01:17 +00:00
/* creation date */
2008-08-20 19:21:57 +00:00
if( !tr_bencDictFindInt( meta, "creation date", &i ) )
i = 0;
inf->dateCreated = i;
2008-08-20 21:01:17 +00:00
/* private */
2008-08-20 19:21:57 +00:00
if( !tr_bencDictFindInt( beInfo, "private", &i ) )
if( !tr_bencDictFindInt( meta, "private", &i ) )
i = 0;
inf->isPrivate = i != 0;
2008-08-20 21:01:17 +00:00
/* piece length */
if( !tr_bencDictFindInt( beInfo, "piece length", &i ) || ( i < 1 ) )
return "piece length";
inf->pieceSize = i;
/* pieces */
if( !tr_bencDictFindRaw( beInfo, "pieces", &raw, &raw_len ) || ( raw_len % SHA_DIGEST_LENGTH ) )
return "pieces";
inf->pieceCount = raw_len / SHA_DIGEST_LENGTH;
2008-08-20 19:21:57 +00:00
inf->pieces = tr_new0( tr_piece, inf->pieceCount );
2008-08-20 21:01:17 +00:00
for ( i=0; i<inf->pieceCount; ++i )
memcpy( inf->pieces[i].hash, &raw[i*SHA_DIGEST_LENGTH], SHA_DIGEST_LENGTH );
2008-08-20 19:21:57 +00:00
/* files */
2008-08-20 21:01:17 +00:00
if(( str = parseFiles( inf, tr_bencDictFind( beInfo, "files" ), tr_bencDictFind( beInfo, "length" ))))
return str;
2008-08-20 19:21:57 +00:00
if( !inf->fileCount || !inf->totalSize )
2008-08-20 21:01:17 +00:00
return "files";
if( (uint64_t) inf->pieceCount != ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
return "files";
/* get announce or announce-list */
2008-08-20 21:01:17 +00:00
if(( str = getannounce( inf, meta ) ))
return str;
2006-07-16 19:39:23 +00:00
/* get the url-list */
geturllist( inf, meta );
2008-04-14 11:52:50 +00:00
/* filename of Transmission's copy */
tr_free( inf->torrent );
inf->torrent = getTorrentFilename( handle, inf );
2008-04-14 11:52:50 +00:00
2008-08-20 21:01:17 +00:00
return NULL;
}
2008-08-20 21:01:17 +00:00
int
tr_metainfoParse( const tr_handle * handle,
tr_info * inf,
const tr_benc * meta_in )
{
const char * badTag = tr_metainfoParseImpl( handle, inf, meta_in );
if( badTag )
{
tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), badTag );
tr_metainfoFree( inf );
return TR_EINVALID;
}
return TR_OK;
2006-07-16 19:39:23 +00:00
}
2008-08-20 21:01:17 +00:00
void
tr_metainfoFree( tr_info * inf )
{
tr_file_index_t ff;
int i;
for( i=0; i<inf->webseedCount; ++i )
tr_free( inf->webseeds[i] );
for( ff=0; ff<inf->fileCount; ++ff )
tr_free( inf->files[ff].name );
tr_free( inf->webseeds );
tr_free( inf->pieces );
tr_free( inf->files );
tr_free( inf->comment );
tr_free( inf->creator );
tr_free( inf->torrent );
tr_free( inf->name );
for( i=0; i<inf->trackerCount; ++i ) {
tr_free( inf->trackers[i].announce );
tr_free( inf->trackers[i].scrape );
}
tr_free( inf->trackers );
memset( inf, '\0', sizeof(tr_info) );
}
void
tr_metainfoRemoveSaved( const tr_handle * handle,
2008-04-14 11:52:50 +00:00
const tr_info * inf )
2006-07-16 19:39:23 +00:00
{
char * filename;
2006-07-16 19:39:23 +00:00
filename = getTorrentFilename( handle, inf );
2008-04-14 11:52:50 +00:00
unlink( filename );
tr_free( filename );
2008-08-20 21:01:17 +00:00
filename = getOldTorrentFilename( handle, inf );
2008-04-14 11:52:50 +00:00
unlink( filename );
tr_free( filename );
}