Changeset 9328

Timestamp:

Oct 19, 2009, 5:05:00 AM (13 years ago)

Author:

charles

Message:

(trunk) #1483: move completed torrents to a user-specified directory + #629: different file extension for incomplete files

Location:

trunk

Files:

• gtk/main.c (modified) (1 diff)
• gtk/tr-prefs.c (modified) (1 diff)
• libtransmission/Makefile.am (modified) (2 diffs)
• libtransmission/fastresume.c (deleted)
• libtransmission/fastresume.h (deleted)
• libtransmission/fdlimit.c (modified) (5 diffs)
• libtransmission/fdlimit.h (modified) (3 diffs)
• libtransmission/inout.c (modified) (2 diffs)
• libtransmission/peer-mgr.c (modified) (2 diffs)
• libtransmission/resume.c (modified) (6 diffs)
• libtransmission/resume.h (modified) (1 diff)
• libtransmission/session.c (modified) (8 diffs)
• libtransmission/session.h (modified) (2 diffs)
• libtransmission/torrent.c (modified) (18 diffs)
• libtransmission/torrent.h (modified) (2 diffs)
• libtransmission/transmission.h (modified) (3 diffs)
• libtransmission/verify.c (modified) (2 diffs)
• macosx/Controller.m (modified) (2 diffs)
• qt/session.cc (modified) (1 diff)

trunk/gtk/main.c

@@ -1127 +1127 @@
         tr_sessionSetPeerPortRandomOnStart( tr, pref_flag_get( key ) );
     }
+    else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR ) )
+    {
+        tr_sessionSetIncompleteDir( tr, pref_string_get( key ) );
+    }
+    else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) )
+    {
+        tr_sessionSetIncompleteDirEnabled( tr, pref_flag_get( key ) );
+    }
 }
 

trunk/gtk/tr-prefs.c

@@ -290 +290 @@
     hig_workarea_add_row_w( t, &row, l, w, NULL );
 #endif
+
+    s = _( "Keep incomplete files in:" );
+    l = new_check_button( s, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, core );
+    w = new_path_chooser_button( TR_PREFS_KEY_INCOMPLETE_DIR, core );
+    gtk_widget_set_sensitive( GTK_WIDGET( w ), pref_flag_get( TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) );
+    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
+    hig_workarea_add_row_w( t, &row, l, w, NULL );
 
     s = _( "Display _options dialog" );

trunk/libtransmission/Makefile.am

@@ -21 +21 @@
     ConvertUTF.c \
     crypto.c \
-    fastresume.c \
     fdlimit.c \
     ggets.c \
@@ -69 +68 @@
     crypto.h \
     completion.h \
-    fastresume.h \
     fdlimit.h \
     ggets.h \

trunk/libtransmission/fdlimit.c

@@ -84 +84 @@
 struct tr_openfile
 {
-    tr_bool    isWritable;
-    int        torrentId;
-    char       filename[MAX_PATH_LENGTH];
-    int        fd;
-    uint64_t   date;
+    tr_bool          isWritable;
+    int              torrentId;
+    tr_file_index_t  fileNum;
+    char             filename[MAX_PATH_LENGTH];
+    int              fd;
+    uint64_t         date;
 };
 
@@ -382 +383 @@
 }
 
+int
+tr_fdFileGetCached( int              torrentId,
+                    tr_file_index_t  fileNum,
+                    tr_bool          doWrite )
+{
+    int i;
+    struct tr_openfile * o;
+
+    assert( torrentId > 0 );
+    assert( tr_isBool( doWrite ) );
+
+    /* is it already open? */
+    for( i=0; i<gFd->openFileLimit; ++i )
+    {
+        o = &gFd->openFiles[i];
+
+        if( !fileIsOpen( o ) )
+            continue;
+        if( torrentId != o->torrentId )
+            continue;
+        if( fileNum != o->fileNum )
+            continue;
+
+        break;
+    }
+
+    if( ( o != NULL ) && ( !doWrite || o->isWritable ) )
+    {
+        o->date = tr_date( );
+        return o->fd;
+    }
+
+    return -1;
+}
+
 /* returns an fd on success, or a -1 on failure and sets errno */
 int
 tr_fdFileCheckout( int                      torrentId,
+                   tr_file_index_t          fileNum,
                    const char             * folder,
                    const char             * torrentFile,
@@ -412 +449 @@
         if( torrentId != o->torrentId )
             continue;
-        if( strcmp( filename, o->filename ) )
+        if( fileNum != o->fileNum )
             continue;
 
@@ -479 +516 @@
     dbgmsg( "checking out '%s' in slot %d", filename, winner );
     o->torrentId = torrentId;
+    o->fileNum = fileNum;
     o->date = tr_date( );
     return o->fd;
@@ -484 +522 @@
 
 void
-tr_fdFileClose( const char * filename )
+tr_fdFileClose( const tr_torrent * tor, tr_file_index_t fileNum )
 {
     struct tr_openfile * o;
     const struct tr_openfile * end;
-
+    const int torrentId = tr_torrentId( tor );
     for( o=gFd->openFiles, end=o+gFd->openFileLimit; o!=end; ++o )
     {
-        if( !fileIsOpen( o ) || strcmp( filename, o->filename ) )
-            continue;
-        dbgmsg( "tr_fdFileClose closing \"%s\"", filename );
+        if( !fileIsOpen( o ) )
+            continue;
+        if( torrentId != o->torrentId )
+            continue;
+        if( fileNum != o->fileNum )
+            continue;
+
+        dbgmsg( "tr_fdFileClose closing \"%s\"", o->filename );
         TrCloseFile( o );
     }

trunk/libtransmission/fdlimit.h

@@ -66 +66 @@
  */
 int  tr_fdFileCheckout( int                      torrentId,
+                        tr_file_index_t          fileNum,
                         const char             * folder,
                         const char             * torrentFile,
@@ -71 +72 @@
                         tr_preallocation_mode    preallocationMode,
                         uint64_t                 desiredFileSize );
+
+int tr_fdFileGetCached( int                      torrentId,
+                        tr_file_index_t          fileNum,
+                        tr_bool                  doWrite );
 
 /**
@@ -80 +85 @@
  * @see tr_fdFileCheckout
  */
-void     tr_fdFileClose( const char * filename );
+void     tr_fdFileClose( const tr_torrent * tor, tr_file_index_t fileNo );
 
 

trunk/libtransmission/inout.c

@@ -76 +76 @@
     const tr_info * info = &tor->info;
     const tr_file * file = &info->files[fileIndex];
-    tr_preallocation_mode preallocationMode;
 
     typedef size_t ( *iofunc )( int, void *, size_t );
@@ -82 +81 @@
     struct stat     sb;
     int             fd = -1;
-    int             err;
-    int             fileExists;
-
-    assert( tor->downloadDir && *tor->downloadDir );
+    int             err = 0;
+    const tr_bool doWrite = ioMode == TR_IO_WRITE;
+
+    assert( tor->currentDir && *tor->currentDir );
     assert( fileIndex < info->fileCount );
     assert( !file->length || ( fileOffset < file->length ) );
     assert( fileOffset + buflen <= file->length );
 
-    {
-        char path[MAX_PATH_LENGTH];
-        tr_snprintf( path, sizeof( path ), "%s%c%s", tor->downloadDir, TR_PATH_DELIMITER, file->name );
-        fileExists = !stat( path, &sb );
-    }
-
     if( !file->length )
         return 0;
 
-    if( ( file->dnd ) || ( ioMode != TR_IO_WRITE ) )
-        preallocationMode = TR_PREALLOCATE_NONE;
-    else
-        preallocationMode = tor->session->preallocationMode;
-
-    if( ( ioMode == TR_IO_READ ) && !fileExists ) /* does file exist? */
-        err = ENOENT;
-    else if( ( fd = tr_fdFileCheckout( tor->uniqueId, tor->downloadDir, file->name, ioMode == TR_IO_WRITE, preallocationMode, file->length ) ) < 0 ) {
-        err = errno;
-        tr_torerr( tor, "tr_fdFileCheckout failed for \"%s\": %s", file->name, tr_strerror( err ) );
-    }
-    else if( tr_lseek( fd, (int64_t)fileOffset, SEEK_SET ) == -1 ) {
-        err = errno;
-        tr_torerr( tor, "tr_lseek failed for \"%s\": %s", file->name, tr_strerror( err ) );
-    }
-    else if( func( fd, buf, buflen ) != buflen ) {
-        err = errno;
-        tr_torerr( tor, "read/write failed for \"%s\": %s", file->name, tr_strerror( err ) );
-    }
-    else
-        err = 0;
-
-    if( ( !err ) && ( !fileExists ) && ( ioMode == TR_IO_WRITE ) )
-        tr_statsFileCreated( tor->session );
+    fd = tr_fdFileGetCached( tr_torrentId( tor ), fileIndex, doWrite );
+
+    if( fd < 0 )
+    {
+        /* the fd cache doesn't have this file...
+         * we'll need to open it and maybe create it */
+        char * name;
+        tr_preallocation_mode preallocationMode;
+        tr_bool fileExists;
+    
+        {
+            char * path = tr_torrentFindFile( tor, fileIndex );
+
+            fileExists = !stat( path, &sb );
+
+            if( fileExists )
+                name = tr_strdup( strstr( path, file->name ) );
+            else
+                name = tr_strdup_printf( "%s.part", file->name );
+
+            tr_free( path );
+        }
+
+        if( ( file->dnd ) || ( ioMode != TR_IO_WRITE ) )
+            preallocationMode = TR_PREALLOCATE_NONE;
+        else
+            preallocationMode = tor->session->preallocationMode;
+
+        if( ( ioMode == TR_IO_READ ) && !fileExists ) /* does file exist? */
+        {
+            err = ENOENT;
+        }
+        else if( ( fd = tr_fdFileCheckout( tor->uniqueId, fileIndex, tor->currentDir, name,
+                                           doWrite, preallocationMode, file->length ) ) < 0 )
+        {
+            err = errno;
+            tr_torerr( tor, "tr_fdFileCheckout failed for \"%s\": %s", name, tr_strerror( err ) );
+        }
+
+        if( doWrite && !err )
+            tr_statsFileCreated( tor->session );
+    }
+
+    if( !err )
+    {
+        if( tr_lseek( fd, (int64_t)fileOffset, SEEK_SET ) == -1 )
+        {
+            err = errno;
+            tr_torerr( tor, "tr_lseek failed for \"%s\": %s", file->name, tr_strerror( err ) );
+        }
+        else if( func( fd, buf, buflen ) != buflen )
+        {
+            err = errno;
+            tr_torerr( tor, "read/write failed for \"%s\": %s", file->name, tr_strerror( err ) );
+        }
+    }
 
     return err;

trunk/libtransmission/peer-mgr.c

@@ -26 +26 @@
 #include "completion.h"
 #include "crypto.h"
-#include "fdlimit.h"
 #include "handshake.h"
 #include "inout.h" /* tr_ioTestPiece */
@@ -1156 +1155 @@
                         tr_peerMsgsHave( peers[i]->msgs, p );
 
-                    for( fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex )
-                    {
+                    for( fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex ) {
                         const tr_file * file = &tor->info.files[fileIndex];
-                        if( ( file->firstPiece <= p ) && ( p <= file->lastPiece ) && tr_cpFileIsComplete( &tor->completion, fileIndex ) )
-                        {
-                            char * path = tr_buildPath( tor->downloadDir, file->name, NULL );
-                            tordbg( t, "closing recently-completed file \"%s\"", path );
-                            tr_fdFileClose( path );
-                            tr_free( path );
-                        }
+                        if( ( file->firstPiece <= p ) && ( p <= file->lastPiece ) )
+                            if( tr_cpFileIsComplete( &tor->completion, fileIndex ) )
+                                tr_torrentFileCompleted( tor, fileIndex );
                     }
                 }
-
-                tr_torrentRecheckCompleteness( tor );
             }
             break;

trunk/libtransmission/resume.c

@@ -18 +18 @@
 #include "bencode.h"
 #include "completion.h"
-#include "fastresume.h"
 #include "peer-mgr.h" /* pex */
 #include "platform.h" /* tr_getResumeDir */
@@ -33 +32 @@
 #define KEY_DND                 "dnd"
 #define KEY_DOWNLOADED          "downloaded"
+#define KEY_INCOMPLETE_DIR      "incomplete-dir"
 #define KEY_MAX_PEERS           "max-peers"
 #define KEY_PAUSED              "paused"
@@ -504 +504 @@
     tr_tordbg( tor, "Saving .resume file for \"%s\"", tr_torrentName( tor ) );
 
-    tr_bencInitDict( &top, 32 ); /* arbitrary "big enough" number */
-    tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE,
-                       tor->activityDate );
-    tr_bencDictAddInt( &top, KEY_ADDED_DATE,
-                       tor->addedDate );
-    tr_bencDictAddInt( &top, KEY_CORRUPT,
-                       tor->corruptPrev + tor->corruptCur );
-    tr_bencDictAddInt( &top, KEY_DONE_DATE,
-                       tor->doneDate );
-    tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR,
-                       tor->downloadDir );
-    tr_bencDictAddInt( &top, KEY_DOWNLOADED,
-                       tor->downloadedPrev + tor->downloadedCur );
-    tr_bencDictAddInt( &top, KEY_UPLOADED,
-                       tor->uploadedPrev + tor->uploadedCur );
-    tr_bencDictAddInt( &top, KEY_MAX_PEERS,
-                       tor->maxConnectedPeers );
-    tr_bencDictAddInt( &top, KEY_BANDWIDTH_PRIORITY,
-                       tr_torrentGetPriority( tor ) );
+    tr_bencInitDict( &top, 33 ); /* arbitrary "big enough" number */
+    tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE, tor->activityDate );
+    tr_bencDictAddInt( &top, KEY_ADDED_DATE, tor->addedDate );
+    tr_bencDictAddInt( &top, KEY_CORRUPT, tor->corruptPrev + tor->corruptCur );
+    tr_bencDictAddInt( &top, KEY_DONE_DATE, tor->doneDate );
+    tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR, tor->downloadDir );
+    if( tor->incompleteDir != NULL )
+        tr_bencDictAddStr( &top, KEY_INCOMPLETE_DIR, tor->incompleteDir );
+    tr_bencDictAddInt( &top, KEY_DOWNLOADED, tor->downloadedPrev + tor->downloadedCur );
+    tr_bencDictAddInt( &top, KEY_UPLOADED, tor->uploadedPrev + tor->uploadedCur );
+    tr_bencDictAddInt( &top, KEY_MAX_PEERS, tor->maxConnectedPeers );
+    tr_bencDictAddInt( &top, KEY_BANDWIDTH_PRIORITY, tr_torrentGetPriority( tor ) );
     tr_bencDictAddBool( &top, KEY_PAUSED, !tor->isRunning );
     savePeers( &top, tor );
@@ -556 +549 @@
     if( tr_bencLoadFile( &top, TR_FMT_BENC, filename ) )
     {
-        tr_tordbg( tor, "Couldn't read \"%s\"; trying old format.",
-                   filename );
-        fieldsLoaded = tr_fastResumeLoad( tor, fieldsToLoad );
-
-        if( ( fieldsLoaded != 0 ) && ( fieldsToLoad == ~(uint64_t)0 ) )
-        {
-            tr_torrentSaveResume( tor );
-            tr_fastResumeRemove( tor );
-            tr_tordbg( tor, "Migrated resume file to \"%s\"", filename );
-        }
+        tr_tordbg( tor, "Couldn't read \"%s\"", filename );
 
         tr_free( filename );
@@ -587 +571 @@
         tor->downloadDir = tr_strdup( str );
         fieldsLoaded |= TR_FR_DOWNLOAD_DIR;
+    }
+
+    if( ( fieldsToLoad & ( TR_FR_PROGRESS | TR_FR_INCOMPLETE_DIR ) )
+      && ( tr_bencDictFindStr( &top, KEY_INCOMPLETE_DIR, &str ) )
+      && ( str && *str ) )
+    {
+        tr_free( tor->incompleteDir );
+        tor->incompleteDir = tr_strdup( str );
+        fieldsLoaded |= TR_FR_INCOMPLETE_DIR;
     }
 
@@ -748 +741 @@
 {
     char * filename = getResumeFilename( tor );
-
     unlink( filename );
-    tr_fastResumeRemove( tor );
     tr_free( filename );
 }

trunk/libtransmission/resume.h

@@ -31 +31 @@
     TR_FR_RUN                 = ( 1 << 9 ),
     TR_FR_DOWNLOAD_DIR        = ( 1 << 10 ),
-    TR_FR_MAX_PEERS           = ( 1 << 11 ),
-    TR_FR_ADDED_DATE          = ( 1 << 12 ),
-    TR_FR_DONE_DATE           = ( 1 << 13 ),
-    TR_FR_ACTIVITY_DATE       = ( 1 << 14 ),
-    TR_FR_RATIOLIMIT          = ( 1 << 15 )
+    TR_FR_INCOMPLETE_DIR      = ( 1 << 11 ),
+    TR_FR_MAX_PEERS           = ( 1 << 12 ),
+    TR_FR_ADDED_DATE          = ( 1 << 13 ),
+    TR_FR_DONE_DATE           = ( 1 << 14 ),
+    TR_FR_ACTIVITY_DATE       = ( 1 << 15 ),
+    TR_FR_RATIOLIMIT          = ( 1 << 16 )
 };
 

trunk/libtransmission/session.c

@@ -348 +348 @@
 
 void
-tr_sessionGetDefaultSettings( tr_benc * d )
-{
+tr_sessionGetDefaultSettings( const char * configDir, tr_benc * d )
+{
+    char * incompleteDir = tr_buildPath( configDir, "Incomplete", NULL );
+
     assert( tr_bencIsDict( d ) );
 
@@ -359 +361 @@
     tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           FALSE );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               TR_DEFAULT_ENCRYPTION );
+    tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,           incompleteDir );
+    tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,   FALSE );
     tr_bencDictAddBool( d, TR_PREFS_KEY_LAZY_BITFIELD,            TRUE );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                 TR_MSG_INF );
@@ -402 +406 @@
     tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,        TR_DEFAULT_BIND_ADDRESS_IPV4 );
     tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,        TR_DEFAULT_BIND_ADDRESS_IPV6 );
+
+    tr_free( incompleteDir );
 }
 
@@ -416 +422 @@
     tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_DOWN ) );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );
+    tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,           tr_sessionGetIncompleteDir( s ) );
+    tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,   tr_sessionGetIncompleteDirEnabled( s ) );
     tr_bencDictAddBool( d, TR_PREFS_KEY_LAZY_BITFIELD,            s->useLazyBitfield );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                 tr_getMessageLevel( ) );
@@ -474 +482 @@
      * preserve those and use the session defaults to fill in any missing gaps. */
     tr_bencInitDict( &sessionDefaults, 0 );
-    tr_sessionGetDefaultSettings( &sessionDefaults );
+    tr_sessionGetDefaultSettings( configDir, &sessionDefaults );
     tr_bencMergeDicts( &sessionDefaults, d );
     tmp = *d; *d = sessionDefaults; sessionDefaults = tmp;
@@ -635 +643 @@
 
     tr_bencInitDict( &settings, 0 );
-    tr_sessionGetDefaultSettings( &settings );
+    tr_sessionGetDefaultSettings( data->configDir, &settings );
     tr_bencMergeDicts( &settings, clientSettings );
 
@@ -684 +692 @@
     assert( found );
     session->downloadDir = tr_strdup( str );
+
+    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_INCOMPLETE_DIR, &str );
+    assert( found );
+    tr_sessionSetIncompleteDir( session, str );
+
+    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, &boolVal );
+    assert( found );
+    tr_sessionSetIncompleteDirEnabled( session, boolVal );
 
     found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PROXY_ENABLED, &boolVal );
@@ -909 +925 @@
 
     return session->downloadDir;
+}
+
+/***
+****
+***/
+
+void
+tr_sessionSetIncompleteDir( tr_session * session, const char * dir )
+{
+    assert( tr_isSession( session ) );
+
+    if( session->incompleteDir != dir )
+    {
+        tr_free( session->incompleteDir );
+
+        session->incompleteDir = tr_strdup( dir );
+
+        tr_mkdirp( session->incompleteDir, 0777 );
+    }
+}
+
+const char*
+tr_sessionGetIncompleteDir( const tr_session * session )
+{
+    assert( tr_isSession( session ) );
+
+    return session->incompleteDir;
+}
+
+void
+tr_sessionSetIncompleteDirEnabled( tr_session * session, tr_bool b )
+{
+    assert( tr_isSession( session ) );
+    assert( tr_isBool( b ) );
+
+    session->isIncompleteDirEnabled = b;
+}
+
+tr_bool
+tr_sessionGetIncompleteDirEnabled( const tr_session * session )
+{
+    assert( tr_isSession( session ) );
+
+    return session->isIncompleteDirEnabled;
 }
 

trunk/libtransmission/session.h

@@ -53 +53 @@
     tr_bool                      useLazyBitfield;
     tr_bool                      isRatioLimited;
+    tr_bool                      isIncompleteDirEnabled;
 
     tr_benc                      removedTorrents;
@@ -102 +103 @@
     char *                       resumeDir;
     char *                       torrentDir;
+    char *                       incompleteDir;
 
     tr_proxy_type                proxyType;

trunk/libtransmission/torrent.c

@@ -551 +551 @@
 }
 
+static void refreshCurrentDir( tr_torrent * tor );;
+
 static void
 torrentRealInit( tr_torrent * tor, const tr_ctor * ctor )
@@ -579 +581 @@
         !tr_ctorGetDownloadDir( ctor, TR_FALLBACK, &dir ) )
             tor->downloadDir = tr_strdup( dir );
+
+    if( tr_sessionGetIncompleteDirEnabled( session ) )
+        tor->incompleteDir = tr_strdup( tr_sessionGetIncompleteDir( session ) );
 
     tor->lastPieceSize = info->totalSize % info->pieceSize;
@@ -643 +648 @@
     loaded = tr_torrentLoadResume( tor, ~0, ctor );
 
+    refreshCurrentDir( tor );
+
     doStart = tor->isRunning;
     tor->isRunning = 0;
@@ -775 +782 @@
         tr_torrentSetDirty( tor );
     }
+
+    refreshCurrentDir( tor );
 }
 
@@ -1242 +1251 @@
 
     tr_free( tor->downloadDir );
+    tr_free( tor->incompleteDir );
     tr_free( tor->peer_id );
 
@@ -1597 +1607 @@
         tor->needsSeedRatioCheck = TRUE;
         tr_fdTorrentClose( tor->uniqueId );
+
+        /* if the torrent is a seed now,
+         * and the files used to be in the incompleteDir,
+         * then move them to the destination directory */
+        if( tr_torrentIsSeed( tor ) && ( tor->currentDir == tor->incompleteDir ) )
+            tr_torrentSetLocation( tor, tor->downloadDir, TRUE, NULL, NULL );
+
         fireCompletenessChange( tor, completeness );
 
@@ -1980 +1997 @@
 
 time_t*
-tr_torrentGetMTimes( const tr_torrent * tor,
-                     size_t *           setme_n )
+tr_torrentGetMTimes( const tr_torrent * tor, size_t * setme_n )
 {
     size_t       i;
@@ -1992 +2008 @@
     {
         struct stat sb;
-        char * path = tr_buildPath( tor->downloadDir, tor->info.files[i].name, NULL );
-        if( !stat( path, &sb ) )
+        char * path = tr_torrentFindFile( tor, i );
+        if( ( path != NULL ) && !stat( path, &sb ) && S_ISREG( sb.st_mode ) )
         {
 #ifdef SYS_DARWIN
@@ -2125 +2141 @@
 tr_torrentGetBytesLeftToAllocate( const tr_torrent * tor )
 {
-    const tr_file * it;
-    const tr_file * end;
-    struct stat sb;
+    tr_file_index_t i;
     uint64_t bytesLeft = 0;
 
     assert( tr_isTorrent( tor ) );
 
-    for( it=tor->info.files, end=it+tor->info.fileCount; it!=end; ++it )
-    {
-        if( !it->dnd )
+    for( i=0; i<tor->info.fileCount; ++i )
+    {
+        if( !tor->info.files[i].dnd )
         {
-            char * path = tr_buildPath( tor->downloadDir, it->name, NULL );
-
-            bytesLeft += it->length;
-
-            if( !stat( path, &sb )
-                    && S_ISREG( sb.st_mode )
-                    && ( (uint64_t)sb.st_size <= it->length ) )
+            struct stat sb;
+            const uint64_t length = tor->info.files[i].length;
+            char * path = tr_torrentFindFile( tor, i );
+
+            bytesLeft += length;
+
+            if( ( path != NULL ) && !stat( path, &sb )
+                                 && S_ISREG( sb.st_mode )
+                                 && ( (uint64_t)sb.st_size <= length ) )
                 bytesLeft -= sb.st_size;
 
@@ -2229 +2245 @@
         else if( S_ISREG( sb.st_mode ) && ( sb.st_size > 0 ) )
         {
-            const char * sub = buf + strlen( tor->downloadDir ) + strlen( TR_PATH_DELIMITER_STR );
+            const char * sub = buf + strlen( tor->currentDir ) + strlen( TR_PATH_DELIMITER_STR );
             const tr_bool isTorrentFile = tr_ptrArrayFindSorted( torrentFiles, sub, vstrcmp ) != NULL;
             if( !isTorrentFile )
@@ -2252 +2268 @@
     const char * cpch = strchr( firstFile, TR_PATH_DELIMITER );
     char * tmp = cpch ? tr_strndup( firstFile, cpch - firstFile ) : NULL;
-    char * root = tr_buildPath( tor->downloadDir, tmp, NULL );
-
-    assert( tr_isTorrent( tor ) );
-
-    for( f=0; f<tor->info.fileCount; ++f )
-        tr_ptrArrayInsertSorted( &torrentFiles, tor->info.files[f].name, vstrcmp );
+    char * root = tr_buildPath( tor->currentDir, tmp, NULL );
+
+    assert( tr_isTorrent( tor ) );
+
+    for( f=0; f<tor->info.fileCount; ++f ) {
+        tr_ptrArrayInsertSorted( &torrentFiles, tr_strdup( tor->info.files[f].name ), vstrcmp );
+        tr_ptrArrayInsertSorted( &torrentFiles, tr_strdup_printf( "%s.part", tor->info.files[f].name ), vstrcmp );
+    }
 
     /* build the set of folders and dirtyFolders */
@@ -2270 +2288 @@
     /* now blow away any remaining torrent files, such as torrent files in dirty folders */
     for( f=0; f<tor->info.fileCount; ++f ) {
-        char * path = tr_buildPath( tor->downloadDir, tor->info.files[f].name, NULL );
+        char * path = tr_buildPath( tor->currentDir, tor->info.files[f].name, NULL );
         fileFunc( path );
         tr_free( path );
@@ -2293 +2311 @@
     tr_ptrArrayDestruct( &dirtyFolders, tr_free );
     tr_ptrArrayDestruct( &folders, tr_free );
-    tr_ptrArrayDestruct( &torrentFiles, NULL );
+    tr_ptrArrayDestruct( &torrentFiles, tr_free );
     tr_free( root );
     tr_free( tmp );
@@ -2313 +2331 @@
     else {
         /* torrent only has one file */
-        char * path = tr_buildPath( tor->downloadDir, tor->info.files[0].name, NULL );
+        char * path = tr_torrentFindFile( tor, 0 );
         fileFunc( path );
         tr_free( path );
@@ -2322 +2340 @@
 ****
 ***/
+
+static char*
+rebaseFile( const tr_torrent * tor, tr_file_index_t fileNo,
+            const char * existingFile, const char * newRoot )
+{
+    const char * base = strstr( existingFile, tor->info.files[fileNo].name );
+    assert( base != NULL );
+    return tr_buildPath( newRoot, base, NULL );
+}
 
 struct LocationData
@@ -2345 +2372 @@
     assert( tr_isTorrent( tor ) );
 
-    if( strcmp( location, tor->downloadDir ) )
+    if( strcmp( location, tor->currentDir ) )
     {
         tr_file_index_t i;
@@ -2367 +2394 @@
             struct stat sb;
             const tr_file * f = &tor->info.files[i];
-            char * oldpath = tr_buildPath( tor->downloadDir, f->name, NULL );
-            char * newpath = tr_buildPath( location, f->name, NULL );
-
-            if( do_move )
+            char * oldpath = tr_torrentFindFile( tor, i );
+            char * newpath = oldpath ? rebaseFile( tor, i, oldpath, location ) : NULL;
+
+            if( do_move && ( oldpath != NULL ) )
             {
                 errno = 0;
@@ -2484 +2511 @@
     }
 }
+
+/***
+****
+***/
+
+void
+tr_torrentFileCompleted( tr_torrent * tor, tr_file_index_t fileNum )
+{
+    char * oldpath = tr_torrentFindFile( tor, fileNum );
+    char * newpath = tr_strdup( oldpath );
+    char * pch = strrchr( newpath, '.' );
+    assert( !strcmp( pch, ".part" ) );
+    *pch = '\0';
+
+    /* close the file so that we can reopen in read-only mode as needed */
+    tr_fdFileClose( tor, fileNum );
+
+    /* strip the trailing ".part" from the filename */
+    if( rename( oldpath, newpath ) )
+        tr_torerr( tor, "Error moving \"%s\" to \"%s\": %s", oldpath, newpath, tr_strerror( errno ) );
+
+    tr_free( newpath );
+    tr_free( oldpath );
+}
+
+/***
+****
+***/
+
+enum
+{
+    TR_FILE_PARTIAL         = (1<<0),
+    TR_FILE_INCOMPLETE_DIR  = (1<<1)
+};
+
+static char*
+tr_torrentBuildFilename( const tr_torrent * tor, tr_file_index_t fileNo, int flags )
+{
+    const char * root;
+    char * base;
+    char * path;
+    const tr_bool partial = ( flags & TR_FILE_PARTIAL ) != 0;
+    const tr_bool incomplete = ( flags & TR_FILE_INCOMPLETE_DIR ) != 0;
+
+    assert( tr_isTorrent( tor ) );
+    assert( fileNo < tor->info.fileCount );
+
+    if( incomplete && ( tor->incompleteDir != NULL ) )
+        root = tor->incompleteDir;
+    else
+        root = tor->downloadDir;
+
+    if( partial )
+        base = tr_strdup_printf( "%s.part", tor->info.files[fileNo].name );
+    else
+        base = tr_strdup( tor->info.files[fileNo].name );
+
+    path = tr_buildPath( root, base, NULL );
+
+    /* cleanup */
+    tr_free( base );
+    return path;
+}
+
+static tr_bool
+fileExists( const char * filename )
+{
+    struct stat sb;
+    const tr_bool ok = !stat( filename, &sb );
+    return ok;
+}
+
+char*
+tr_torrentFindFile( const tr_torrent * tor, tr_file_index_t fileNo )
+{
+    int i;
+    char * filename;
+    int flags[4];
+    int n = 0;
+
+    assert( tr_isTorrent( tor ) );
+    assert( fileNo < tor->info.fileCount );
+
+    /* based on what we know about the torrent,
+     * put the most likely hits first... */
+    if( tr_cpFileIsComplete( &tor->completion, fileNo ) ) {
+        flags[n++] = 0;
+        flags[n++] = TR_FILE_INCOMPLETE_DIR;
+        flags[n++] = TR_FILE_PARTIAL;
+        flags[n++] = TR_FILE_INCOMPLETE_DIR|TR_FILE_PARTIAL;
+    } else {
+        flags[n++] = TR_FILE_INCOMPLETE_DIR|TR_FILE_PARTIAL;
+        flags[n++] = TR_FILE_PARTIAL;
+        flags[n++] = TR_FILE_INCOMPLETE_DIR;
+        flags[n++] = 0;
+    }
+        
+    for( i=0; i<n; ++i ) {
+        filename = tr_torrentBuildFilename( tor, fileNo, flags[i] );
+        if( fileExists( filename ))
+            break;
+        tr_free( filename );
+        filename = NULL;
+    }
+
+    return filename;
+}
+
+/* Decide whether we should be looking for files in downloadDir or incompleteDir. */
+static void
+refreshCurrentDir( tr_torrent * tor )
+{
+    const char * dir = tor->downloadDir;
+
+    if( tor->incompleteDir != NULL )
+    {
+        char * tmp1 = tr_torrentBuildFilename( tor, 0, 0 );
+        char * tmp2 = tr_torrentBuildFilename( tor, 0, TR_FILE_PARTIAL );
+
+        if( !fileExists( tmp1 ) && !fileExists( tmp2 ) )
+            dir = tor->incompleteDir;
+
+        tr_free( tmp2 );
+        tr_free( tmp1 );
+    }
+
+    assert( dir != NULL );
+    assert( ( dir == tor->downloadDir ) || ( dir == tor->incompleteDir ) );
+    tor->currentDir = dir;
+}

trunk/libtransmission/torrent.h

@@ -158 +158 @@
     uint8_t * peer_id;
 
-    /* Where to download */
+    /* Where the files will be when it's complete */
     char * downloadDir;
+
+    /* Where the files are when the torrent is incomplete */
+    char * incompleteDir;
+
+    /* Where the files are now.
+     * This pointer will be equal to downloadDir or incompleteDir */
+    const char * currentDir;
 
     /* How many bytes we ask for per request */
@@ -348 +355 @@
 }
 
+/**
+ * Get the file that exists on the disk, or NULL if no file exists yet.
+ * @return the file that exists on the disk, or NULL if no file exists yet.
+ * @param tor the torrent whose file we're using
+ * @param fileNum the fileIndex, in [0..tor->info.fileCount)
+ */
+char* tr_torrentFindFile( const tr_torrent * tor, tr_file_index_t fileNo );
+
+/**
+ * Tell the tr_torrent that one of its files has become complete
+ */
+void tr_torrentFileCompleted( tr_torrent * tor, tr_file_index_t fileNo );
+
+
 #endif

trunk/libtransmission/transmission.h

@@ -169 +169 @@
 #define TR_PREFS_KEY_DOWNLOAD_DIR               "download-dir"
 #define TR_PREFS_KEY_ENCRYPTION                 "encryption"
+#define TR_PREFS_KEY_INCOMPLETE_DIR             "incomplete-dir"
+#define TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED     "incomplete-dir-enabled"
 #define TR_PREFS_KEY_LAZY_BITFIELD              "lazy-bitfield-enabled"
 #define TR_PREFS_KEY_MSGLEVEL                   "message-level"
@@ -227 +229 @@
  * @see tr_getDefaultConfigDir()
  */
-void tr_sessionGetDefaultSettings( struct tr_benc * dictionary );
+void tr_sessionGetDefaultSettings( const char * configDir, struct tr_benc * dictionary );
 
 /**
@@ -329 +331 @@
  */
 const char * tr_sessionGetDownloadDir( const tr_session * session );
+
+/**
+ * @brief Set the per-session incomplete download folder
+ * @see tr_sessionInit()
+ * @see tr_sessionGetIncompleteDir()
+ * @see tr_sessionSetIncompleteDirEnabled()
+ * @see tr_sessionGetIncompleteDirEnabled()
+ */
+void tr_sessionSetIncompleteDir( tr_session * session, const char * dir );
+
+const char* tr_sessionGetIncompleteDir( const tr_session * session );
+
+void tr_sessionSetIncompleteDirEnabled( tr_session * session, tr_bool );
+
+tr_bool tr_sessionGetIncompleteDirEnabled( const tr_session * session );
 
 /**

trunk/libtransmission/verify.c

@@ -80 +80 @@
         if( !filePos && (fd<0) )
         {
-            char * filename = tr_buildPath( tor->downloadDir, file->name, NULL );
-            fd = tr_open_file_for_scanning( filename );
+            char * filename = tr_torrentFindFile( tor, fileIndex );
+            fd = filename == NULL ? -1 : tr_open_file_for_scanning( filename );
             /* fprintf( stderr, "opening file #%d (%s) -- %d\n", fileIndex, filename, fd ); */
             tr_free( filename );
@@ -255 +255 @@
     {
         struct stat sb;
-        char * path = tr_buildPath( tor->downloadDir, tor->info.files[i].name, NULL );
-        if( !stat( path, &sb ) && ( sb.st_size > 0 ) )
+        char * path = tr_torrentFindFile( tor, i );
+        if( ( path != NULL ) && !stat( path, &sb ) && ( sb.st_size > 0 ) )
             hasAny = TRUE;
         tr_free( path );

trunk/macosx/Controller.m

@@ -265 +265 @@
         tr_benc settings;
         tr_bencInitDict(&settings, 34);
-        tr_sessionGetDefaultSettings(&settings);
+        const char * configDir = tr_getDefaultConfigDir("Transmission");
+        tr_sessionGetDefaultSettings(configDir, &settings);
         
         const BOOL usesSpeedLimitSched = [fDefaults boolForKey: @"SpeedLimitAuto"];
@@ -319 +320 @@
         tr_bencDictAddBool(&settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,  [fDefaults boolForKey: @"RPCUseWhitelist"]);
         
-        fLib = tr_sessionInit("macosx", tr_getDefaultConfigDir("Transmission"), YES, &settings);
+        fLib = tr_sessionInit("macosx", configDir, YES, &settings);
         tr_bencFree(&settings);
         

trunk/qt/session.cc

@@ -263 +263 @@
         tr_benc settings;
         tr_bencInitDict( &settings, 0 );
-        tr_sessionGetDefaultSettings( &settings );
         tr_sessionLoadSettings( &settings, myConfigDir.toUtf8().constData(), "qt" );
         mySession = tr_sessionInit( "qt", myConfigDir.toUtf8().constData(), true, &settings );