Changeset 7722

Timestamp:

Jan 16, 2009, 5:31:10 PM (12 years ago)

Author:

charles

Message:

(1.5x) sync with trunk's libtransmission bugfixes & enhancements

Location:

branches/1.5x

Files:

• configure.ac (modified) (1 diff)
• gtk/conf.h (modified) (1 diff)
• gtk/details.c (modified) (3 diffs)
• gtk/main.c (modified) (1 diff)
• gtk/notify.c (modified) (2 diffs)
• gtk/tr-core.c (modified) (1 diff)
• gtk/tr-prefs.c (modified) (3 diffs)
• gtk/tr-prefs.h (modified) (1 diff)
• libtransmission/completion.c (modified) (1 diff)
• libtransmission/completion.h (modified) (1 diff)
• libtransmission/fastresume.c (modified) (1 diff)
• libtransmission/fdlimit.c (modified) (6 diffs)
• libtransmission/fdlimit.h (modified) (2 diffs)
• libtransmission/handshake.c (modified) (1 diff)
• libtransmission/inout.c (modified) (2 diffs)
• libtransmission/net.c (modified) (1 diff)
• libtransmission/net.h (modified) (1 diff)
• libtransmission/peer-mgr.c (modified) (32 diffs)
• libtransmission/peer-mgr.h (modified) (5 diffs)
• libtransmission/peer-msgs.c (modified) (8 diffs)
• libtransmission/port-forwarding.c (modified) (2 diffs)
• libtransmission/resume.c (modified) (4 diffs)
• libtransmission/rpc-server.c (modified) (2 diffs)
• libtransmission/rpc-server.h (modified) (1 diff)
• libtransmission/rpcimpl.c (modified) (2 diffs)
• libtransmission/session.c (modified) (6 diffs)
• libtransmission/session.h (modified) (1 diff)
• libtransmission/torrent.c (modified) (9 diffs)
• libtransmission/torrent.h (modified) (3 diffs)
• libtransmission/tracker.c (modified) (5 diffs)
• libtransmission/transmission.h (modified) (5 diffs)
• libtransmission/web.c (modified) (1 diff)

branches/1.5x/configure.ac

@@ -50 +50 @@
 AC_C_INLINE
 if test "x$GCC" = "xyes" ; then
-    CFLAGS="-std=gnu99 -ggdb3 -Wall -Wextra -Wredundant-decls -Wpointer-arith -Wformat-security -W -Wmissing-declarations -Wdeclaration-after-statement -Wcast-align -Winline -Winit-self -Wundef -Wnested-externs -Wmissing-format-attribute"
+    CFLAGS="-std=gnu99 -ggdb3 -Wall -Wextra -Wredundant-decls -Wpointer-arith -Wformat-security -W -Wmissing-declarations -Wdeclaration-after-statement -Wcast-align -Winit-self -Wundef -Wnested-externs -Wmissing-format-attribute"
     CXXFLAGS="-Wall -Wformat-security -W"
 fi

branches/1.5x/gtk/conf.h

@@ -23 +23 @@
  *****************************************************************************/
 
-struct tr_benc;
-
-/**
-***
-**/
-
 #ifndef TG_CONF_H
 #define TG_CONF_H
+
+#include <inttypes.h>
+#include <libtransmission/transmission.h>
 
 int64_t          pref_int_get           ( const char * key );

branches/1.5x/gtk/details.c

@@ -12 +12 @@
 
 #include <errno.h>
+#include <math.h> /* ceil() */
 #include <stddef.h>
 #include <stdio.h>
@@ -1011 +1012 @@
     char            buf[128];
     const tr_stat * stat = tr_torrent_stat( a->gtor );
+    const tr_info * info = tr_torrent_info( a->gtor );
     const double    complete = stat->percentComplete * 100.0;
     const double    done = stat->percentDone * 100.0;
+    const double    verifiedPieceCount = (double)stat->haveValid / info->pieceSize;
 
     pch = tr_torrent_status_str( a->gtor );
@@ -1035 +1038 @@
                 sizeof( sizeStr2 ) );
     /* %1$s is total size of what we've saved to disk
-       %2$s is how much of it's passed the checksum test */
-    g_snprintf( buf, sizeof( buf ), _(
-                    "%1$s (%2$s verified)" ), sizeStr, sizeStr2 );
+       %2$s is how much of it's passed the checksum test
+       %3$s is how many pieces are verified */
+    g_snprintf( buf, sizeof( buf ), _( "%1$s (%2$s verified in %3$d pieces)" ),
+                sizeStr, sizeStr2, (int)ceil(verifiedPieceCount) );
     gtk_label_set_text( GTK_LABEL( a->have_lb ), buf );
 

branches/1.5x/gtk/main.c

@@ -238 +238 @@
 
     {
-        tr_torrent * tor = NULL;
         tr_session * session = tr_core_session( data->core );
-        int activeCount = 0;
-        while(( tor = tr_torrentNext( session, tor )))
-            if( TR_STATUS_IS_ACTIVE( tr_torrentGetActivity( tor )))
-                ++activeCount;
+        int activeCount = tr_sessionGetActiveTorrentCount( session );
         action_sensitize( "pause-all-torrents", activeCount != 0 );
     }

branches/1.5x/gtk/notify.c

@@ -16 +16 @@
 #endif
 #include <glib/gi18n.h>
+#include "conf.h"
 #include "notify.h"
+#include "tr-prefs.h"
 #include "util.h"
 
@@ -61 +63 @@
 tr_notify_send( TrTorrent *tor )
 {
-    const tr_info *      info = tr_torrent_info( tor );
-    NotifyNotification * n = notify_notification_new( _(
-                                                          "Torrent Complete" ),
-                                                      info->name,
-                                                      "transmission", NULL );
+    if( pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
+    {
+        const tr_info * info = tr_torrent_info( tor );
+        NotifyNotification * n;
 
-    if( info->fileCount == 1 )
-        notify_notification_add_action( n, "file", _( "Open File" ),
-                                        NOTIFY_ACTION_CALLBACK(
-                                            notifyCallback ), tor, NULL );
-    notify_notification_add_action( n, "folder", _( "Open Folder" ),
-                                    NOTIFY_ACTION_CALLBACK(
-                                        notifyCallback ), tor, NULL );
-    notify_notification_show( n, NULL );
+        n = notify_notification_new( _( "Torrent Complete" ),
+                                     info->name,
+                                     "transmission", NULL );
+
+        if( info->fileCount == 1 )
+            notify_notification_add_action(
+                n, "file", _( "Open File" ),
+                NOTIFY_ACTION_CALLBACK( notifyCallback ), tor,
+                NULL );
+
+        notify_notification_add_action(
+            n, "folder", _( "Open Folder" ),
+            NOTIFY_ACTION_CALLBACK( notifyCallback ), tor, NULL );
+
+        notify_notification_show( n, NULL );
+    }
 }
 

branches/1.5x/gtk/tr-core.c

@@ -1208 +1208 @@
     /* always allow hibernation when all the torrents are paused */
     if( inhibit ) {
-        gboolean active = FALSE;
-        tr_session *  session = tr_core_session( core );
-        tr_torrent * tor = NULL;
-        while(( tor = tr_torrentNext( session, tor )))
-            if(( active = ( tr_torrentGetActivity( tor ) != TR_STATUS_STOPPED )))
-                break;
-        if( !active )
+        tr_session * session = tr_core_session( core );
+
+        if( tr_sessionGetActiveTorrentCount( session ) == 0 )
             inhibit = FALSE;
     }

branches/1.5x/gtk/tr-prefs.c

@@ -40 +40 @@
     cf_check_older_configs( );
 
-#if HAVE_GIO
+#ifdef HAVE_GIO
     str = NULL;
     if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
@@ -57 +57 @@
     pref_flag_set_default   ( PREF_KEY_STATUSBAR, TRUE );
     pref_flag_set_default   ( PREF_KEY_SHOW_TRAY_ICON, FALSE );
+    pref_flag_set_default   ( PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
     pref_string_set_default ( PREF_KEY_STATUSBAR_STATS, "total-ratio" );
 
@@ -349 +350 @@
     s = _( "Show _icon in the desktop Notification Area" );
     w = new_check_button( s, PREF_KEY_SHOW_TRAY_ICON, core );
+    hig_workarea_add_wide_control( t, &row, w );
+
+    s = _( "Show desktop _notifications" );
+    w = new_check_button( s, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, core );
     hig_workarea_add_wide_control( t, &row, w );
 

branches/1.5x/gtk/tr-prefs.h

@@ -33 +33 @@
 #define PREF_KEY_DIR_WATCH_ENABLED          "watch-dir-enabled"
 #define PREF_KEY_SHOW_TRAY_ICON             "show-notification-area-icon"
+#define PREF_KEY_SHOW_DESKTOP_NOTIFICATION  "show-desktop-notification"
 #define PREF_KEY_START                      "start-added-torrents"
 #define PREF_KEY_TRASH_ORIGINAL             "trash-original-torrent-files"

branches/1.5x/libtransmission/completion.c

@@ -316 +316 @@
     return cp->completeBlocks[piece] == tr_torPieceCountBlocks( cp->tor, piece );
 }
+
+tr_bool
+tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t fileIndex )
+{
+    tr_block_index_t block;
+
+    const tr_torrent * tor = cp->tor;
+    const tr_file * file = &tor->info.files[fileIndex];
+    const tr_block_index_t firstBlock = file->offset / tor->blockSize;
+    const tr_block_index_t lastBlock = ( file->offset + file->length - 1 ) / tor->blockSize;
+
+    assert( tr_torBlockPiece( tor, firstBlock ) == file->firstPiece );
+    assert( tr_torBlockPiece( tor, lastBlock ) == file->lastPiece );
+
+    for( block=firstBlock; block<=lastBlock; ++block )
+        if( !tr_cpBlockIsComplete( cp, block ) )
+            return FALSE;
+
+    return TRUE;
+}

branches/1.5x/libtransmission/completion.h

@@ -129 +129 @@
                       tr_piece_index_t   piece );
 
+tr_bool tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t );
+
 /**
 *** Blocks
 **/
 
-static TR_INLINE int tr_cpBlockIsComplete( const tr_completion * cp, tr_block_index_t block ) {
+static TR_INLINE tr_bool tr_cpBlockIsComplete( const tr_completion * cp, tr_block_index_t block ) {
     return tr_bitfieldHas( &cp->blockBitfield, block );
 }

branches/1.5x/libtransmission/fastresume.c

@@ -416 +416 @@
             tr_pex pex;
             readBytes( &pex, &buf, sizeof( tr_pex ) );
-            tr_peerMgrAddPex( tor->session->peerMgr, tor->info.hash,
-                              TR_PEER_FROM_CACHE,
-                              &pex );
+            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
         }
 

branches/1.5x/libtransmission/fdlimit.c

@@ -109 +109 @@
 #endif
 
-static int
-preallocateFile( const char * filename, uint64_t length )
-{
-    int success = 0;
+static tr_bool
+preallocateFileSparse( int fd, uint64_t length )
+{
+    const char zero = '\0';
+
+    if( length == 0 )
+        return TRUE;
+
+    if( lseek( fd, length-1, SEEK_SET ) == -1 )
+        return FALSE;
+    if( write( fd, &zero, 1 ) == -1 )
+        return FALSE;
+    if( ftruncate( fd, length ) == -1 )
+        return FALSE;
+
+    return TRUE;
+}
+
+static tr_bool
+preallocateFileFull( const char * filename, uint64_t length )
+{
+    tr_bool success = 0;
 
 #ifdef WIN32
@@ -171 +189 @@
  */
 static int
-TrOpenFile( int          i,
-            const char * folder,
-            const char * torrentFile,
-            int          doWrite,
-            int          doPreallocate,
-            uint64_t     desiredFileSize )
+TrOpenFile( int                      i,
+            const char             * folder,
+            const char             * torrentFile,
+            tr_bool                  doWrite,
+            tr_preallocation_mode    preallocationMode,
+            uint64_t                 desiredFileSize )
 {
     struct tr_openfile * file = &gFd->openFiles[i];
@@ -203 +221 @@
     alreadyExisted = !stat( filename, &sb ) && S_ISREG( sb.st_mode );
 
-    if( doWrite && !alreadyExisted && doPreallocate )
-        if( preallocateFile( filename, desiredFileSize ) )
+    if( doWrite && !alreadyExisted && ( preallocationMode == TR_PREALLOCATE_FULL ) )
+        if( preallocateFileFull( filename, desiredFileSize ) )
             tr_inf( _( "Preallocated file \"%s\"" ), filename );
     
@@ -225 +243 @@
     }
 
+    if( doWrite && !alreadyExisted && ( preallocationMode == TR_PREALLOCATE_SPARSE ) )
+        preallocateFileSparse( file->fd, desiredFileSize );
+
     tr_free( filename );
     return 0;
@@ -257 +278 @@
 /* returns an fd on success, or a -1 on failure and sets errno */
 int
-tr_fdFileCheckout( const char * folder,
-                   const char * torrentFile,
-                   int          doWrite,
-                   int          doPreallocate,
-                   uint64_t     desiredFileSize )
+tr_fdFileCheckout( const char             * folder,
+                   const char             * torrentFile,
+                   tr_bool                  doWrite,
+                   tr_preallocation_mode    preallocationMode,
+                   uint64_t                 desiredFileSize )
 {
     int i, winner = -1;
@@ -359 +380 @@
     if( !fileIsOpen( o ) )
     {
-        const int err = TrOpenFile( winner, folder, torrentFile, doWrite, doPreallocate, desiredFileSize );
+        const int err = TrOpenFile( winner, folder, torrentFile, doWrite, preallocationMode, desiredFileSize );
         if( err ) {
             tr_lockUnlock( gFd->lock );

branches/1.5x/libtransmission/fdlimit.h

@@ -27 +27 @@
 #endif
 
+#include "transmission.h"
 #include "net.h"
 
@@ -51 +52 @@
  * @see tr_fdFileClose
  */
-int  tr_fdFileCheckout( const char * folder,
-                        const char * torrentFile,
-                        int          doWrite,
-                        int          doPreallocate,
-                        uint64_t     desiredFileSize );
+int  tr_fdFileCheckout( const char             * folder,
+                        const char             * torrentFile,
+                        tr_bool                  doWrite,
+                        tr_preallocation_mode    preallocationMode,
+                        uint64_t                 desiredFileSize );
 
 /**

branches/1.5x/libtransmission/handshake.c

@@ -847 +847 @@
     {
         const tr_bool clientIsSeed = tr_torrentIsSeed( tor );
-        const tr_bool peerIsSeed = tr_peerMgrPeerIsSeed( handshake->session->peerMgr,
-                                                         tor->info.hash,
-                                                         tr_peerIoGetAddress( handshake->io, NULL ) );
+        const tr_bool peerIsSeed = tr_peerMgrPeerIsSeed( tor, tr_peerIoGetAddress( handshake->io, NULL ) );
         dbgmsg( handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
                 tor->info.name );

branches/1.5x/libtransmission/inout.c

@@ -72 +72 @@
     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 );
@@ -94 +95 @@
         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 = errno;
-    else if( ( fd = tr_fdFileCheckout ( tor->downloadDir, file->name, ioMode == TR_IO_WRITE, !file->dnd, file->length ) ) < 0 )
+    else if( ( fd = tr_fdFileCheckout ( tor->downloadDir, file->name, ioMode == TR_IO_WRITE, preallocationMode, file->length ) ) < 0 )
         err = errno;
     else if( tr_lseek( fd, (int64_t)fileOffset, SEEK_SET ) == -1 )

branches/1.5x/libtransmission/net.c

@@ -129 +129 @@
 }
 
+void
+tr_suspectAddress( const tr_address * a UNUSED, const char * source UNUSED )
+{
+/* this is overkill for a production environment,
+ * but useful in the nightly builds, so only compile it into the nightlies */
+#ifdef TR_UNSTABLE
+    /* be really aggressive in what we report */
+    if( a->type == TR_AF_INET && !( ntohl( a->addr.addr4.s_addr ) & 0xff000000 ) )
+        tr_err(  "Funny looking address %s from %s", tr_ntop_non_ts( a ), source );
+    /* /16s taken from ipv6 rib on 21 dec, 2008 */
+    /* this is really, really ugly. expedience over quality */
+    if( a->type == TR_AF_INET6 )
+    {
+        uint16_t slash16;
+        uint16_t valid[] = { 0x339, 0x2002, 0x2003, 0x2400, 0x2401, 0x2402,
+            0x2403, 0x2404, 0x2405, 0x2406, 0x2407, 0x2600, 0x2607, 0x2610,
+            0x2620, 0x2800, 0x2801, 0x2a00, 0x2a01, 0x0a02, 0x2001, 0x0000 };
+        uint16_t *p;
+        tr_bool good = FALSE;
+        p = valid;
+        memcpy( &slash16, &a->addr, 2 );
+        slash16 = ntohs( slash16 );
+        while( *p )
+        {
+            if( slash16 == *p )
+                good = TRUE;
+            p++;
+        }
+        if( !good && !IN6_IS_ADDR_V4MAPPED( &a->addr.addr6 ) )
+            tr_err(  "Funny looking address %s from %s", tr_ntop_non_ts( a ), source );
+    }
+#endif
+}
+
 const char * 
 tr_ntop( const tr_address * src, char * dst, int size ) 

branches/1.5x/libtransmission/net.h

@@ -89 +89 @@
 void tr_normalizeV4Mapped( tr_address * const addr );
 
+void tr_suspectAddress( const tr_address * a, const char * source );
+
 static TR_INLINE tr_bool tr_isAddress( const tr_address * a ) { return ( a != NULL ) && ( a->type==TR_AF_INET || a->type==TR_AF_INET6 ); }
 

branches/1.5x/libtransmission/peer-mgr.c

@@ +1 @@
+
 /*
  * This file Copyright (C) 2007-2009 Charles Kerr <charles@transmissionbt.com>
@@ -27 +28 @@
 #include "completion.h"
 #include "crypto.h"
+#include "fdlimit.h"
 #include "handshake.h"
 #include "inout.h" /* tr_ioTestPiece */
@@ -32 +34 @@
 #include "peer-io.h"
 #include "peer-mgr.h"
-#include "peer-mgr-private.h"
 #include "peer-msgs.h"
 #include "ptrarray.h"
@@ -116 +117 @@
 };
 
-typedef struct
+typedef struct tr_torrent_peers
 {
     tr_bool         isRunning;
@@ -139 +140 @@
 {
     tr_session      * session;
-    tr_ptrArray       torrents; /* Torrent */
     tr_ptrArray       incomingHandshakes; /* tr_handshake */
     tr_timer        * bandwidthTimer;
@@ -235 +235 @@
 **/
 
-static int
-torrentCompare( const void * va,
-                const void * vb )
-{
-    const Torrent * a = va;
-    const Torrent * b = vb;
-
-    return memcmp( a->hash, b->hash, SHA_DIGEST_LENGTH );
-}
-
-static int
-torrentCompareToHash( const void * va,
-                      const void * vb )
-{
-    const Torrent * a = va;
-    const uint8_t * b_hash = vb;
-
-    return memcmp( a->hash, b_hash, SHA_DIGEST_LENGTH );
-}
-
 static Torrent*
 getExistingTorrent( tr_peerMgr *    manager,
                     const uint8_t * hash )
 {
-    return (Torrent*) tr_ptrArrayFindSorted( &manager->torrents,
-                                             hash,
-                                             torrentCompareToHash );
+    tr_torrent * tor = tr_torrentFindFromHash( manager->session, hash );
+
+    return tor == NULL ? NULL : tor->torrentPeers;
 }
 
@@ -454 +434 @@
 
     m->session = session;
-    m->torrents = TR_PTR_ARRAY_INIT;
     m->incomingHandshakes = TR_PTR_ARRAY_INIT;
     m->bandwidthTimer = tr_timerNew( session, bandwidthPulse, m, BANDWIDTH_PERIOD_MSEC );
@@ -474 +453 @@
     tr_ptrArrayDestruct( &manager->incomingHandshakes, NULL );
 
-    /* free the torrents. */
-    tr_ptrArrayDestruct( &manager->torrents, torrentDestructor );
-
     managerUnlock( manager );
     tr_free( manager );
@@ -498 +474 @@
 
 tr_bool
-tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
-                      const uint8_t     * torrentHash,
+tr_peerMgrPeerIsSeed( const tr_torrent  * tor,
                       const tr_address  * addr )
 {
     tr_bool isSeed = FALSE;
-    const Torrent * t = NULL;
-    const struct peer_atom * atom = NULL;
-
-    t = getExistingTorrent( (tr_peerMgr*)mgr, torrentHash );
-    if( t )
-        atom = getExistingAtom( t, addr );
+    const Torrent * t = tor->torrentPeers;
+    const struct peer_atom * atom = getExistingAtom( t, addr );
+
     if( atom )
         isSeed = ( atom->flags & ADDED_F_SEED_FLAG ) != 0;
@@ -1063 +1035 @@
         case TR_PEER_CLIENT_GOT_BLOCK:
         {
-            tr_torrent *     tor = t->tor;
+            tr_torrent * tor = t->tor;
 
             tr_block_index_t block = _tr_block( tor, e->pieceIndex, e->offset );
@@ -1085 +1057 @@
                 tr_torrentSetHasPiece( tor, p, ok );
                 tr_torrentSetPieceChecked( tor, p, TRUE );
-                tr_peerMgrSetBlame( tor->session->peerMgr, tor->info.hash, p, ok );
+                tr_peerMgrSetBlame( tor, p, ok );
 
                 if( !ok )
+                {
                     gotBadPiece( t, p );
+                }
                 else
                 {
                     int i;
-                    int peerCount = tr_ptrArraySize( &t->peers );
-                    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
+                    int peerCount;
+                    tr_peer ** peers;
+                    tr_file_index_t fileIndex;
+
+                    peerCount = tr_ptrArraySize( &t->peers );
+                    peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
                     for( i=0; i<peerCount; ++i )
                         tr_peerMsgsHave( peers[i]->msgs, p );
+
+                    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 );
+                        }
+                    }
                 }
 
@@ -1316 +1306 @@
 
 void
-tr_peerMgrAddPex( tr_peerMgr *    manager,
-                  const uint8_t * torrentHash,
+tr_peerMgrAddPex( tr_torrent   *  tor,
                   uint8_t         from,
                   const tr_pex *  pex )
@@ -1323 +1312 @@
     if( tr_isPex( pex ) ) /* safeguard against corrupt data */
     {
-        Torrent * t;
-        managerLock( manager );
-
-        t = getExistingTorrent( manager, torrentHash );
+        Torrent * t = tor->torrentPeers;
+        managerLock( t->manager );
+
         if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
             ensureAtomExists( t, &pex->addr, pex->port, pex->flags, from );
 
-        managerUnlock( manager );
+        managerUnlock( t->manager );
     }
 }
@@ -1397 +1385 @@
     for( i = 0 ; i < n ; i++ ) {
         memcpy( &pex[i].addr, walk, sizeof( tr_address ) );
+        tr_suspectAddress( &pex[i].addr, "tracker"  );
         memcpy( &pex[i].port, walk + sizeof( tr_address ), 2 );
         pex[i].flags = 0x00;
@@ -1411 +1400 @@
 
 void
-tr_peerMgrSetBlame( tr_peerMgr *     manager,
-                    const uint8_t *  torrentHash,
+tr_peerMgrSetBlame( tr_torrent     * tor,
                     tr_piece_index_t pieceIndex,
                     int              success )
@@ -1419 +1407 @@
     {
         int        peerCount, i;
-        Torrent *  t = getExistingTorrent( manager, torrentHash );
+        Torrent *  t = tor->torrentPeers;
         tr_peer ** peers;
 
@@ -1471 +1459 @@
 
 int
-tr_peerMgrGetPeers( tr_peerMgr      * manager,
-                    const uint8_t   * torrentHash,
+tr_peerMgrGetPeers( tr_torrent      * tor,
                     tr_pex         ** setme_pex,
                     uint8_t           af)
 {
     int peersReturning = 0;
-    const Torrent *  t;
-
-    managerLock( manager );
-
-    t = getExistingTorrent( manager, torrentHash );
-    if( t == NULL )
-    {
-        *setme_pex = NULL;
-    }
-    else
+    const Torrent * t = tor->torrentPeers;
+
+    managerLock( t->manager );
+
     {
         int i;
@@ -1521 +1502 @@
     }
 
-    managerUnlock( manager );
+    managerUnlock( t->manager );
     return peersReturning;
 }
@@ -1530 +1511 @@
 
 void
-tr_peerMgrStartTorrent( tr_peerMgr *    manager,
-                        const uint8_t * torrentHash )
-{
-    Torrent * t;
-
-    managerLock( manager );
-
-    t = getExistingTorrent( manager, torrentHash );
+tr_peerMgrStartTorrent( tr_torrent * tor )
+{
+    Torrent * t = tor->torrentPeers;
+
+    managerLock( t->manager );
 
     assert( t );
@@ -1563 +1541 @@
     }
 
-    managerUnlock( manager );
+    managerUnlock( t->manager );
 }
 
@@ -1586 +1564 @@
 
 void
-tr_peerMgrStopTorrent( tr_peerMgr *    manager,
-                       const uint8_t * torrentHash )
-{
-    managerLock( manager );
-
-    stopTorrent( getExistingTorrent( manager, torrentHash ) );
-
-    managerUnlock( manager );
+tr_peerMgrStopTorrent( tr_torrent * tor )
+{
+    Torrent * t = tor->torrentPeers;
+
+    managerLock( t->manager );
+
+    stopTorrent( t );
+
+    managerUnlock( t->manager );
 }
 
@@ -1600 +1579 @@
                       tr_torrent * tor )
 {
-    Torrent * t;
-
     managerLock( manager );
 
     assert( tor );
-    assert( getExistingTorrent( manager, tor->info.hash ) == NULL );
-
-    t = torrentConstructor( manager, tor );
-    tr_ptrArrayInsertSorted( &manager->torrents, t, torrentCompare );
+    assert( tor->torrentPeers == NULL );
+
+    tor->torrentPeers = torrentConstructor( manager, tor );
 
     managerUnlock( manager );
@@ -1614 +1590 @@
 
 void
-tr_peerMgrRemoveTorrent( tr_peerMgr *    manager,
-                         const uint8_t * torrentHash )
-{
-    Torrent * t;
-
-    managerLock( manager );
-
-    t = getExistingTorrent( manager, torrentHash );
-    assert( t );
-    stopTorrent( t );
-    tr_ptrArrayRemoveSorted( &manager->torrents, t, torrentCompare );
-    torrentDestructor( t );
-
-    managerUnlock( manager );
+tr_peerMgrRemoveTorrent( tr_torrent * tor )
+{
+    tr_torrentLock( tor );
+
+    stopTorrent( tor->torrentPeers );
+    torrentDestructor( tor->torrentPeers );
+
+    tr_torrentUnlock( tor );
 }
 
 void
-tr_peerMgrTorrentAvailability( const tr_peerMgr * manager,
-                               const uint8_t *    torrentHash,
-                               int8_t *           tab,
+tr_peerMgrTorrentAvailability( const tr_torrent * tor,
+                               int8_t           * tab,
                                unsigned int       tabCount )
 {
     tr_piece_index_t   i;
     const Torrent *    t;
-    const tr_torrent * tor;
     float              interval;
     tr_bool            isSeed;
     int                peerCount;
     const tr_peer **   peers;
-    managerLock( manager );
-
-    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
+    tr_torrentLock( tor );
+
+    t = tor->torrentPeers;
     tor = t->tor;
     interval = tor->info.pieceCount / (float)tabCount;
@@ -1668 +1636 @@
     }
 
-    managerUnlock( manager );
+    tr_torrentUnlock( tor );
 }
 
 /* Returns the pieces that are available from peers */
 tr_bitfield*
-tr_peerMgrGetAvailable( const tr_peerMgr * manager,
-                        const uint8_t *    torrentHash )
+tr_peerMgrGetAvailable( const tr_torrent * tor )
 {
     int i;
     int peerCount;
-    Torrent * t;
+    Torrent * t = tor->torrentPeers;
     const tr_peer ** peers;
     tr_bitfield * pieces;
-    managerLock( manager );
-
-    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
+    managerLock( t->manager );
+
     pieces = tr_bitfieldNew( t->tor->info.pieceCount );
     peerCount = tr_ptrArraySize( &t->peers );
@@ -1690 +1656 @@
         tr_bitfieldOr( pieces, peers[i]->have );
 
-    managerUnlock( manager );
+    managerUnlock( t->manager );
     return pieces;
 }
 
-int
-tr_peerMgrHasConnections( const tr_peerMgr * manager,
-                          const uint8_t *    torrentHash )
-{
-    int ret;
-    const Torrent * t;
-    managerLock( manager );
-
-    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
-    ret = t && ( !tr_ptrArrayEmpty( &t->peers ) || !tr_ptrArrayEmpty( &t->webseeds ) );
-
-    managerUnlock( manager );
-    return ret;
-}
-
 void
-tr_peerMgrTorrentStats( const tr_peerMgr * manager,
-                        const uint8_t    * torrentHash,
+tr_peerMgrTorrentStats( tr_torrent       * tor,
                         int              * setmePeersKnown,
                         int              * setmePeersConnected,
@@ -1721 +1671 @@
 {
     int i, size;
-    const Torrent * t;
+    const Torrent * t = tor->torrentPeers;
     const tr_peer ** peers;
     const tr_webseed ** webseeds;
 
-    managerLock( manager );
-
-    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
+    managerLock( t->manager );
+
     peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
     size = tr_ptrArraySize( &t->peers );
@@ -1769 +1718 @@
             ++*setmeWebseedsSendingToUs;
 
-    managerUnlock( manager );
+    managerUnlock( t->manager );
 }
 
 float*
-tr_peerMgrWebSpeeds( const tr_peerMgr * manager,
-                     const uint8_t *    torrentHash )
-{
-    const Torrent * t;
+tr_peerMgrWebSpeeds( const tr_torrent * tor )
+{
+    const Torrent * t = tor->torrentPeers;
     const tr_webseed ** webseeds;
     int i;
@@ -1783 +1731 @@
     uint64_t now;
 
-    assert( manager );
-    managerLock( manager );
-
-    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
+    assert( t->manager );
+    managerLock( t->manager );
+
     webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
     webseedCount = tr_ptrArraySize( &t->webseeds );
-    assert( webseedCount == t->tor->info.webseedCount );
+    assert( webseedCount == tor->info.webseedCount );
     ret = tr_new0( float, webseedCount );
     now = tr_date( );
@@ -1797 +1744 @@
             ret[i] = -1.0;
 
-    managerUnlock( manager );
+    managerUnlock( t->manager );
     return ret;
 }
@@ -1809 +1756 @@
 
 struct tr_peer_stat *
-tr_peerMgrPeerStats( const   tr_peerMgr  * manager,
-                     const   uint8_t     * torrentHash,
+tr_peerMgrPeerStats( const tr_torrent    * tor,
                      int                 * setmeCount )
 {
     int i, size;
-    const Torrent * t;
+    const Torrent * t = tor->torrentPeers;
     const tr_peer ** peers;
     tr_peer_stat * ret;
     uint64_t now;
 
-    assert( manager );
-    managerLock( manager );
-
-    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
+    assert( t->manager );
+    managerLock( t->manager );
+
     size = tr_ptrArraySize( &t->peers );
     peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
@@ -1872 +1817 @@
     *setmeCount = size;
 
-    managerUnlock( manager );
+    managerUnlock( t->manager );
     return ret;
 }
@@ -2352 +2297 @@
 pumpAllPeers( tr_peerMgr * mgr )
 {
-    const int torrentCount = tr_ptrArraySize( &mgr->torrents );
-    int       i, j;
-
-    for( i=0; i<torrentCount; ++i )
-    {
-        Torrent * t = tr_ptrArrayNth( &mgr->torrents, i );
+    tr_torrent * tor = NULL;
+
+    while(( tor = tr_torrentNext( mgr->session, tor )))
+    {
+        int j;
+        Torrent * t = tor->torrentPeers;
+
         for( j=0; j<tr_ptrArraySize( &t->peers ); ++j )
         {

branches/1.5x/libtransmission/peer-mgr.h

@@ -25 +25 @@
 
 #include "net.h"
+#include "publish.h" /* tr_publisher_tag */
 
 struct tr_peer_stat;
@@ -47 +48 @@
 tr_pex;
 
+
+struct tr_bandwidth;
+struct tr_bitfield;
+struct tr_peerIo;
+struct tr_peermsgs;
+
+enum
+{
+    ENCRYPTION_PREFERENCE_UNKNOWN,
+    ENCRYPTION_PREFERENCE_YES,
+    ENCRYPTION_PREFERENCE_NO
+};
+
+/**
+ * State information about a connected peer.
+ *
+ * @see struct peer_atom
+ * @see tr_peermsgs
+ */
+typedef struct tr_peer
+{
+    tr_bool                  peerIsChoked;
+    tr_bool                  peerIsInterested;
+    tr_bool                  clientIsChoked;
+    tr_bool                  clientIsInterested;
+    tr_bool                  doPurge;
+
+    /* number of bad pieces they've contributed to */
+    uint8_t                  strikes;
+
+    uint8_t                  encryption_preference;
+    tr_port                  port;
+    tr_address               addr;
+    struct tr_peerIo       * io;
+
+    struct tr_bitfield     * blame;
+    struct tr_bitfield     * have;
+
+    /** how complete the peer's copy of the torrent is. [0.0...1.0] */
+    float                    progress;
+
+    /* the client name from the `v' string in LTEP's handshake dictionary */
+    char                   * client;
+
+    time_t                   chokeChangedAt;
+
+    struct tr_peermsgs     * msgs;
+    tr_publisher_tag         msgsTag;
+}
+tr_peer;
+
+
 int tr_pexCompare( const void * a, const void * b );
 
@@ -53 +106 @@
 void tr_peerMgrFree( tr_peerMgr * manager );
 
-tr_bool tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
-                              const uint8_t     * torrentHash,
-                              const tr_address  * addr );
+tr_bool tr_peerMgrPeerIsSeed( const tr_torrent * tor,
+                              const tr_address * addr );
 
 void tr_peerMgrAddIncoming( tr_peerMgr  * manager,
@@ -78 +130 @@
                                size_t      * setme_pex_count );
 
-void tr_peerMgrAddPex( tr_peerMgr     * manager,
-                       const uint8_t  * torrentHash,
+void tr_peerMgrAddPex( tr_torrent     * tor,
                        uint8_t          from,
                        const tr_pex   * pex );
 
-void tr_peerMgrSetBlame( tr_peerMgr        * manager,
-                         const uint8_t     * torrentHash,
+void tr_peerMgrSetBlame( tr_torrent        * tor,
                          tr_piece_index_t    pieceIndex,
                          int                 success );
 
-int  tr_peerMgrGetPeers( tr_peerMgr      * manager,
-                         const uint8_t   * torrentHash,
+int  tr_peerMgrGetPeers( tr_torrent      * tor,
                          tr_pex         ** setme_pex,
                          uint8_t           af);
 
-void tr_peerMgrStartTorrent( tr_peerMgr     * manager,
-                             const uint8_t  * torrentHash );
+void tr_peerMgrStartTorrent( tr_torrent * tor );
 
-void tr_peerMgrStopTorrent( tr_peerMgr      * manager,
-                             const uint8_t  * torrentHash );
+void tr_peerMgrStopTorrent( tr_torrent * tor );
 
 void tr_peerMgrAddTorrent( tr_peerMgr         * manager,
                            struct tr_torrent  * tor );
 
-void tr_peerMgrRemoveTorrent( tr_peerMgr     * manager,
-                              const uint8_t  * torrentHash );
+void tr_peerMgrRemoveTorrent( tr_torrent * tor );
 
-void tr_peerMgrTorrentAvailability( const tr_peerMgr * manager,
-                                    const uint8_t    * torrentHash,
+void tr_peerMgrTorrentAvailability( const tr_torrent * tor,
                                     int8_t           * tab,
                                     unsigned int       tabCount );
 
-struct tr_bitfield* tr_peerMgrGetAvailable( const tr_peerMgr * manager,
-                                            const uint8_t    * torrentHash );
+struct tr_bitfield* tr_peerMgrGetAvailable( const tr_torrent * tor );
 
-int tr_peerMgrHasConnections( const tr_peerMgr * manager,
-                              const uint8_t    * torrentHash );
-
-void tr_peerMgrTorrentStats( const tr_peerMgr * manager,
-                             const uint8_t * torrentHash,
+void tr_peerMgrTorrentStats( tr_torrent * tor,
                              int * setmePeersKnown,
                              int * setmePeersConnected,
@@ -126 +166 @@
                              int * setmePeersFrom ); /* TR_PEER_FROM__MAX */
 
-struct tr_peer_stat* tr_peerMgrPeerStats( const tr_peerMgr  * manager,
-                                          const uint8_t     * torrentHash,
-                                          int               * setmeCount );
+struct tr_peer_stat* tr_peerMgrPeerStats( const tr_torrent * tor,
+                                          int              * setmeCount );
 
-float* tr_peerMgrWebSpeeds( const tr_peerMgr  * manager,
-                            const uint8_t     * torrentHash );
+float* tr_peerMgrWebSpeeds( const tr_torrent * tor );
 
 
+double tr_peerGetPieceSpeed( const tr_peer    * peer,
+                             uint64_t           now,
+                             tr_direction       direction );
+
 #endif

branches/1.5x/libtransmission/peer-msgs.c

@@ -31 +31 @@
 #include "peer-io.h"
 #include "peer-mgr.h"
-#include "peer-mgr-private.h"
 #include "peer-msgs.h"
 #include "platform.h" /* MAX_STACK_ARRAY_SIZE */
@@ -1048 +1047 @@
     uint8_t * tmp = tr_new( uint8_t, msglen );
     tr_benc val;
-    const tr_torrent * tor = msgs->torrent;
+    tr_torrent * tor = msgs->torrent;
     const uint8_t * added;
     size_t added_len;
@@ -1068 +1067 @@
                                         &n );
             for( i = 0; i < n; ++i )
-                tr_peerMgrAddPex( msgs->session->peerMgr, tor->info.hash,
-                                  TR_PEER_FROM_PEX, pex + i );
+                tr_peerMgrAddPex( tor, TR_PEER_FROM_PEX, pex + i );
             tr_free( pex );
         }
@@ -1084 +1082 @@
                                          &n );
             for( i = 0; i < n; ++i )
-                tr_peerMgrAddPex( msgs->session->peerMgr, tor->info.hash,
-                                  TR_PEER_FROM_PEX, pex + i );
+                tr_peerMgrAddPex( tor, TR_PEER_FROM_PEX, pex + i );
             tr_free( pex );
         }
@@ -1624 +1621 @@
 
         default:
+            ret = READ_ERR;
             assert( 0 );
     }
@@ -1915 +1913 @@
         tr_pex * newPex = NULL;
         tr_pex * newPex6 = NULL;
-        const int newCount = tr_peerMgrGetPeers( msgs->session->peerMgr,
-                                                 msgs->torrent->info.hash,
-                                                 &newPex, TR_AF_INET );
-        const int newCount6 = tr_peerMgrGetPeers( msgs->session->peerMgr,
-                                                  msgs->torrent->info.hash,
-                                                  &newPex6, TR_AF_INET6 );
+        const int newCount = tr_peerMgrGetPeers( msgs->torrent, &newPex, TR_AF_INET );
+        const int newCount6 = tr_peerMgrGetPeers( msgs->torrent, &newPex6, TR_AF_INET6 );
 
         /* build the diffs */
@@ -1981 +1975 @@
             for( i = 0; i < diffs.addedCount; ++i )
             {
+                tr_suspectAddress( &diffs.added[i].addr, "pex" );
                 memcpy( walk, &diffs.added[i].addr.addr, 4 ); walk += 4;
                 memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
@@ -2011 +2006 @@
             for( i = 0; i < diffs6.addedCount; ++i )
             {
+                tr_suspectAddress( &diffs6.added[i].addr, "pex6" );
                 memcpy( walk, &diffs6.added[i].addr.addr.addr6.s6_addr, 16 );
                 walk += 16;

branches/1.5x/libtransmission/port-forwarding.c

@@ -166 +166 @@
 incomingPeersPulse( tr_shared * s )
 {
-    int allPaused;
-    tr_torrent * tor;
+    tr_bool allPaused;
     
     if( s->shouldChange )
@@ -177 +176 @@
     }
     
-    /* see if any torrents aren't paused */
-    allPaused = 1;
-    tor = NULL;
-    while( ( tor = tr_torrentNext( s->session, tor ) ) )
-    {
-        if( TR_STATUS_IS_ACTIVE( tr_torrentGetActivity( tor ) ) )
-        {
-            allPaused = 0;
-            break;
-        }
-    }
+    allPaused = tr_sessionGetActiveTorrentCount( s->session ) == 0;
     
     /* if we have any running torrents, check for new incoming peer connections */

branches/1.5x/libtransmission/resume.c

@@ -69 +69 @@
 {
     tr_pex * pex = NULL;
-    int count = tr_peerMgrGetPeers( tor->session->peerMgr,
-                                    tor->info.hash, &pex, TR_AF_INET );
+    int count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET );
 
     if( count > 0 )
@@ -78 +77 @@
     pex = NULL;
     
-    count = tr_peerMgrGetPeers( tor->session->peerMgr, tor->info.hash, &pex,
-                                TR_AF_INET6 );
+    count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET6 );
     if( count > 0 )
         tr_bencDictAddRaw( dict, KEY_PEERS6, pex, sizeof( tr_pex ) * count );
@@ -102 +100 @@
             tr_pex pex;
             memcpy( &pex, str + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
-            tr_peerMgrAddPex( tor->session->peerMgr,
-                              tor->info.hash, TR_PEER_FROM_CACHE, &pex );
+            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
         }
         tr_tordbg( tor, "Loaded %d IPv4 peers from resume file", count );
@@ -117 +114 @@
             tr_pex pex;
             memcpy( &pex, str + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
-            tr_peerMgrAddPex( tor->session->peerMgr,
-                              tor->info.hash, TR_PEER_FROM_CACHE, &pex );
+            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
         }
         tr_tordbg( tor, "Loaded %d IPv6 peers from resume file", count );

branches/1.5x/libtransmission/rpc-server.c

@@ -709 +709 @@
 tr_rpc_server *
 tr_rpcInit( tr_session  * session,
-            tr_bool       isEnabled,
-            tr_port       port,
-            tr_bool       isWhitelistEnabled,
-            const char  * whitelist,
-            tr_bool       isPasswordEnabled,
-            const char  * username,
-            const char  * password )
+            tr_benc * settings )
 {
     tr_rpc_server * s;
+    tr_bool found;
+    int64_t i;
+    const char *str;
 
     s = tr_new0( tr_rpc_server, 1 );
     s->session = session;
-    s->port = port;
-    s->username = tr_strdup( username );
-    s->password = tr_strdup( password );
-    s->isWhitelistEnabled = isWhitelistEnabled;
-    s->isPasswordEnabled = isPasswordEnabled;
-    s->isEnabled = isEnabled != 0;
-    tr_rpcSetWhitelist( s, whitelist ? whitelist : "127.0.0.1" );
+
+    found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_ENABLED, &i );
+    assert( found );
+    s->isEnabled = i != 0;
+
+    found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_PORT, &i );
+    assert( found );
+    s->port = i;
+
+    found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, &i );
+    assert( found );
+    s->isWhitelistEnabled = i != 0;
+
+    found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &i );
+    assert( found );
+    s->isPasswordEnabled = i != 0;
+
+    found = tr_bencDictFindStr( settings, TR_PREFS_KEY_RPC_WHITELIST, &str );
+    assert( found );
+    tr_rpcSetWhitelist( s, str ? str : "127.0.0.1" );
+
+    found = tr_bencDictFindStr( settings, TR_PREFS_KEY_RPC_USERNAME, &str );
+    assert( found );
+    s->username = tr_strdup( str );
+
+    found = tr_bencDictFindStr( settings, TR_PREFS_KEY_RPC_PASSWORD, &str );
+    assert( found );
+    s->password = tr_strdup( str );
 
 #ifdef HAVE_ZLIB
@@ -736 +754 @@
 #endif
 
-    if( isEnabled )
+    if( s->isEnabled )
+    {
+        tr_ninf( MY_NAME, _( "Serving RPC and Web requests on port %d" ), (int) s->port );
         tr_runInEventThread( session, startServer, s );
 
-    if( isEnabled )
-    {
-        tr_ninf( MY_NAME, _( "Serving RPC and Web requests on port %d" ), (int)port );
-
-        if( isWhitelistEnabled )
+        if( s->isWhitelistEnabled )
             tr_ninf( MY_NAME, _( "Whitelist enabled" ) );
 
-        if( isPasswordEnabled )
+        if( s->isPasswordEnabled )
             tr_ninf( MY_NAME, _( "Password required" ) );
     }

branches/1.5x/libtransmission/rpc-server.h

@@ -21 +21 @@
 
 tr_rpc_server * tr_rpcInit( tr_session  * session,
-                            tr_bool       isEnabled,
-                            tr_port       port,
-                            tr_bool       isWhitelistEnabled,
-                            const char  * whitelist,
-                            tr_bool       isPasswordEnabled,
-                            const char  * username,
-                            const char  * password );
+                            tr_benc  * settings );
 
 void            tr_rpcClose( tr_rpc_server ** freeme );

branches/1.5x/libtransmission/rpcimpl.c

@@ -688 +688 @@
               tr_benc     * args_out )
 {
-    tr_benc    * d;
-    tr_torrent * tor;
-    int          running;
-    int          total;
-
-    tor = NULL;
-    total = running = 0;
+    int running = 0;
+    int total = 0;
+    tr_torrent * tor = NULL;
+
     while(( tor = tr_torrentNext( session, tor ))) {
         ++total;
@@ -701 +698 @@
     }
 
-    d = tr_bencDictAddDict( args_out, "session-stats", 5 );
-    tr_bencDictAddInt( d, "activeTorrentCount", running );
-    tr_bencDictAddInt( d, "downloadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_DOWN ) * 1024 ) );
-    tr_bencDictAddInt( d, "pausedTorrentCount", total - running );
-    tr_bencDictAddInt( d, "torrentCount", total );
-    tr_bencDictAddInt( d, "uploadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_UP ) * 1024 ) );
+    tr_bencDictAddInt( args_out, "activeTorrentCount", running );
+    tr_bencDictAddInt( args_out, "downloadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_DOWN ) * 1024 ) );
+    tr_bencDictAddInt( args_out, "pausedTorrentCount", total - running );
+    tr_bencDictAddInt( args_out, "torrentCount", total );
+    tr_bencDictAddInt( args_out, "uploadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_UP ) * 1024 ) );
     return NULL;
 }

branches/1.5x/libtransmission/session.c

@@ -238 +238 @@
     tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              TRUE );
     tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          TRUE );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION,            TR_PREALLOCATE_SPARSE );
     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    "" );
     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       FALSE );
@@ -283 +284 @@
     tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              s->isPexEnabled );
     tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          tr_sessionIsPortForwardingEnabled( s ) );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION,            s->preallocationMode );
     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    s->proxy );
     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       s->isProxyAuthEnabled );
@@ -370 +372 @@
     tr_session * session;
     char * filename;
-    int64_t rpc_enabled, whitelist_enabled, rpc_auth_enabled, rpc_port;
-    const char * whitelist = NULL, *rpc_passwd = NULL, *rpc_username = NULL;
 
     assert( tr_bencIsDict( clientSettings ) );
@@ -406 +406 @@
     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ENCRYPTION, &i ); 
     assert( found ); 
+    assert( tr_isEncryptionMode( i ) );
     session->encryptionMode = i; 
+
+    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PREALLOCATION, &i );
+    assert( found );
+    assert( tr_isPreallocationMode( i ) );
+    session->preallocationMode = i;
  
     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &i ); 
@@ -528 +534 @@
 
     session->web = tr_webInit( session ); 
-    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_ENABLED, &rpc_enabled ) 
-         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_PORT, &rpc_port ) 
-         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, &whitelist_enabled ) 
-         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &rpc_auth_enabled ) 
-         && tr_bencDictFindStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, &whitelist ) 
-         && tr_bencDictFindStr( &settings, TR_PREFS_KEY_RPC_USERNAME, &rpc_username ) 
-         && tr_bencDictFindStr( &settings, TR_PREFS_KEY_RPC_PASSWORD, &rpc_passwd ); 
-    assert( found ); 
-    session->rpcServer = tr_rpcInit( session, rpc_enabled, rpc_port, whitelist_enabled, whitelist, 
-                                     rpc_auth_enabled, rpc_username, rpc_passwd ); 
+    session->rpcServer = tr_rpcInit( session, &settings ); 
 
     metainfoLookupRescan( session );
@@ -1411 +1408 @@
 }
 
+int
+tr_sessionGetActiveTorrentCount( tr_session * session )
+{
+    int ret = 0;
+    tr_torrent * tor = NULL;
+
+    while(( tor = tr_torrentNext( session, tor )))
+        if( tr_torrentGetActivity( tor ) != TR_STATUS_STOPPED )
+            ++ret;
+    
+    return ret;
+}

branches/1.5x/libtransmission/session.h

@@ -71 +71 @@
 
     tr_encryption_mode           encryptionMode;
+
+    tr_preallocation_mode        preallocationMode;
 
     struct tr_event_handle *     events;

branches/1.5x/libtransmission/torrent.c

@@ -206 +206 @@
                 if( event->allAreSeeds )
                     pex[i].flags |= ADDED_F_SEED_FLAG;
-                tr_peerMgrAddPex( tor->session->peerMgr, tor->info.hash,
-                                  TR_PEER_FROM_TRACKER, pex + i );
+                tr_peerMgrAddPex( tor, TR_PEER_FROM_TRACKER, pex + i );
             }
 
@@ -745 +744 @@
                              &s->downloaders );
 
-    tr_peerMgrTorrentStats( tor->session->peerMgr,
-                            tor->info.hash,
+    tr_peerMgrTorrentStats( tor,
                             &s->peersKnown,
                             &s->peersConnected,
@@ -800 +798 @@
     {
         tr_piece_index_t i;
-        tr_bitfield *    peerPieces = tr_peerMgrGetAvailable(
-            tor->session->peerMgr,
-            tor->info.
-            hash );
+        tr_bitfield *    peerPieces = tr_peerMgrGetAvailable( tor );
         s->desiredAvailable = 0;
         for( i = 0; i < tor->info.pieceCount; ++i )
@@ -920 +915 @@
 tr_torrentWebSpeeds( const tr_torrent * tor )
 {
-    return tor ? tr_peerMgrWebSpeeds( tor->session->peerMgr, tor->info.hash )
-           : NULL;
+    return tor ? tr_peerMgrWebSpeeds( tor ) : NULL;
 }
 
@@ -931 +925 @@
 
     if( tor )
-        ret = tr_peerMgrPeerStats( tor->session->peerMgr,
-                                   tor->info.hash, peerCount );
+        ret = tr_peerMgrPeerStats( tor, peerCount );
 
     return ret;
@@ -949 +942 @@
                         int                size )
 {
-    tr_peerMgrTorrentAvailability( tor->session->peerMgr,
-                                   tor->info.hash,
-                                   tab, size );
+    tr_peerMgrTorrentAvailability( tor, tab, size );
 }
 
@@ -1013 +1004 @@
     tr_globalLock( session );
 
-    tr_peerMgrRemoveTorrent( session->peerMgr, tor->info.hash );
+    tr_peerMgrRemoveTorrent( tor );
 
     tr_cpDestruct( &tor->completion );
@@ -1066 +1057 @@
     tor->startDate = time( NULL );
     tr_trackerStart( tor->tracker );
-    tr_peerMgrStartTorrent( tor->session->peerMgr, tor->info.hash );
+    tr_peerMgrStartTorrent( tor );
 
     tr_globalUnlock( tor->session );
@@ -1155 +1146 @@
 
     tr_verifyRemove( tor );
-    tr_peerMgrStopTorrent( tor->session->peerMgr, tor->info.hash );
+    tr_peerMgrStopTorrent( tor );
     tr_trackerStop( tor->tracker );
 

branches/1.5x/libtransmission/torrent.h

@@ -25 +25 @@
 struct tr_bandwidth;
 struct tr_ratecontrol;
+struct tr_torrent_peers;
 
 /**
@@ -111 +112 @@
 time_t*          tr_torrentGetMTimes( const tr_torrent  * tor,
                                       size_t            * setmeCount );
+
+tr_torrent*      tr_torrentNext( tr_session  * session,
+                                 tr_torrent  * current );
+
 
 typedef enum
@@ -194 +199 @@
 
     struct tr_bandwidth      * bandwidth;
+
+    struct tr_torrent_peers  * torrentPeers;
 };
 

branches/1.5x/libtransmission/tracker.c

@@ -260 +260 @@
         memcpy( &addr.addr.addr4, compactWalk, 4 );
         memcpy( &port, compactWalk + 4, 2 );
+        tr_suspectAddress( &addr, "compact" );
         
         memcpy( walk, &addr, sizeof( addr ) );
@@ -292 +293 @@
         memcpy( &port, compactWalk + 16, 2 );
         compactWalk += 18;
+        tr_suspectAddress( &addr, "compact6" );
         
         memcpy( walk, &addr, sizeof( addr ) );
@@ -367 +369 @@
 
         memcpy( walk, &addr, sizeof( tr_address ) );
+        tr_suspectAddress( &addr, "old tracker" );
         port = htons( itmp );
         memcpy( walk + sizeof( tr_address ), &port, 2 );
@@ -933 +936 @@
 
     /* upkeep: queue periodic rescrape / reannounce */
-    for( tor = session->torrentList; tor; tor = tor->next )
+    tor = NULL;
+    while(( tor = tr_torrentNext( session, tor )))
     {
         tr_tracker * t = tor->tracker;
@@ -962 +966 @@
     if( ( session->tracker )
       && ( session->tracker->runningCount < 1 )
-      && ( session->torrentList == NULL ) )
+      && ( tr_sessionCountTorrents( session ) == 0 ) )
     {
         tr_trackerSessionClose( session );

branches/1.5x/libtransmission/transmission.h

@@ -107 +107 @@
 typedef enum
 {
+    TR_PREALLOCATE_NONE   = 0,
+    TR_PREALLOCATE_SPARSE = 1,
+    TR_PREALLOCATE_FULL   = 2
+}
+tr_preallocation_mode;
+
+static TR_INLINE tr_bool tr_isPreallocationMode( tr_preallocation_mode m  )
+{
+    return ( m == TR_PREALLOCATE_NONE )
+        || ( m == TR_PREALLOCATE_SPARSE )
+        || ( m == TR_PREALLOCATE_FULL );
+}
+
+typedef enum
+{
     TR_PROXY_HTTP,
     TR_PROXY_SOCKS4,
@@ -120 +135 @@
 }
 tr_encryption_mode;
+
+static TR_INLINE tr_bool tr_isEncryptionMode( tr_encryption_mode m )
+{
+    return ( m == TR_CLEAR_PREFERRED )
+        || ( m == TR_ENCRYPTION_PREFERRED )
+        || ( m == TR_ENCRYPTION_REQUIRED );
+}
+
 
 #define TR_DEFAULT_OPEN_FILE_LIMIT_STR "32"
@@ -147 +170 @@
 #define TR_PREFS_KEY_PORT_FORWARDING            "port-forwarding-enabled"
 #define TR_PREFS_KEY_PROXY_AUTH_ENABLED         "proxy-auth-enabled"
+#define TR_PREFS_KEY_PREALLOCATION              "preallocation"
 #define TR_PREFS_KEY_PROXY_ENABLED              "proxy-enabled"
 #define TR_PREFS_KEY_PROXY_PASSWORD             "proxy-auth-password"
@@ -564 +588 @@
                                       int         * setmeCount );
 
+int tr_sessionGetActiveTorrentCount( tr_session * session );
+
 /** @} */
 
@@ -817 +843 @@
  */
 void tr_torrentDeleteLocalData( tr_torrent * torrent,  tr_fileFunc fileFunc );
-
-/**
- * @brief Iterate through the torrents.
- *
- * Pass in a NULL pointer to get the first torrent.
- */
-tr_torrent* tr_torrentNext( tr_session  * session,
-                            tr_torrent  * current );
-
 
 uint64_t tr_torrentGetBytesLeftToAllocate( const tr_torrent * torrent );

branches/1.5x/libtransmission/web.c

@@ -129 +129 @@
         curl_easy_setopt( easy, CURLOPT_CONNECTTIMEOUT, 120L );
         curl_easy_setopt( easy, CURLOPT_FOLLOWLOCATION, 1L );
+        curl_easy_setopt( easy, CURLOPT_FORBID_REUSE, 1L );
         curl_easy_setopt( easy, CURLOPT_NOSIGNAL, 1L );
         curl_easy_setopt( easy, CURLOPT_PRIVATE, task );