torrent.c

/*
 * This file Copyright (C) Mnemosyne LLC
 *
 * This file is licensed by the GPL version 2. Works owned by the
 * Transmission project are granted a special exemption to clause 2(b)
 * so that the bulk of its code can remain under the MIT license.
 * This exemption does not extend to derived works not owned by
 * the Transmission project.
 *
 * $Id: torrent.c 12931 2011-09-28 16:06:19Z jordan $
 */

#include<signal.h>/* signal() */
#include<sys/types.h>/* stat */
#include<sys/stat.h>/* stat */
#ifndefWIN32
#include<sys/wait.h>/* wait() */
#else
#include<process.h>
#definewaitpid(pid, status, options) _cwait(status, pid, WAIT_CHILD)
#endif
#include<unistd.h>/* stat */
#include<dirent.h>

#include<assert.h>
#include<math.h>
#include<stdarg.h>
#include<string.h>/* memcmp */
#include<stdlib.h>/* qsort */
#include<stdio.h>/* remove() */

#include<event2/util.h>/* evutil_vsnprintf() */

#include"transmission.h"
#include"announcer.h"
#include"bandwidth.h"
#include"bencode.h"
#include"cache.h"
#include"completion.h"
#include"crypto.h"/* for tr_sha1 */
#include"resume.h"
#include"fdlimit.h"/* tr_fdTorrentClose */
#include"inout.h"/* tr_ioTestPiece() */
#include"list.h"
#include"magnet.h"
#include"metainfo.h"
#include"peer-common.h"/* MAX_BLOCK_SIZE */
#include"peer-mgr.h"
#include"platform.h"/* TR_PATH_DELIMITER_STR */
#include"ptrarray.h"
#include"session.h"
#include"torrent.h"
#include"torrent-magnet.h"
#include"trevent.h"/* tr_runInEventThread() */
#include"utils.h"
#include"verify.h"
#include"version.h"

/***
****
***/

#definetr_deeplog_tor( tor, ... ) \
 do { \
 if( tr_deepLoggingIsActive( ) ) \
 tr_deepLog( __FILE__, __LINE__, tr_torrentName( tor ), __VA_ARGS__ ); \
 } while( 0 )

/***
****
***/

constchar*
tr_torrentName( consttr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

returntor->info.name;
}

int
tr_torrentId( consttr_torrent*tor )
{
returntor->uniqueId;
}

tr_torrent*
tr_torrentFindFromId( tr_session*session, intid )
{
tr_torrent*tor=NULL;

while(( tor=tr_torrentNext( session, tor )))
if( tor->uniqueId==id )
returntor;

returnNULL;
}

tr_torrent*
tr_torrentFindFromHashString( tr_session*session, constchar*str )
{
tr_torrent*tor=NULL;

while(( tor=tr_torrentNext( session, tor )))
if( !evutil_ascii_strcasecmp( str, tor->info.hashString ) )
returntor;

returnNULL;
}

tr_torrent*
tr_torrentFindFromHash( tr_session*session, constuint8_t*torrentHash )
{
tr_torrent*tor=NULL;

while(( tor=tr_torrentNext( session, tor )))
if( *tor->info.hash==*torrentHash )
if( !memcmp( tor->info.hash, torrentHash, SHA_DIGEST_LENGTH ) )
returntor;

returnNULL;
}

tr_torrent*
tr_torrentFindFromMagnetLink( tr_session*session, constchar*magnet )
{
tr_magnet_info*info;
tr_torrent*tor=NULL;

if(( info=tr_magnetParse( magnet )))
 {
tor=tr_torrentFindFromHash( session, info->hash );
tr_magnetFree( info );
 }

returntor;
}

tr_torrent*
tr_torrentFindFromObfuscatedHash( tr_session*session,
constuint8_t*obfuscatedTorrentHash )
{
tr_torrent*tor=NULL;

while(( tor=tr_torrentNext( session, tor )))
if( !memcmp( tor->obfuscatedHash, obfuscatedTorrentHash,
SHA_DIGEST_LENGTH ) )
returntor;

returnNULL;
}

bool
tr_torrentIsPieceTransferAllowed( consttr_torrent*tor,
tr_directiondirection )
{
intlimit;
boolallowed= true;

if( tr_torrentUsesSpeedLimit( tor, direction ) )
if( tr_torrentGetSpeedLimit_Bps( tor, direction ) <= 0 )
allowed= false;

if( tr_torrentUsesSessionLimits( tor ) )
if( tr_sessionGetActiveSpeedLimit_Bps( tor->session, direction, &limit ) )
if( limit <= 0 )
allowed= false;

returnallowed;
}

/***
**** PER-TORRENT UL / DL SPEEDS
***/

void
tr_torrentSetSpeedLimit_Bps( tr_torrent*tor, tr_directiondir, intBps )
{
assert( tr_isTorrent( tor ) );
assert( tr_isDirection( dir ) );
assert( Bps >= 0 );

if( tr_bandwidthSetDesiredSpeed_Bps( &tor->bandwidth, dir, Bps ) )
tr_torrentSetDirty( tor );
}
void
tr_torrentSetSpeedLimit_KBps( tr_torrent*tor, tr_directiondir, intKBps )
{
tr_torrentSetSpeedLimit_Bps( tor, dir, toSpeedBytes( KBps ) );
}

int
tr_torrentGetSpeedLimit_Bps( consttr_torrent*tor, tr_directiondir )
{
assert( tr_isTorrent( tor ) );
assert( tr_isDirection( dir ) );

returntr_bandwidthGetDesiredSpeed_Bps( &tor->bandwidth, dir );
}
int
tr_torrentGetSpeedLimit_KBps( consttr_torrent*tor, tr_directiondir )
{
returntoSpeedKBps( tr_torrentGetSpeedLimit_Bps( tor, dir ) );
}

void
tr_torrentUseSpeedLimit( tr_torrent*tor, tr_directiondir, booldo_use )
{
assert( tr_isTorrent( tor ) );
assert( tr_isDirection( dir ) );

if( tr_bandwidthSetLimited( &tor->bandwidth, dir, do_use ) )
tr_torrentSetDirty( tor );
}

bool
tr_torrentUsesSpeedLimit( consttr_torrent*tor, tr_directiondir )
{
assert( tr_isTorrent( tor ) );
assert( tr_isDirection( dir ) );

returntr_bandwidthIsLimited( &tor->bandwidth, dir );
}

void
tr_torrentUseSessionLimits( tr_torrent*tor, booldoUse )
{
boolchanged;

assert( tr_isTorrent( tor ) );

changed=tr_bandwidthHonorParentLimits( &tor->bandwidth, TR_UP, doUse );
changed |= tr_bandwidthHonorParentLimits( &tor->bandwidth, TR_DOWN, doUse );

if( changed )
tr_torrentSetDirty( tor );
}

bool
tr_torrentUsesSessionLimits( consttr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

returntr_bandwidthAreParentLimitsHonored( &tor->bandwidth, TR_UP );
}

/***
****
***/

void
tr_torrentSetCheatMode( tr_torrent*tor, tr_cheatMode_tmode )
{
assert( tr_isTorrent( tor ) );

if( ( mode >= TR_CHEAT_DEACT&&mode<TR_CHEAT_COUNT ) &&mode!=tor->cheatMode )
 {
tor->cheatMode=mode;

tr_torrentSetDirty( tor );
 }
}

tr_cheatMode_t
tr_torrentGetCheatMode( consttr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

returntor->cheatMode;
}

void
tr_torrentSetRatioMode( tr_torrent*tor, tr_ratiolimitmode )
{
assert( tr_isTorrent( tor ) );
assert( mode==TR_RATIOLIMIT_GLOBAL||mode==TR_RATIOLIMIT_SINGLE||mode==TR_RATIOLIMIT_UNLIMITED );

if( mode!=tor->ratioLimitMode )
 {
tor->ratioLimitMode=mode;

tr_torrentSetDirty( tor );
 }
}

tr_ratiolimit
tr_torrentGetRatioMode( consttr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

returntor->ratioLimitMode;
}

void
tr_torrentSetRatioLimit( tr_torrent*tor, doubledesiredRatio )
{
assert( tr_isTorrent( tor ) );

if( (int)(desiredRatio*100.0) != (int)(tor->desiredRatio*100.0) )
 {
tor->desiredRatio=desiredRatio;

tr_torrentSetDirty( tor );
 }
}

double
tr_torrentGetRatioLimit( consttr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

returntor->desiredRatio;
}

bool
tr_torrentGetSeedRatio( consttr_torrent*tor, double*ratio )
{
boolisLimited;

switch( tr_torrentGetRatioMode( tor ) )
 {
caseTR_RATIOLIMIT_SINGLE:
isLimited= true;
if( ratio )
*ratio=tr_torrentGetRatioLimit( tor );
break;

caseTR_RATIOLIMIT_GLOBAL:
isLimited=tr_sessionIsRatioLimited( tor->session );
if( isLimited&&ratio )
*ratio=tr_sessionGetRatioLimit( tor->session );
break;

default: /* TR_RATIOLIMIT_UNLIMITED */
isLimited= false;
break;
 }

returnisLimited;
}

/* returns true if the seed ratio applies --
 * it applies if the torrent's a seed AND it has a seed ratio set */
staticbool
tr_torrentGetSeedRatioBytes( tr_torrent*tor,
uint64_t*setmeLeft,
uint64_t*setmeGoal )
{
doubleseedRatio;
boolseedRatioApplies= false;

if( tr_torrentGetSeedRatio( tor, &seedRatio ) )
 {
constuint64_tu=tor->uploadedCur+tor->uploadedPrev;
constuint64_td=tor->downloadedCur+tor->downloadedPrev;
constuint64_tbaseline=d ? d : tr_cpSizeWhenDone( &tor->completion );
constuint64_tgoal=baseline*seedRatio;
if( setmeLeft ) *setmeLeft=goal>u ? goal-u : 0;
if( setmeGoal ) *setmeGoal=goal;
seedRatioApplies=tr_torrentIsSeed( tor );
 }

returnseedRatioApplies;
}

staticbool
tr_torrentIsSeedRatioDone( tr_torrent*tor )
{
uint64_tbytesLeft;
returntr_torrentGetSeedRatioBytes( tor, &bytesLeft, NULL ) && !bytesLeft;
}

/***
****
***/

void
tr_torrentSetIdleMode( tr_torrent*tor, tr_idlelimitmode )
{
assert( tr_isTorrent( tor ) );
assert( mode==TR_IDLELIMIT_GLOBAL||mode==TR_IDLELIMIT_SINGLE||mode==TR_IDLELIMIT_UNLIMITED );

if( mode!=tor->idleLimitMode )
 {
tor->idleLimitMode=mode;

tr_torrentSetDirty( tor );
 }
}

tr_idlelimit
tr_torrentGetIdleMode( consttr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

returntor->idleLimitMode;
}

void
tr_torrentSetIdleLimit( tr_torrent*tor, uint16_tidleMinutes )
{
assert( tr_isTorrent( tor ) );

if( idleMinutes>0 )
 {
tor->idleLimitMinutes=idleMinutes;

tr_torrentSetDirty( tor );
 }
}

uint16_t
tr_torrentGetIdleLimit( consttr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

returntor->idleLimitMinutes;
}

bool
tr_torrentGetSeedIdle( consttr_torrent*tor, uint16_t*idleMinutes )
{
boolisLimited;

switch( tr_torrentGetIdleMode( tor ) )
 {
caseTR_IDLELIMIT_SINGLE:
isLimited= true;
if( idleMinutes )
*idleMinutes=tr_torrentGetIdleLimit( tor );
break;

caseTR_IDLELIMIT_GLOBAL:
isLimited=tr_sessionIsIdleLimited( tor->session );
if( isLimited&&idleMinutes )
*idleMinutes=tr_sessionGetIdleLimit( tor->session );
break;

default: /* TR_IDLELIMIT_UNLIMITED */
isLimited= false;
break;
 }

returnisLimited;
}

staticbool
tr_torrentIsSeedIdleLimitDone( tr_torrent*tor )
{
uint16_tidleMinutes;
returntr_torrentGetSeedIdle( tor, &idleMinutes )
&&difftime(tr_time(), MAX(tor->startDate, tor->activityDate)) >= idleMinutes*60u;
}

/***
****
***/

void
tr_torrentCheckSeedLimit( tr_torrent*tor )
{
assert( tr_isTorrent( tor ) );

if( !tor->isRunning|| !tr_torrentIsSeed( tor ) ||tor->isStopping )
return;

/* if we're seeding and reach our seed ratio limit, stop the torrent */
if( tr_torrentIsSeedRatioDone( tor ) )
 {
tr_torinf( tor, "Seed ratio reached; pausing torrent" );

tor->isStopping= true;

/* maybe notify the client */
if( tor->ratio_limit_hit_func!=NULL )
tor->ratio_limit_hit_func( tor, tor->ratio_limit_hit_func_user_data );
 }
/* if we're seeding and reach our inactiviy limit, stop the torrent */
elseif( tr_torrentIsSeedIdleLimitDone( tor ) )
 {
tr_torinf( tor, "Seeding idle limit reached; pausing torrent" );

tor->isStopping= true;
tor->finishedSeedingByIdle= true;

/* maybe notify the client */
if( tor->idle_limit_hit_func!=NULL )
tor->idle_limit_hit_func( tor, tor->idle_limit_hit_func_user_data );
 }
}

/***
****
***/

void
tr_torrentSetLocalError( tr_torrent*tor, constchar*fmt, ... )
{
va_listap;

assert( tr_isTorrent( tor ) );

va_start( ap, fmt );
tor->error=TR_STAT_LOCAL_ERROR;
tor->errorTracker[0] ='\0';
evutil_vsnprintf( tor->errorString, sizeof( tor->errorString ), fmt, ap );
va_end( ap );

tr_torerr( tor, "%s", tor->errorString );

if( tor->isRunning )
tor->isStopping= true;
}

staticvoid
tr_torrentClearError( tr_torrent*tor )
{
tor->error=TR_STAT_OK;
tor->errorString[0] ='\0';
tor->errorTracker[0] ='\0';
}

staticvoid
onTrackerResponse( tr_torrent*tor, consttr_tracker_event*event, void*unusedUNUSED )
{
switch( event->messageType )
 {
caseTR_TRACKER_PEERS:
 {
size_ti;
constint8_tseedProbability=event->seedProbability;
constboolallAreSeeds=seedProbability==100;

if( allAreSeeds )
tr_tordbg( tor, "Got %zu seeds from tracker", event->pexCount );
else
tr_tordbg( tor, "Got %zu peers from tracker", event->pexCount );

for( i=0; i<event->pexCount; ++i )
tr_peerMgrAddPex( tor, TR_PEER_FROM_TRACKER, &event->pex[i], seedProbability );

break;
 }

caseTR_TRACKER_WARNING:
tr_torerr( tor, _( "Tracker warning: \"%s\"" ), event->text );
tor->error=TR_STAT_TRACKER_WARNING;
tr_strlcpy( tor->errorTracker, event->tracker, sizeof( tor->errorTracker ) );
tr_strlcpy( tor->errorString, event->text, sizeof( tor->errorString ) );
break;

caseTR_TRACKER_ERROR:
tr_torerr( tor, _( "Tracker error: \"%s\"" ), event->text );
tor->error=TR_STAT_TRACKER_ERROR;
tr_strlcpy( tor->errorTracker, event->tracker, sizeof( tor->errorTracker ) );
tr_strlcpy( tor->errorString, event->text, sizeof( tor->errorString ) );
break;

caseTR_TRACKER_ERROR_CLEAR:
if( tor->error!=TR_STAT_LOCAL_ERROR )
tr_torrentClearError( tor );
break;
 }
}

/***
****
**** TORRENT INSTANTIATION
****
***/

statictr_piece_index_t
getBytePiece( consttr_info*info, uint64_tbyteOffset )
{
tr_piece_index_tpiece;
assert( info );
assert( info->pieceSize!=0 );

piece=byteOffset / info->pieceSize;

/* handle 0-byte files at the end of a torrent */
if (byteOffset==info->totalSize)
piece=info->pieceCount-1;

returnpiece;
}

staticvoid
initFilePieces( tr_info*info,
tr_file_index_tfileIndex )
{
tr_file*file;
uint64_tfirstByte, lastByte;

assert( info );
assert( fileIndex<info->fileCount );

file=&info->files[fileIndex];
firstByte=file->offset;
lastByte=firstByte+ ( file->length ? file->length-1 : 0 );
file->firstPiece=getBytePiece( info, firstByte );
file->lastPiece=getBytePiece( info, lastByte );
}

staticint
pieceHasFile( tr_piece_index_tpiece,
consttr_file*file )
{
return ( file->firstPiece <= piece ) && ( piece <= file->lastPiece );
}

statictr_priority_t
calculatePiecePriority( consttr_torrent*tor,
tr_piece_index_tpiece,
intfileHint )
{
tr_file_index_ti;
tr_priority_tpriority=TR_PRI_LOW;

/* find the first file that has data in this piece */
if( fileHint >= 0 ) {
i=fileHint;
while( i>0&&pieceHasFile( piece, &tor->info.files[i-1] ) )
--i;
 } else {
for( i=0; i<tor->info.fileCount; ++i )
if( pieceHasFile( piece, &tor->info.files[i] ) )
break;
 }

/* the piece's priority is the max of the priorities
 * of all the files in that piece */
for( ; i<tor->info.fileCount; ++i )
 {
consttr_file*file=&tor->info.files[i];

if( !pieceHasFile( piece, file ) )
break;

priority=MAX( priority, file->priority );

/* when dealing with multimedia files, getting the first and
 last pieces can sometimes allow you to preview it a bit
 before it's fully downloaded... */
if( file->priority >= TR_PRI_NORMAL )
if( file->firstPiece==piece||file->lastPiece==piece )
priority=TR_PRI_HIGH;
 }

returnpriority;
}

staticvoid
tr_torrentInitFilePieces( tr_torrent*tor )
{
int*firstFiles;
tr_file_index_tf;
tr_piece_index_tp;
uint64_toffset=0;
tr_info*inf=&tor->info;

/* assign the file offsets */
for( f=0; f<inf->fileCount; ++f ) {
inf->files[f].offset=offset;
offset+=inf->files[f].length;
initFilePieces( inf, f );
 }

/* build the array of first-file hints to give calculatePiecePriority */
firstFiles=tr_new( int, inf->pieceCount );
for( p=f=0; p<inf->pieceCount; ++p ) {
while( inf->files[f].lastPiece<p )
++f;
firstFiles[p] =f;
 }

#if0
/* test to confirm the first-file hints are correct */
for( p=0; p<inf->pieceCount; ++p ) {
f=firstFiles[p];
assert( inf->files[f].firstPiece <= p );
assert( inf->files[f].lastPiece >= p );
if( f>0 )
assert( inf->files[f-1].lastPiece<p );
for( f=0; f<inf->fileCount; ++f )
if( pieceHasFile( p, &inf->files[f] ) )
break;
assert( (int)f==firstFiles[p] );
 }
#endif

for( p=0; p<inf->pieceCount; ++p )
inf->pieces[p].priority=calculatePiecePriority( tor, p, firstFiles[p] );

tr_free( firstFiles );
}

staticvoidtorrentStart( tr_torrent*tor, boolbypass_queue );

/**
 * Decide on a block size. Constraints:
 * (1) most clients decline requests over 16 KiB
 * (2) pieceSize must be a multiple of block size
 */
uint32_t
tr_getBlockSize( uint32_tpieceSize )
{
uint32_tb=pieceSize;

while( b>MAX_BLOCK_SIZE )
b /= 2u;

if( !b|| ( pieceSize % b ) ) /* not cleanly divisible */
return0;
returnb;
}

staticvoidrefreshCurrentDir( tr_torrent*tor );

staticvoid
torrentInitFromInfo( tr_torrent*tor )
{
uint64_tt;
tr_info*info=&tor->info;

tor->blockSize=tr_getBlockSize( info->pieceSize );

if( info->pieceSize )
tor->lastPieceSize= (uint32_t)(info->totalSize % info->pieceSize);

if( !tor->lastPieceSize )
tor->lastPieceSize=info->pieceSize;

if( tor->blockSize )
tor->lastBlockSize=info->totalSize % tor->blockSize;

if( !tor->lastBlockSize )
tor->lastBlockSize=tor->blockSize;

tor->blockCount=tor->blockSize
 ? ( info->totalSize+tor->blockSize-1 ) / tor->blockSize
 : 0;

tor->blockCountInPiece=tor->blockSize
 ? info->pieceSize / tor->blockSize
 : 0;

tor->blockCountInLastPiece=tor->blockSize
 ? ( tor->lastPieceSize+tor->blockSize-1 ) / tor->blockSize
 : 0;

/* check our work */
if( tor->blockSize!=0 )
assert( ( info->pieceSize % tor->blockSize ) ==0 );
t=info->pieceCount-1;
t *= info->pieceSize;
t+=tor->lastPieceSize;
assert( t==info->totalSize );
t=tor->blockCount-1;
t *= tor->blockSize;
t+=tor->lastBlockSize;
assert( t==info->totalSize );
t=info->pieceCount-1;
t *= tor->blockCountInPiece;
t+=tor->blockCountInLastPiece;
assert( t== (uint64_t)tor->blockCount );

tr_cpConstruct( &tor->completion, tor );

tr_torrentInitFilePieces( tor );

tor->completeness=tr_cpGetStatus( &tor->completion );
}

staticvoidtr_torrentFireMetadataCompleted( tr_torrent*tor );

void
tr_torrentGotNewInfoDict( tr_torrent*tor )
{
torrentInitFromInfo( tor );

tr_peerMgrOnTorrentGotMetainfo( tor );

tr_torrentFireMetadataCompleted( tor );
}

staticbool
hasAnyLocalData( consttr_torrent*tor )
{
tr_file_index_ti;

for( i=0; i<tor->info.fileCount; ++i )
if( tr_torrentFindFile2( tor, i, NULL, NULL, NULL ) )
return true;

return false;
}

staticbool
setLocalErrorIfFilesDisappeared( tr_torrent*tor )
{
constbooldisappeared= ( tr_cpHaveTotal( &tor->completion ) >0 ) && !hasAnyLocalData( tor );

if( disappeared )
 {
tr_deeplog_tor( tor, "%s", "[LAZY] uh oh, the files disappeared" );
tr_torrentSetLocalError( tor, "%s", _( "No data found! Ensure drives connected or use \"Set Location\". To re-download, remove/re-add torrent OR re-verify" ) );
 }

returndisappeared;
}

staticbool
localErrFilesDisappearedUE( tr_torrent*tor )
{
constbooldisappeared= ( tr_cpHaveTotal( &tor->completion ) >0 ) && !hasAnyLocalData( tor );

if( disappeared )
 {
tr_deeplog_tor( tor, "%s", "[LAZY] uh oh WARNING, the files disappeared" );
tr_torrentSetLocalError( tor, "%s", _( "WARNING! possible user error! files MAYBE disappeared!!! to IGNORE: after verify use Start/Resume Now" ) );
 }

returndisappeared;
}

staticboolfileExists( constchar*filename, time_t*optional_mtime );

staticbool
torrentDataExists( consttr_torrent*tor )
{
char*path, *spath;
boolexists;
if( !tr_torrentHasMetadata( tor ) )
return false;
path=tr_buildPath( tr_torrentGetCurrentDir( tor ),
tr_torrentName( tor ), NULL );
exists=fileExists( path, NULL );

if( !exists )
 {
path=NULL;
spath=tr_strdup_printf( "%s.part", tr_torrentName( tor ) );
path=tr_buildPath( tr_torrentGetCurrentDir( tor ), spath, NULL );
exists=fileExists( path, NULL );
if( !exists )
 {
path=NULL;
spath=NULL;
spath=tr_metainfoGetBasename( &tor->info );
path=tr_buildPath( tr_sessionGetPieceTempDir( tor->session ), spath, NULL );
exists=fileExists( path, NULL );
 }
tr_free( spath );
 }
tr_free( path );
returnexists;

}

staticvoid
torrentInit( tr_torrent*tor, consttr_ctor*ctor )
{
char*s;
intdoStart;
uint64_tloaded;
constchar*dir;
boolisNewTorrent;
structstatst;
staticintnextUniqueId=1;
tr_session*session=tr_ctorGetSession( ctor );

assert( session!=NULL );

tr_sessionLock( session );

tor->session=session;
tor->uniqueId=nextUniqueId++;
tor->magicNumber=TORRENT_MAGIC_NUMBER;
tor->queuePosition=session->torrentCount;
tor->reverifyTorrent=tor->session->reverifyTorrents;

tr_peerIdInit( tor->peer_id );

tr_sha1( tor->obfuscatedHash, "req2", 4,
tor->info.hash, SHA_DIGEST_LENGTH,
NULL );

if( !tr_ctorGetDownloadDir( ctor, TR_FORCE, &dir ) ||
 !tr_ctorGetDownloadDir( ctor, TR_FALLBACK, &dir ) )
tor->downloadDir=tr_strdup( dir );

if( tr_ctorGetIncompleteDir( ctor, &dir ) )
dir=tr_sessionGetIncompleteDir( session );
if( tr_sessionIsIncompleteDirEnabled( session ) )
tor->incompleteDir=tr_strdup( dir );

s=tr_metainfoGetBasename( &tor->info );
tor->pieceTempDir=tr_buildPath( tr_sessionGetPieceTempDir( tor->session ), s, NULL );
tr_free( s );

tr_bandwidthConstruct( &tor->bandwidth, session, &session->bandwidth );

tor->bandwidth.priority=tr_ctorGetBandwidthPriority( ctor );

tor->error=TR_STAT_OK;

tor->finishedSeedingByIdle= false;

tr_peerMgrAddTorrent( session->peerMgr, tor );

assert( !tor->downloadedCur );
assert( !tor->uploadedCur );

tr_torrentSetAddedDate( tor, tr_time( ) ); /* this is a default value to be
 overwritten by the resume file */

torrentInitFromInfo( tor );
loaded=tr_torrentLoadResume( tor, ~0, ctor );
tor->completeness=tr_cpGetStatus( &tor->completion );
setLocalErrorIfFilesDisappeared( tor );

tr_ctorInitTorrentPriorities( ctor, tor );
tr_ctorInitTorrentWanted( ctor, tor );

refreshCurrentDir( tor );
tr_mkdirp( tor->pieceTempDir, 0777 );

doStart=tor->isRunning;
tor->isRunning=0;

if( !( loaded&TR_FR_SPEEDLIMIT ) )
 {
tr_torrentUseSpeedLimit( tor, TR_UP, false );
tr_torrentSetSpeedLimit_Bps( tor, TR_UP, tr_sessionGetSpeedLimit_Bps( tor->session, TR_UP ) );
tr_torrentUseSpeedLimit( tor, TR_DOWN, false );
tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, tr_sessionGetSpeedLimit_Bps( tor->session, TR_DOWN ) );
tr_torrentUseSessionLimits( tor, true );
 }

if( !( loaded&TR_FR_RATIOLIMIT ) )
 {
tr_torrentSetRatioMode( tor, TR_RATIOLIMIT_GLOBAL );
tr_torrentSetRatioLimit( tor, tr_sessionGetRatioLimit( tor->session ) );
 }

if( !( loaded&TR_FR_IDLELIMIT ) )
 {
tr_torrentSetIdleMode( tor, TR_IDLELIMIT_GLOBAL );
tr_torrentSetIdleLimit( tor, tr_sessionGetIdleLimit( tor->session ) );
 }

if( !( loaded&TR_FR_CHEATMODE ) )
 {
tr_torrentSetCheatMode( tor, TR_CHEAT_DEACT );
 }
// random float, range 0.0 to 0.1
tor->cheatRand= (float)tr_cryptoRandInt(100000)/1000000;

/* add the torrent to tr_session.torrentList */
session->torrentCount++;
if( session->torrentList==NULL )
session->torrentList=tor;
else {
tr_torrent*it=session->torrentList;
while( it->next!=NULL )
it=it->next;
it->next=tor;
 }

/* if we don't have a local .torrent file already, assume the torrent is new */
isNewTorrent=stat( tor->info.torrent, &st );

/* maybe save our own copy of the metainfo */
if( tr_ctorGetSave( ctor ) )
 {
consttr_benc*val;
if( !tr_ctorGetMetainfo( ctor, &val ) )
 {
constchar*path=tor->info.torrent;
constinterr=tr_bencToFile( val, TR_FMT_BENC, path );
if( err )
tr_torrentSetLocalError( tor, "Unable to save torrent file: %s", tr_strerror( err ) );
tr_sessionSetTorrentFile( tor->session, tor->info.hashString, path );
 }
 }

tor->tiers=tr_announcerAddTorrent( tor, onTrackerResponse, NULL );

if( isNewTorrent )
 {
if( tor->session->prefetchMagnets&& !tr_torrentHasMetadata( tor ) && ( doStart==0 ) )
 {
tor->preFetchMagnet= true;
torrentStart( tor, true );
 }
else
 {
tor->startAfterVerify= false;
tr_torrentVerify( tor );