Changeset 3105

Timestamp:

Sep 20, 2007, 4:32:01 PM (16 years ago)

Author:

livings124

Message:

merge encryption branch to trunk (xcode project is still out of date)

Location:

trunk

Files:

• doc/encryption.txt (copied) (copied from branches/encryption/doc/encryption.txt)
• doc/properties.txt (copied) (copied from branches/encryption/doc/properties.txt)
• gtk/lock-icon.h (copied) (copied from branches/encryption/gtk/lock-icon.h)
• gtk/main.c (modified) (3 diffs)
• gtk/torrent-inspector.c (modified) (8 diffs)
• libtransmission/Makefile.am (modified) (4 diffs)
• libtransmission/bencode.c (modified) (3 diffs)
• libtransmission/bencode.h (modified) (1 diff)
• libtransmission/choking.c (deleted)
• libtransmission/clients.c (modified) (1 diff)
• libtransmission/clients.h (modified) (1 diff)
• libtransmission/completion.c (modified) (17 diffs)
• libtransmission/completion.h (modified) (1 diff)
• libtransmission/crypto.c (copied) (copied from branches/encryption/libtransmission/crypto.c)
• libtransmission/crypto.h (copied) (copied from branches/encryption/libtransmission/crypto.h)
• libtransmission/fastresume.c (modified) (20 diffs)
• libtransmission/fastresume.h (modified) (2 diffs)
• libtransmission/fdlimit.c (modified) (2 diffs)
• libtransmission/handshake.c (copied) (copied from branches/encryption/libtransmission/handshake.c)
• libtransmission/handshake.h (copied) (copied from branches/encryption/libtransmission/handshake.h)
• libtransmission/http.c (modified) (6 diffs)
• libtransmission/inout.c (modified) (17 diffs)
• libtransmission/inout.h (modified) (2 diffs)
• libtransmission/internal.h (modified) (6 diffs)
• libtransmission/ipcparse.c (modified) (2 diffs)
• libtransmission/ipcparse.h (modified) (2 diffs)
• libtransmission/list.c (modified) (9 diffs)
• libtransmission/list.h (modified) (1 diff)
• libtransmission/makemeta.c (modified) (5 diffs)
• libtransmission/metainfo.c (modified) (16 diffs)
• libtransmission/metainfo.h (modified) (1 diff)
• libtransmission/net.c (modified) (3 diffs)
• libtransmission/net.h (modified) (1 diff)
• libtransmission/peer-io.c (copied) (copied from branches/encryption/libtransmission/peer-io.c)
• libtransmission/peer-io.h (copied) (copied from branches/encryption/libtransmission/peer-io.h)
• libtransmission/peer-mgr-private.h (copied) (copied from branches/encryption/libtransmission/peer-mgr-private.h)
• libtransmission/peer-mgr.c (copied) (copied from branches/encryption/libtransmission/peer-mgr.c)
• libtransmission/peer-mgr.h (copied) (copied from branches/encryption/libtransmission/peer-mgr.h)
• libtransmission/peer-msgs.c (copied) (copied from branches/encryption/libtransmission/peer-msgs.c)
• libtransmission/peer-msgs.h (copied) (copied from branches/encryption/libtransmission/peer-msgs.h)
• libtransmission/peer.c (modified) (18 diffs)
• libtransmission/peer.h (modified) (3 diffs)
• libtransmission/peeraz.h (modified) (5 diffs)
• libtransmission/peerext.h (modified) (6 diffs)
• libtransmission/peermessages.h (modified) (7 diffs)
• libtransmission/peerparse.h (modified) (11 diffs)
• libtransmission/peerutils.h (modified) (5 diffs)
• libtransmission/platform.c (modified) (21 diffs)
• libtransmission/platform.h (modified) (2 diffs)
• libtransmission/ptrarray.c (modified) (15 diffs)
• libtransmission/ptrarray.h (modified) (1 diff)
• libtransmission/publish.c (modified) (4 diffs)
• libtransmission/publish.h (modified) (1 diff)
• libtransmission/ratecontrol.c (modified) (8 diffs)
• libtransmission/ratecontrol.h (modified) (1 diff)
• libtransmission/sha1.c (deleted)
• libtransmission/sha1.h (deleted)
• libtransmission/shared.c (modified) (13 diffs)
• libtransmission/shared.h (modified) (5 diffs)
• libtransmission/timer.c (deleted)
• libtransmission/timer.h (deleted)
• libtransmission/torrent.c (modified) (65 diffs)
• libtransmission/tracker.c (modified) (38 diffs)
• libtransmission/tracker.h (modified) (3 diffs)
• libtransmission/transmission.c (modified) (15 diffs)
• libtransmission/transmission.h (modified) (38 diffs)
• libtransmission/trevent.c (modified) (8 diffs)
• libtransmission/trevent.h (modified) (3 diffs)
• libtransmission/upnp.c (modified) (6 diffs)
• libtransmission/utils.c (modified) (18 diffs)
• libtransmission/utils.h (modified) (1 diff)
• mk/version.sh (modified) (1 diff)

trunk/gtk/main.c

@@ -168 +168 @@
 
 static void
-safepipe(void);
-static void
 setupsighandlers(void);
 static void
@@ -229 +227 @@
     gboolean     didinit, didlock, sendquit, startpaused;
 
-    safepipe();                 /* ignore SIGPIPE */
     argfiles = readargs( argc, argv, &sendquit, &startpaused );
     didinit = cf_init( tr_getPrefsDirectory(), NULL );
@@ -1108 +1105 @@
 
 static void
-safepipe(void) {
-  struct sigaction sa;
-
-  memset(&sa, 0,  sizeof(sa));
-  sa.sa_handler = SIG_IGN;
-  sigaction(SIGPIPE, &sa, NULL);
-}
-
-static void
 setupsighandlers(void) {
   int sigs[] = {SIGHUP, SIGINT, SIGQUIT, SIGTERM};

trunk/gtk/torrent-inspector.c

@@ -34 +34 @@
 #include "tr_torrent.h"
 #include "dot-icons.h"
+#include "lock-icon.h"
 #include "hig.h"
 #include "torrent-inspector.h"
@@ -237 +238 @@
   PEER_COL_PROGRESS,
   PEER_COL_IS_CONNECTED,
+  PEER_COL_IS_ENCRYPTED,
   PEER_COL_IS_DOWNLOADING,
   PEER_COL_DOWNLOAD_RATE,
@@ -251 +253 @@
   N_("Progress"),
   " ",
+  " ",
   N_("Downloading"),
   N_("DL Rate"),
@@ -284 +287 @@
                       PEER_COL_PORT, peer->port,
                       PEER_COL_CLIENT, client,
+                      PEER_COL_IS_ENCRYPTED, peer->isEncrypted,
                       PEER_COL_PROGRESS, (int)(100.0*peer->progress + 0.5),
                       PEER_COL_IS_CONNECTED, peer->isConnected,
@@ -315 +319 @@
                                          G_TYPE_INT,     /* progress [0..100] */
                                          G_TYPE_BOOLEAN, /* isConnected */
+                                         G_TYPE_BOOLEAN, /* isEncrypted */
                                          G_TYPE_BOOLEAN, /* isDownloading */
                                          G_TYPE_FLOAT,   /* downloadFromRate */
@@ -349 +354 @@
 
 static void
+render_encrypted (GtkTreeViewColumn  * column UNUSED,
+                  GtkCellRenderer    * renderer,
+                  GtkTreeModel       * tree_model,
+                  GtkTreeIter        * iter,
+                  gpointer             data UNUSED)
+{
+  static GdkPixbuf * lock = NULL;
+  gboolean is_encrypted = FALSE;
+  gtk_tree_model_get (tree_model, iter, PEER_COL_IS_ENCRYPTED, &is_encrypted,
+                                        -1);
+  if (!lock) lock = gdk_pixbuf_new_from_inline (-1, lock_icon, FALSE, NULL);
+  g_object_set (renderer, "xalign", (gfloat)0.0,
+                          "yalign", (gfloat)0.5,
+                          "pixbuf", (is_encrypted ? lock : NULL),
+                          NULL);
+}
+
+static void
 render_ul_rate (GtkTreeViewColumn  * column UNUSED,
                 GtkCellRenderer    * renderer,
@@ -495 +518 @@
   /* TODO: make this configurable? */
   int view_columns[] = { PEER_COL_IS_CONNECTED,
+                         PEER_COL_IS_ENCRYPTED,
                          PEER_COL_ADDRESS,
                          PEER_COL_CLIENT,
@@ -537 +561 @@
         c = gtk_tree_view_column_new_with_attributes (
               _("Progress"), r, "value", PEER_COL_PROGRESS, NULL);
+        break;
+
+      case PEER_COL_IS_ENCRYPTED:
+        resizable = FALSE;
+        r = gtk_cell_renderer_pixbuf_new ();
+        c = gtk_tree_view_column_new_with_attributes (t, r, NULL);
+        gtk_tree_view_column_set_sizing (c, GTK_TREE_VIEW_COLUMN_FIXED);
+        gtk_tree_view_column_set_fixed_width (c, 32);
+        gtk_tree_view_column_set_cell_data_func (c, r, render_encrypted,
+                                                 NULL, NULL);
         break;
 

trunk/libtransmission/Makefile.am

@@ -10 +10 @@
     basename.c \
     bencode.c \
-    choking.c \
     clients.c \
     completion.c \
+    crypto.c \
     dirname.c \
     fastresume.c \
     fdlimit.c \
+    handshake.c \
     http.c \
     inout.c \
@@ -24 +25 @@
     natpmp.c \
     net.c \
-    peer.c \
+    peer-io.c \
+    peer-mgr.c \
+    peer-msgs.c \
     platform.c \
     ptrarray.c \
     publish.c \
     ratecontrol.c \
-    sha1.c \
     shared.c \
     strlcat.c \
     strlcpy.c \
-    timer.c \
     torrent.c \
     tracker.c \
@@ -46 +47 @@
     bsdqueue.h \
     bsdtree.h \
-    choking.h \
     clients.h \
+    crypto.h \
     completion.h \
     fastresume.h \
     fdlimit.h \
+    handshake.h \
     http.h \
     inout.h \
@@ -60 +62 @@
     natpmp.h \
     net.h \
-    peeraz.h \
-    peerext.h \
-    peer.h \
-    peermessages.h \
-    peerparse.h \
-    peertree.h \
-    peerutils.h \
+    peer-io.h \
+    peer-mgr.h \
+    peer-mgr-private.h \
+    peer-msgs.h \
     platform.h \
     ptrarray.h \
     publish.h \
     ratecontrol.h \
-    sha1.h \
     shared.h \
-    timer.h \
     tracker.h \
     transmission.h \

trunk/libtransmission/bencode.c

@@ -365 +365 @@
     benc_val_t * item;
 
-    assert( TYPE_LIST == list->type );
+    assert( tr_bencIsList( list ) );
     assert( list->val.l.count < list->val.l.alloc );
 
@@ -379 +379 @@
     benc_val_t * keyval, * itemval;
 
-    assert( TYPE_DICT == dict->type );
+    assert( tr_bencIsDict( dict ) );
     assert( dict->val.l.count + 2 <= dict->val.l.alloc );
 
@@ -480 +480 @@
     return 0;
 }
+
+/**
+***
+**/
+
+int
+tr_bencIsStr ( const benc_val_t * val )
+{
+    return val!=NULL && val->type==TYPE_STR;
+}
+
+int
+tr_bencIsInt ( const benc_val_t * val )
+{
+    return val!=NULL && val->type==TYPE_INT;
+}
+
+int
+tr_bencIsList( const benc_val_t * val )
+{
+    return val!=NULL && val->type==TYPE_LIST;
+}
+
+int
+tr_bencIsDict( const benc_val_t * val )
+{
+    return val!=NULL && val->type==TYPE_DICT;
+}

trunk/libtransmission/bencode.h

@@ -91 +91 @@
                           int * used, int * max );
 
+int    tr_bencIsStr   ( const benc_val_t * val );
+int    tr_bencIsInt   ( const benc_val_t * val );
+int    tr_bencIsList  ( const benc_val_t * val );
+int    tr_bencIsDict  ( const benc_val_t * val );
+
 #endif

trunk/libtransmission/clients.c

@@ -45 +45 @@
 }
 
-char * tr_clientForId( uint8_t * id )
+char * tr_clientForId( const uint8_t * id )
 {
     char * ret = NULL;

trunk/libtransmission/clients.h

@@ -23 +23 @@
  *****************************************************************************/
 
-char * tr_clientForId( uint8_t * );
+char * tr_clientForId( const uint8_t * );

trunk/libtransmission/completion.c

@@ -30 +30 @@
 #include "utils.h"
 
-struct tr_completion_s
-{
-    tr_torrent_t * tor;
-
-    /* true if a peer is requesting this block */
-    tr_bitfield_t * blockRequested;
+struct tr_completion
+{
+    tr_torrent * tor;
 
     /* do we have this block? */
-    tr_bitfield_t * blockBitfield;
+    tr_bitfield * blockBitfield;
 
     /* do we have this piece? */
-    tr_bitfield_t * pieceBitfield;
+    tr_bitfield * pieceBitfield;
 
     /* a block is complete if and only if we have it */
@@ -52 +49 @@
 };
 
-tr_completion_t * tr_cpInit( tr_torrent_t * tor )
-{
-    tr_completion_t * cp;
-
-    cp                   = tr_new( tr_completion_t, 1 );
+tr_completion * tr_cpInit( tr_torrent * tor )
+{
+    tr_completion * cp;
+
+    cp                   = tr_new( tr_completion, 1 );
     cp->tor              = tor;
     cp->blockBitfield    = tr_bitfieldNew( tor->blockCount );
-    cp->blockRequested   = tr_bitfieldNew( tor->blockCount );
     cp->pieceBitfield    = tr_bitfieldNew( tor->info.pieceCount );
     cp->completeBlocks   = tr_new( uint16_t, tor->info.pieceCount );
@@ -68 +64 @@
 }
 
-void tr_cpClose( tr_completion_t * cp )
+void tr_cpClose( tr_completion * cp )
 {
     tr_free(         cp->completeBlocks );
     tr_bitfieldFree( cp->pieceBitfield );
-    tr_bitfieldFree( cp->blockRequested );
     tr_bitfieldFree( cp->blockBitfield );
     tr_free(         cp );
 }
 
-void tr_cpReset( tr_completion_t * cp )
-{
-    tr_torrent_t * tor = cp->tor;
+void tr_cpReset( tr_completion * cp )
+{
+    tr_torrent * tor = cp->tor;
 
     tr_bitfieldClear( cp->pieceBitfield );
     tr_bitfieldClear( cp->blockBitfield );
-    tr_bitfieldClear( cp->blockRequested );
     memset( cp->completeBlocks, 0, sizeof(uint16_t) * tor->info.pieceCount );
 
@@ -97 +91 @@
 
 static void
-tr_cpEnsureDoneValid( const tr_completion_t * ccp )
-{
-    const tr_torrent_t * tor = ccp->tor;
+tr_cpEnsureDoneValid( const tr_completion * ccp )
+{
+    const tr_torrent * tor = ccp->tor;
     const tr_info_t * info = &tor->info;
     uint64_t have=0, total=0;
     int i;
-    tr_completion_t * cp ;
+    tr_completion * cp ;
 
     if( !ccp->doneDirty )
@@ -109 +103 @@
 
     /* too bad C doesn't have 'mutable' */
-    cp = (tr_completion_t*) ccp;
+    cp = (tr_completion*) ccp;
     cp->doneDirty = FALSE;
 
@@ -136 +130 @@
 
 void
-tr_cpInvalidateDND ( tr_completion_t * cp )
+tr_cpInvalidateDND ( tr_completion * cp )
 {
     cp->doneDirty = TRUE;
 }
 
-int tr_cpPieceIsComplete( const tr_completion_t * cp, int piece )
+int
+tr_cpPieceIsComplete( const tr_completion * cp, int piece )
 {
     return cp->completeBlocks[piece] >= tr_torPieceCountBlocks(cp->tor,piece);
 }
 
-const tr_bitfield_t * tr_cpPieceBitfield( const tr_completion_t * cp )
+const tr_bitfield * tr_cpPieceBitfield( const tr_completion * cp )
 {
     return cp->pieceBitfield;
 }
 
-void tr_cpPieceAdd( tr_completion_t * cp, int piece )
-{
-    const tr_torrent_t * tor = cp->tor;
+void tr_cpPieceAdd( tr_completion * cp, int piece )
+{
+    const tr_torrent * tor = cp->tor;
     const int start = tr_torPieceFirstBlock(tor,piece);
     const int end = start + tr_torPieceCountBlocks(tor,piece);
@@ -162 +157 @@
 }
 
-void tr_cpPieceRem( tr_completion_t * cp, int piece )
-{
-    const tr_torrent_t * tor = cp->tor;
+void tr_cpPieceRem( tr_completion * cp, int piece )
+{
+    const tr_torrent * tor = cp->tor;
     const int start = tr_torPieceFirstBlock(tor,piece);
     const int end = start + tr_torPieceCountBlocks(tor,piece);
@@ -191 +186 @@
 }
 
-/* Blocks */
-void tr_cpDownloaderAdd( tr_completion_t * cp, int block )
-{
-    tr_bitfieldAdd( cp->blockRequested, block );
-}
-
-void tr_cpDownloaderRem( tr_completion_t * cp, int block )
-{
-    tr_bitfieldRem( cp->blockRequested, block );
-}
-
-int tr_cpBlockIsComplete( const tr_completion_t * cp, int block )
-{
-    return tr_bitfieldHas( cp->blockBitfield, block );
+int tr_cpBlockIsComplete( const tr_completion * cp, int block )
+{
+    return tr_bitfieldHas( cp->blockBitfield, block ) ? 1 : 0;
 }
 
 void
-tr_cpBlockAdd( tr_completion_t * cp, int block )
-{
-    const tr_torrent_t * tor = cp->tor;
+tr_cpBlockAdd( tr_completion * cp, int block )
+{
+    const tr_torrent * tor = cp->tor;
 
     if( !tr_cpBlockIsComplete( cp, block ) )
@@ -231 +215 @@
 }
 
-const tr_bitfield_t * tr_cpBlockBitfield( const tr_completion_t * cp )
+const tr_bitfield * tr_cpBlockBitfield( const tr_completion * cp )
 {
     assert( cp != NULL );
@@ -239 +223 @@
 
 void
-tr_cpBlockBitfieldSet( tr_completion_t * cp, tr_bitfield_t * bitfield )
+tr_cpBlockBitfieldSet( tr_completion * cp, tr_bitfield * bitfield )
 {
     int i;
@@ -253 +237 @@
 }
 
-float tr_cpPercentBlocksInPiece( const tr_completion_t * cp, int piece )
+float tr_cpPercentBlocksInPiece( const tr_completion * cp, int piece )
 {
     assert( cp != NULL );
 
     return (double)cp->completeBlocks[piece] / tr_torPieceCountBlocks(cp->tor,piece);
-}
-
-int
-tr_cpMissingBlocksForPiece( const tr_completion_t * cp, int piece )
-{
-    int i;
-    int n;
-    const tr_torrent_t * tor = cp->tor;
-    const int start = tr_torPieceFirstBlock(tor,piece);
-    const int end   = start + tr_torPieceCountBlocks(tor,piece);
-
-    n = 0;
-    for( i = start; i < end; ++i )
-        if( !tr_cpBlockIsComplete( cp, i ) && !tr_bitfieldHas( cp->blockRequested, i ) )
-            ++n;
-
-    return n;
-}
-
-int tr_cpMissingBlockInPiece( const tr_completion_t * cp, int piece )
-{
-    int i;
-    const tr_torrent_t * tor = cp->tor;
-    const int start = tr_torPieceFirstBlock(tor,piece);
-    const int end   = start + tr_torPieceCountBlocks(tor,piece);
-
-    for( i = start; i < end; ++i )
-        if( !tr_cpBlockIsComplete( cp, i ) && !tr_bitfieldHas( cp->blockRequested, i ) )
-            return i;
-
-    return -1;
 }
 
@@ -296 +249 @@
 
 float
-tr_cpPercentComplete ( const tr_completion_t * cp )
+tr_cpPercentComplete ( const tr_completion * cp )
 {
     return (double)cp->completeHave / cp->tor->info.totalSize;
@@ -302 +255 @@
 
 uint64_t
-tr_cpLeftUntilComplete ( const tr_completion_t * cp )
+tr_cpLeftUntilComplete ( const tr_completion * cp )
 {
     return cp->tor->info.totalSize - cp->completeHave;
@@ -308 +261 @@
 
 float
-tr_cpPercentDone( const tr_completion_t * cp )
+tr_cpPercentDone( const tr_completion * cp )
 {
     tr_cpEnsureDoneValid( cp );
@@ -316 +269 @@
 
 uint64_t
-tr_cpLeftUntilDone ( const tr_completion_t * cp )
+tr_cpLeftUntilDone ( const tr_completion * cp )
 {
     tr_cpEnsureDoneValid( cp );
@@ -324 +277 @@
 
 cp_status_t
-tr_cpGetStatus ( const tr_completion_t * cp )
+tr_cpGetStatus ( const tr_completion * cp )
 {
     if( cp->completeHave >= cp->tor->info.totalSize )
@@ -338 +291 @@
 
 uint64_t
-tr_cpDownloadedValid( const tr_completion_t * cp )
+tr_cpDownloadedValid( const tr_completion * cp )
 {
     uint64_t b = 0;
-    const tr_torrent_t * tor = cp->tor;
+    const tr_torrent * tor = cp->tor;
     const tr_info_t * info = &tor->info;
     int i;

trunk/libtransmission/completion.h

@@ -28 +28 @@
 #include "transmission.h"
 
-typedef struct tr_completion_s tr_completion_t;
+typedef struct tr_completion tr_completion;
 
-tr_completion_t     * tr_cpInit( tr_torrent_t * );
-void                  tr_cpClose( tr_completion_t * );
-void                  tr_cpReset( tr_completion_t * );
+tr_completion  * tr_cpInit( tr_torrent * );
+void             tr_cpClose( tr_completion * );
+void             tr_cpReset( tr_completion * );
 
 /* General */
 
-cp_status_t           tr_cpGetStatus ( const tr_completion_t * );
-uint64_t              tr_cpDownloadedValid( const tr_completion_t * );
-uint64_t              tr_cpLeftUntilComplete( const tr_completion_t * );
-uint64_t              tr_cpLeftUntilDone( const tr_completion_t * );
-float                 tr_cpPercentComplete( const tr_completion_t * );
-float                 tr_cpPercentDone( const tr_completion_t * );
-void                  tr_cpInvalidateDND ( tr_completion_t * );
+cp_status_t      tr_cpGetStatus ( const tr_completion * );
+uint64_t         tr_cpDownloadedValid( const tr_completion * );
+uint64_t         tr_cpLeftUntilComplete( const tr_completion * );
+uint64_t         tr_cpLeftUntilDone( const tr_completion * );
+float            tr_cpPercentComplete( const tr_completion * );
+float            tr_cpPercentDone( const tr_completion * );
+void             tr_cpInvalidateDND ( tr_completion * );
 
 /* Pieces */
-int                   tr_cpPieceIsComplete( const tr_completion_t *, int piece );
-void                  tr_cpPieceAdd( tr_completion_t *, int piece );
-void                  tr_cpPieceRem( tr_completion_t *, int piece );
+int              tr_cpPieceIsComplete( const tr_completion *, int piece );
+void             tr_cpPieceAdd( tr_completion *, int piece );
+void             tr_cpPieceRem( tr_completion *, int piece );
 
 /* Blocks */
-void                  tr_cpDownloaderAdd( tr_completion_t *, int block );
-void                  tr_cpDownloaderRem( tr_completion_t *, int block );
-int                   tr_cpBlockIsComplete( const tr_completion_t *, int block );
-void                  tr_cpBlockAdd( tr_completion_t *, int block );
-void                  tr_cpBlockBitfieldSet( tr_completion_t *, struct tr_bitfield_s * );
-float                 tr_cpPercentBlocksInPiece( const tr_completion_t * cp, int piece );
-/* Missing = we don't have it and we are not getting it from any peer yet */
-int                   tr_cpMissingBlocksForPiece( const tr_completion_t * cp, int piece );
-int                   tr_cpMissingBlockInPiece( const tr_completion_t *, int piece );
+int              tr_cpBlockIsComplete( const tr_completion *, int block );
+void             tr_cpBlockAdd( tr_completion *, int block );
+void             tr_cpBlockBitfieldSet( tr_completion *, struct tr_bitfield * );
+float            tr_cpPercentBlocksInPiece( const tr_completion * cp, int piece );
 
-const struct tr_bitfield_s * tr_cpPieceBitfield( const tr_completion_t* );
-const struct tr_bitfield_s * tr_cpBlockBitfield( const tr_completion_t * );
+const struct tr_bitfield * tr_cpPieceBitfield( const tr_completion* );
+const struct tr_bitfield * tr_cpBlockBitfield( const tr_completion * );
 
 #endif

trunk/libtransmission/fastresume.c

@@ -56 +56 @@
 #include "completion.h"
 #include "fastresume.h"
-#include "peer.h"
+#include "peer-mgr.h"
 #include "platform.h"
 #include "utils.h"
@@ -75 +75 @@
 
     /* IPs and ports of connectable peers */
-    FR_ID_PEERS = 4,
+    FR_ID_PEERS_OLD = 4,
 
     /* progress data:
@@ -89 +89 @@
     /* transfer speeds
      * uint32_t: dl speed rate to use when the mode is single
-     * uint32_t: dl's tr_speedlimit_t
+     * uint32_t: dl's tr_speedlimit
      * uint32_t: ul speed rate to use when the mode is single
-     * uint32_t: ul's tr_speedlimit_t
+     * uint32_t: ul's tr_speedlimit
      */
     FR_ID_SPEED = 8,
@@ -101 +101 @@
 
     /* number of corrupt bytes downloaded */
-    FR_ID_CORRUPT = 10
+    FR_ID_CORRUPT = 10,
+
+    /* IPs and ports of connectable peers */
+    FR_ID_PEERS = 11
 };
 
@@ -115 +118 @@
 
 static void
-fastResumeFileName( char * buf, size_t buflen, const tr_torrent_t * tor, int tag )
+fastResumeFileName( char * buf, size_t buflen, const tr_torrent * tor, int tag )
 {
     const char * cacheDir = tr_getCacheDirectory ();
@@ -133 +136 @@
 
 static tr_time_t*
-getMTimes( const tr_torrent_t * tor, int * setme_n )
+getMTimes( const tr_torrent * tor, int * setme_n )
 {
     int i;
@@ -172 +175 @@
 
 void
-tr_fastResumeSave( const tr_torrent_t * tor )
+tr_fastResumeSave( const tr_torrent * tor )
 {
     char      path[MAX_PATH_LENGTH];
@@ -195 +198 @@
         uint8_t * buf = malloc( FR_PROGRESS_LEN( tor ) );
         uint8_t * walk = buf;
-        const tr_bitfield_t * bitfield;
+        const tr_bitfield * bitfield;
 
         /* mtimes */
@@ -284 +287 @@
 
     /* Write download and upload totals */
+
     total = tor->downloadedCur + tor->downloadedPrev;
     fastResumeWriteData( FR_ID_DOWNLOADED, &total, 8, 1, file );
+
     total = tor->uploadedCur + tor->uploadedPrev;
     fastResumeWriteData( FR_ID_UPLOADED, &total, 8, 1, file );
+
     total = tor->corruptCur + tor->corruptPrev;
     fastResumeWriteData( FR_ID_CORRUPT, &total, 8, 1, file );
@@ -293 +299 @@
     if( !( TR_FLAG_PRIVATE & tor->info.flags ) )
     {
-        /* Write IPs and ports of connectable peers, if any */
-        int size;
-        uint8_t * buf = NULL;
-        if( ( size = tr_peerGetConnectable( tor, &buf ) ) > 0 )
-        {
-            fastResumeWriteData( FR_ID_PEERS, buf, size, 1, file );
-            free( buf );
-        }
+        tr_pex * pex;
+        const int count = tr_peerMgrGetPeers( tor->handle->peerMgr,
+                                              tor->info.hash,
+                                              &pex );
+        if( count > 0 )
+            fastResumeWriteData( FR_ID_PEERS, pex, sizeof(tr_pex), count, file );
+        tr_free( pex );
     }
 
@@ -309 +314 @@
 
 static int
-loadSpeeds( tr_torrent_t * tor, FILE * file )
+loadSpeeds( tr_torrent * tor, FILE * file )
 {
     const size_t len = FR_SPEED_LEN;
@@ -326 +331 @@
     tr_torrentSetSpeedLimit( tor, TR_DOWN, i16 );
     memcpy( &i8, walk, 1 ); walk += 1;
-    tr_torrentSetSpeedMode( tor, TR_DOWN, (tr_speedlimit_t)i8 );
+    tr_torrentSetSpeedMode( tor, TR_DOWN, (tr_speedlimit)i8 );
     memcpy( &i16, walk, 2 ); walk += 2;
     tr_torrentSetSpeedLimit( tor, TR_UP, i16 );
     memcpy( &i8, walk, 1 ); walk += 1;
-    tr_torrentSetSpeedMode( tor, TR_UP, (tr_speedlimit_t)i8 );
+    tr_torrentSetSpeedMode( tor, TR_UP, (tr_speedlimit)i8 );
 
     tr_free( buf );
@@ -338 +343 @@
 
 static int
-loadPriorities( tr_torrent_t * tor,
-                FILE         * file )
+loadPriorities( tr_torrent * tor,
+                FILE       * file )
 {
     const size_t n = tor->info.fileCount;
@@ -388 +393 @@
 
 static int
-fastResumeLoadProgress( const tr_torrent_t  * tor,
-                        tr_bitfield_t       * uncheckedPieces,
-                        FILE                * file )
+fastResumeLoadProgress( const tr_torrent  * tor,
+                        tr_bitfield       * uncheckedPieces,
+                        FILE              * file )
 {
     int i;
@@ -410 +415 @@
         for( i=0; i<n; ++i ) {
             if ( curMTimes[i]!=oldMTimes[i] ) {
-                const tr_file_t * file = &tor->info.files[i];
+                const tr_file * file = &tor->info.files[i];
                 tr_dbg( "File '%s' mtimes differ-- flagging pieces [%d..%d] for recheck",
                         file->name, file->firstPiece, file->lastPiece);
@@ -423 +428 @@
     /* get the completion bitfield */
     if (1) {
-        tr_bitfield_t bitfield;
+        tr_bitfield bitfield;
         memset( &bitfield, 0, sizeof bitfield );
         bitfield.len = FR_BLOCK_BITFIELD_LEN( tor );
@@ -442 +447 @@
 
 static uint64_t
-fastResumeLoadOld( tr_torrent_t   * tor,
-                   tr_bitfield_t  * uncheckedPieces, 
-                   FILE           * file )
+fastResumeLoadOld( tr_torrent   * tor,
+                   tr_bitfield  * uncheckedPieces, 
+                   FILE         * file )
 {
     uint64_t ret = 0;
@@ -476 +481 @@
 
 static uint64_t
-fastResumeLoadImpl ( tr_torrent_t   * tor,
-                     tr_bitfield_t  * uncheckedPieces )
+fastResumeLoadImpl ( tr_torrent   * tor,
+                     tr_bitfield  * uncheckedPieces )
 {
     char      path[MAX_PATH_LENGTH];
@@ -637 +642 @@
                 break;
 
+            case FR_ID_PEERS_OLD:
+                if( !( TR_FLAG_PRIVATE & tor->info.flags ) )
+                {
+                    uint8_t * buf = malloc( len );
+                    if( 1 != fread( buf, len, 1, file ) )
+                    {
+                        free( buf );
+                        fclose( file );
+                        return ret;
+                    }
+
+                    tr_peerMgrAddPeers( tor->handle->peerMgr,
+                                        tor->info.hash,
+                                        TR_PEER_FROM_CACHE,
+                                        buf, len / 6 );
+
+                    tr_dbg( "found %i peers in resume file", len/6 );
+                    free( buf );
+                    ret |= TR_FR_PEERS;
+                }
+
             case FR_ID_PEERS:
                 if( !( TR_FLAG_PRIVATE & tor->info.flags ) )
                 {
-                    int used;
-                    uint8_t * buf = malloc( len );
-                    if( 1 != fread( buf, len, 1, file ) )
-                    {
-                        free( buf );
-                        fclose( file );
-                        return ret;
-                    }
-                    used = tr_torrentAddCompact( tor, TR_PEER_FROM_CACHE,
-                                                 buf, len / 6 );
-                    tr_dbg( "found %i peers in resume file, used %i",
-                            len / 6, used );
-                    free( buf );
+                    const int count = len / sizeof(tr_pex);
+                    tr_pex * pex = tr_new0( tr_pex, count );
+                    if( 1 != fread( pex, sizeof(tr_pex), count, file ) )
+                    {
+                        free( pex );
+                        fclose( file );
+                        return ret;
+                    }
+
+                    tr_peerMgrAddPex( tor->handle->peerMgr,
+                                      tor->info.hash,
+                                      TR_PEER_FROM_CACHE,
+                                      pex, count );
+
+                    tr_dbg( "found %i peers in resume file", len/6 );
+                    free( pex );
                     ret |= TR_FR_PEERS;
                 }
@@ -671 +700 @@
 
 uint64_t
-tr_fastResumeLoad( tr_torrent_t   * tor,
-                   tr_bitfield_t  * uncheckedPieces )
+tr_fastResumeLoad( tr_torrent   * tor,
+                   tr_bitfield  * uncheckedPieces )
 {
     const uint64_t ret = fastResumeLoadImpl( tor, uncheckedPieces );

trunk/libtransmission/fastresume.h

@@ -26 +26 @@
 #define TR_FAST_RESUME_H
 
-void tr_fastResumeSave( const tr_torrent_t * tor );
+void tr_fastResumeSave( const tr_torrent * tor );
 
 enum
@@ -43 +43 @@
  * Returns a bitwise-or'ed set of the data loaded from fastresume
  */
-uint64_t tr_fastResumeLoad( tr_torrent_t         * tor,
-                            struct tr_bitfield_s * uncheckedPieces );
+uint64_t tr_fastResumeLoad( tr_torrent         * tor,
+                            struct tr_bitfield * uncheckedPieces );
 
 #endif

trunk/libtransmission/fdlimit.c

@@ -64 +64 @@
 typedef struct tr_fd_s
 {
-    tr_lock_t     * lock;
-    tr_cond_t     * cond;
+    tr_lock       * lock;
+    tr_cond       * cond;
     
     int             reserved;
@@ -391 +391 @@
 void tr_fdSocketClose( int s )
 {
-    tr_lockLock( gFd->lock );
+    if( s >= 0 )
+    {
+        tr_lockLock( gFd->lock );
 #ifdef BEOS_NETSERVER
-    closesocket( s );
+        closesocket( s );
 #else
-    close( s );
+        close( s );
 #endif
-    if( SocketGetPriority( s ) )
-        gFd->reserved--;
-    else
-        gFd->normal--;
-    tr_lockUnlock( gFd->lock );
+        if( SocketGetPriority( s ) )
+            gFd->reserved--;
+        else
+            gFd->normal--;
+        tr_lockUnlock( gFd->lock );
+    }
 }
 

trunk/libtransmission/http.c

@@ -32 +32 @@
 #include <sys/types.h>
 
+#include "evdns.h"
+
 #ifdef __BEOS__
 extern int vasprintf( char **, const char *, va_list );
@@ -85 +87 @@
 #define HTTP_LENGTH_CHUNKED     4
     char           lengthtype;
-    tr_resolve_t * resolve;
     char         * host;
     int            port;
@@ -568 +569 @@
 }
 
+static void
+resolve_cb( int result, char type, int count, int ttl, void *addresses, void *arg)
+{
+    tr_http_t * http = (tr_http_t *) arg;
+
+    if( (result!=DNS_ERR_NONE) || (type!=DNS_IPv4_A) || (ttl<0) || (count<1) )
+        http->state = HTTP_STATE_ERROR;
+    else {
+         struct in_addr *in_addrs = addresses;
+         http->sock = tr_netOpenTCP( &in_addrs[0], htons(http->port), 1 );
+         http->state = HTTP_STATE_CONNECT;
+    }
+}
+
 tr_tristate_t
 tr_httpPulse( tr_http_t * http, const char ** data, int * len )
@@ -587 +602 @@
                 break;
             }
-            http->resolve = tr_netResolveInit( http->host );
-            if( NULL == http->resolve )
+            if( evdns_resolve_ipv4( http->host, 0, resolve_cb, http ) )
             {
                 goto err;
@@ -596 +610 @@
 
         case HTTP_STATE_RESOLVE:
-            switch( tr_netResolvePulse( http->resolve, &addr ) )
-            {
-                case TR_NET_WAIT:
-                    return TR_NET_WAIT;
-                case TR_NET_ERROR:
-                    goto err;
-                case TR_NET_OK:
-                    tr_netResolveClose( http->resolve );
-                    http->resolve = NULL;
-                    http->sock = tr_netOpenTCP( &addr, htons( http->port ), 1 );
-                    http->state = HTTP_STATE_CONNECT;
-            }
-            /* fallthrough */
+            return TR_NET_WAIT;
 
         case HTTP_STATE_CONNECT:
@@ -898 +900 @@
 tr_httpClose( tr_http_t * http )
 {
-    if( NULL != http->resolve )
-    {
-        tr_netResolveClose( http->resolve );
-    }
     free( http->host );
-    if( 0 <= http->sock )
-    {
-        tr_netClose( http->sock );
-    }
+    tr_netClose( http->sock );
     free( http->header.buf );
     free( http->body.buf );

trunk/libtransmission/inout.c

@@ -21 +21 @@
 #include "transmission.h"
 #include "completion.h"
+#include "crypto.h"
+#include "fastresume.h"
 #include "fdlimit.h"
 #include "inout.h"
+#include "list.h"
 #include "net.h"
-#include "peer.h"
-#include "sha1.h"
+#include "platform.h"
+#include "peer-mgr.h"
 #include "utils.h"
 
-struct tr_io_s
-{
-    tr_torrent_t * tor;
+struct tr_io
+{
+    tr_torrent * tor;
 };
 
@@ -37 +40 @@
 ****/
 
-enum { TR_IO_READ, TR_IO_WRITE };
-
 #ifdef WIN32
 #define lseek _lseeki64
 #endif
 
-static int
-readOrWriteBytes ( const tr_torrent_t  * tor,
+enum { TR_IO_READ, TR_IO_WRITE };
+
+static int
+readOrWriteBytes ( const tr_torrent    * tor,
                    int                   ioMode,
                    int                   fileIndex,
@@ -51 +54 @@
                    size_t                buflen )
 {
-    const tr_info_t * info = &tor->info;
-    const tr_file_t * file = &info->files[fileIndex];
+    const tr_info * info = &tor->info;
+    const tr_file * file = &info->files[fileIndex];
     typedef size_t (* iofunc) ( int, void *, size_t );
     iofunc func = ioMode == TR_IO_READ ? (iofunc)read : (iofunc)write;
@@ -86 +89 @@
 
 static void
-findFileLocation ( const tr_torrent_t * tor,
+findFileLocation ( const tr_torrent * tor,
                    int                  pieceIndex,
                    int                  pieceOffset,
@@ -92 +95 @@
                    uint64_t           * fileOffset )
 {
-    const tr_info_t * info = &tor->info;
+    const tr_info * info = &tor->info;
 
     int i;
@@ -113 +116 @@
 
 static int
-ensureMinimumFileSize ( const tr_torrent_t  * tor,
+ensureMinimumFileSize ( const tr_torrent  * tor,
                         int                   fileIndex,
                         uint64_t              minSize ) /* in bytes */
@@ -120 +123 @@
     int ret;
     struct stat sb;
-    const tr_file_t * file = &tor->info.files[fileIndex];
+    const tr_file * file = &tor->info.files[fileIndex];
 
     assert ( 0<=fileIndex && fileIndex<tor->info.fileCount );
@@ -144 +147 @@
 
 static int
-readOrWritePiece ( tr_torrent_t       * tor,
-                   int                  ioMode,
-                   int                  pieceIndex,
-                   int                  pieceOffset,
-                   uint8_t            * buf,
-                   size_t               buflen )
+readOrWritePiece ( tr_torrent       * tor,
+                   int                ioMode,
+                   int                pieceIndex,
+                   int                pieceOffset,
+                   uint8_t          * buf,
+                   size_t             buflen )
 {
     int ret = 0;
     int fileIndex;
     uint64_t fileOffset;
-    const tr_info_t * info = &tor->info;
+    const tr_info * info = &tor->info;
 
     assert( 0<=pieceIndex && pieceIndex<tor->info.pieceCount );
@@ -163 +166 @@
     while( buflen && !ret )
     {
-        const tr_file_t * file = &info->files[fileIndex];
+        const tr_file * file = &info->files[fileIndex];
         const uint64_t bytesThisPass = MIN( buflen, file->length - fileOffset );
 
@@ -182 +185 @@
 
 int
-tr_ioRead( tr_io_t * io, int pieceIndex, int begin, int len, uint8_t * buf )
-{
-    return readOrWritePiece ( io->tor, TR_IO_READ, pieceIndex, begin, buf, len );
+tr_ioRead( tr_torrent * tor, int pieceIndex, int begin, int len, uint8_t * buf )
+{
+    return readOrWritePiece ( tor, TR_IO_READ, pieceIndex, begin, buf, len );
 }
 
 int
-tr_ioWrite( tr_io_t * io, int pieceIndex, int begin, int len, uint8_t * buf )
-{
-    return readOrWritePiece ( io->tor, TR_IO_WRITE, pieceIndex, begin, buf, len );
+tr_ioWrite( tr_torrent * tor, int pieceIndex, int begin, int len, uint8_t * buf )
+{
+    return readOrWritePiece ( tor, TR_IO_WRITE, pieceIndex, begin, buf, len );
 }
 
@@ -198 +201 @@
 
 static int
-tr_ioRecalculateHash ( tr_torrent_t  * tor,
+tr_ioRecalculateHash ( tr_torrent    * tor,
                        int             pieceIndex,
                        uint8_t       * setme )
@@ -205 +208 @@
     int ret;
     uint8_t * buf;
-    const tr_info_t * info;
+    const tr_info * info;
 
     assert( tor != NULL );
@@ -216 +219 @@
     buf = malloc( n );
     ret = readOrWritePiece ( tor, TR_IO_READ, pieceIndex, 0, buf, n );
-    if( !ret ) {
-        SHA1( buf, n, setme );
-    }
+    if( !ret )
+        tr_sha1( setme, buf, n, NULL );
     free( buf );
 
@@ -225 +227 @@
 
 static int
-checkPiece ( tr_torrent_t * tor, int pieceIndex )
+checkPiece ( tr_torrent * tor, int pieceIndex )
 {
     uint8_t hash[SHA_DIGEST_LENGTH];
@@ -235 +237 @@
 }
 
+/**
+***
+**/
+
 void
-tr_ioCheckFiles( tr_torrent_t * tor )
-{
-    assert( tor != NULL );
-    assert( tor->completion != NULL );
-    assert( tor->info.pieceCount > 0 );
-
-    if( tor->uncheckedPieces != NULL )
+tr_ioClose( const tr_torrent * tor )
+{
+    int i;
+    const tr_info * info = &tor->info;
+
+    for( i=0; i<info->fileCount; ++i )
+        tr_fdFileClose( tor->destination, info->files[i].name );
+}
+
+int
+tr_ioHash( tr_torrent * tor, int pieceIndex )
+{
+    int ret;
+    const int success = !checkPiece( tor, pieceIndex );
+
+    if( success )
+    {
+        tr_dbg( "Piece %d hash OK", pieceIndex );
+        tr_cpPieceAdd( tor->completion, pieceIndex );
+        ret = TR_OK;
+    }
+    else
+    {
+        tr_err( "Piece %d hash FAILED", pieceIndex );
+        tr_cpPieceRem( tor->completion, pieceIndex );
+        ret = TR_ERROR;
+    }
+
+    tr_peerMgrSetBlame( tor->handle->peerMgr, tor->info.hash, pieceIndex, success );
+
+    return ret;
+}
+
+/**
+***
+**/
+
+struct recheck_node
+{
+    tr_torrent * torrent;
+    tr_recheck_done_cb recheck_done_cb;
+    run_status_t status_when_done;
+};
+
+static void
+fireCheckDone( tr_torrent          * torrent,
+               tr_recheck_done_cb    recheck_done_cb,
+               run_status_t          status_when_done )
+{
+    torrent->runStatus = status_when_done;
+    (*recheck_done_cb)( torrent );
+}
+
+struct recheck_node currentNode;
+
+static tr_list * recheckList = NULL;
+
+static tr_thread * recheckThread = NULL;
+
+static int stopCurrent = FALSE;
+
+static void
+recheckThreadFunc( void * unused UNUSED )
+{
+    for( ;; )
     {
         int i;
+        tr_torrent * tor;
+
+        struct recheck_node * node = (struct recheck_node*) recheckList ? recheckList->data : NULL;
+        if( node == NULL )
+            break;
+
+        currentNode = *node;
+        tor = currentNode.torrent;
+        tr_list_remove_data( &recheckList, node );
+        tr_free( node );
+
+        if( tor->uncheckedPieces == NULL ) {
+            fireCheckDone( tor, currentNode.recheck_done_cb, currentNode.status_when_done );
+            continue;
+        }
+
+        tor->runStatus = TR_RUN_CHECKING;
 
         /* remove the unchecked pieces from completion... */
@@ -253 +334 @@
         tr_inf( "Verifying some pieces of \"%s\"", tor->info.name );
 
-        for( i=0; i<tor->info.pieceCount; ++i ) 
+        for( i=0; i<tor->info.pieceCount && !stopCurrent; ++i ) 
         {
             if( !tr_bitfieldHas( tor->uncheckedPieces, i ) )
@@ -262 +343 @@
         }
 
-        tr_bitfieldFree( tor->uncheckedPieces );
-        tor->uncheckedPieces = NULL;
-        tor->fastResumeDirty = TRUE;
-    }
-}
-
-/****
-*****  Life Cycle
-****/
-
-tr_io_t*
-tr_ioNew ( tr_torrent_t * tor )
-{
-    tr_io_t * io = tr_calloc( 1, sizeof( tr_io_t ) );
-    io->tor = tor;
-    return io;
-}
-
+        if( !stopCurrent )
+        {
+            tr_bitfieldFree( tor->uncheckedPieces );
+            tor->uncheckedPieces = NULL;
+        }
+        stopCurrent = FALSE;
+        tr_fastResumeSave( tor );
+        fireCheckDone( tor, currentNode.recheck_done_cb, currentNode.status_when_done );
+    }
+
+    recheckThread = NULL;
+}
 
 void
-tr_ioSync( tr_io_t * io )
-{
-    if( io != NULL )
-    {
-        int i;
-        const tr_info_t * info = &io->tor->info;
-
-        for( i=0; i<info->fileCount; ++i )
-            tr_fdFileClose( io->tor->destination, info->files[i].name );
-    }
+tr_ioRecheckAdd( tr_torrent          * tor,
+                 tr_recheck_done_cb    recheck_done_cb,
+                 run_status_t          status_when_done )
+{
+    if( tor->uncheckedPieces == NULL )
+    {
+        fireCheckDone( tor, recheck_done_cb, status_when_done );
+    }
+    else
+    {
+        struct recheck_node * node;
+        node = tr_new( struct recheck_node, 1 );
+        node->torrent = tor;
+        node->recheck_done_cb = recheck_done_cb;
+        node->status_when_done = status_when_done;
+        tr_list_append( &recheckList, node );
+
+        tor->runStatus = TR_RUN_CHECKING_WAIT;
+
+        if( recheckThread == NULL )
+            recheckThread = tr_threadNew( recheckThreadFunc, NULL, "recheckThreadFunc" );
+    }
+}
+
+static int
+compareRecheckByTorrent( const void * va, const void * vb )
+{
+    const struct recheck_node * a = ( const struct recheck_node * ) va;
+    const struct recheck_node * b = ( const struct recheck_node * ) vb;
+    return a->torrent - b->torrent;
 }
 
 void
-tr_ioClose( tr_io_t * io )
-{
-    if( io != NULL )
-    {
-        tr_ioSync( io );
-        tr_free( io );
-    }
-}
-
-int
-tr_ioHash( tr_io_t * io, int pieceIndex )
-{
-    int i;
-    int ret;
-    tr_torrent_t * tor = io->tor;
-    const int success = !checkPiece( tor, pieceIndex );
-
-    if( success )
-    {
-        tr_dbg( "Piece %d hash OK", pieceIndex );
-        tr_cpPieceAdd( tor->completion, pieceIndex );
-        ret = TR_OK;
-    }
-    else
-    {
-        tr_err( "Piece %d hash FAILED", pieceIndex );
-        tr_cpPieceRem( tor->completion, pieceIndex );
-        ret = TR_ERROR;
-    }
-
-    /* Assign blame or credit to peers */
-    for( i=0; i<tor->peerCount; ++i )
-        tr_peerBlame( tor->peers[i], pieceIndex, success );
-
-    return ret;
-}
+tr_ioRecheckRemove( tr_torrent * tor )
+{
+    if( tor == currentNode.torrent )
+        stopCurrent = TRUE;
+    else {
+        struct recheck_node tmp;
+        tmp.torrent = tor;
+        struct recheck_node * node = tr_list_remove( &recheckList, &tmp, compareRecheckByTorrent );
+        if( node != NULL ) {
+            fireCheckDone( tor, node->recheck_done_cb, node->status_when_done );
+            tr_free( node );
+        }
+    }
+}

trunk/libtransmission/inout.h

@@ -26 +26 @@
 #define TR_IO_H 1
 
-typedef struct tr_io_s tr_io_t;
+struct tr_torrent;
 
-void tr_ioCheckFiles  ( tr_torrent_t * );
-
-tr_io_t * tr_ioNew ( tr_torrent_t * );
+typedef struct tr_io tr_io;
 
 /***********************************************************************
@@ -40 +38 @@
  * TR_ERROR_IO_* otherwise.
  **********************************************************************/
-int tr_ioRead  ( tr_io_t *, int index, int begin, int len, uint8_t * );
-int tr_ioWrite ( tr_io_t *, int index, int begin, int len, uint8_t * );
+int tr_ioRead  ( struct tr_torrent*, int index, int begin, int len, uint8_t * );
+int tr_ioWrite ( struct tr_torrent *, int index, int begin, int len, uint8_t * );
 
-/***********************************************************************
- * tr_ioHash
- ***********************************************************************
- * Hashes the specified piece and updates the completion accordingly.
- **********************************************************************/
-int tr_ioHash ( tr_io_t *, int piece );
+/* hashes the specified piece and updates the completion accordingly. */
+int tr_ioHash ( tr_torrent*, int piece );
 
-/***********************************************************************
- * tr_ioSync
- ***********************************************************************
- * Flush all data on disc by closing all files, and update the cache
- * file.
- **********************************************************************/
-void tr_ioSync( tr_io_t * );
+/* close all the files associated with this torrent*/
+void tr_ioClose( const tr_torrent * );
 
-void      tr_ioClose       ( tr_io_t * );
+/**
+***
+**/
+
+typedef void (*tr_recheck_done_cb)( tr_torrent * tor );
+
+void tr_ioRecheckAdd( tr_torrent          * tor,
+                      tr_recheck_done_cb    recheck_done_cb,
+                      run_status_t          status_when_done );
+
+void tr_ioRecheckRemove( tr_torrent * tor );
+
+/**
+***
+**/
 
 #endif

trunk/libtransmission/internal.h

@@ -46 +46 @@
 #endif
 
-int tr_trackerInfoInit( struct tr_tracker_info_s  * info,
-                        const char                * address,
-                        int                         address_len );
+int tr_trackerInfoInit( struct tr_tracker_info  * info,
+                        const char              * address,
+                        int                       address_len );
 
-void tr_trackerInfoClear( struct tr_tracker_info_s * info );
-
-struct tr_peer_s;
+void tr_trackerInfoClear( struct tr_tracker_info * info );
 
 void tr_peerIdNew ( char* buf, int buflen );
 
-void tr_torrentResetTransferStats( tr_torrent_t * );
+void tr_torrentResetTransferStats( tr_torrent * );
 
-int tr_torrentAddCompact( tr_torrent_t * tor, int from,
-                           const uint8_t * buf, int count );
-int tr_torrentAttachPeer( tr_torrent_t * tor, struct tr_peer_s * );
+void tr_torrentSetHasPiece( tr_torrent * tor, int pieceIndex, int has );
 
-void tr_torrentSetHasPiece( tr_torrent_t * tor, int pieceIndex, int has );
+void tr_torrentLock    ( const tr_torrent * );
+void tr_torrentUnlock  ( const tr_torrent * );
 
-void tr_torrentReaderLock    ( const tr_torrent_t * );
-void tr_torrentReaderUnlock  ( const tr_torrent_t * );
-void tr_torrentWriterLock    ( tr_torrent_t * );
-void tr_torrentWriterUnlock  ( tr_torrent_t * );
+void tr_torrentChangeMyPort  ( tr_torrent *, int port );
 
-void tr_torrentChangeMyPort  ( tr_torrent_t *, int port );
+int tr_torrentExists( tr_handle *, const uint8_t * );
+tr_torrent* tr_torrentFindFromHash( tr_handle *, const uint8_t * );
+tr_torrent* tr_torrentFindFromObfuscatedHash( tr_handle *, const uint8_t* );
 
 /* get the index of this piece's first block */
@@ -90 +86 @@
 
 #define tr_block(a,b) _tr_block(tor,a,b)
-int _tr_block( const tr_torrent_t * tor, int index, int begin );
+int _tr_block( const tr_torrent * tor, int index, int begin );
 
 
 typedef enum
 {
-    TR_RUN_CHECKING           = (1<<0), /* checking files' checksums */
-    TR_RUN_RUNNING            = (1<<1), /* seeding or leeching */
-    TR_RUN_STOPPING           = (1<<2), /* stopping */
-    TR_RUN_STOPPING_NET_WAIT  = (1<<3), /* waiting on network -- we're
-                                           telling tracker we've stopped */
+    TR_RUN_CHECKING_WAIT      = (1<<0), /* waiting to be checked */
+    TR_RUN_CHECKING           = (1<<1), /* checking files' checksums */
+    TR_RUN_RUNNING            = (1<<2), /* seeding or leeching */
+    TR_RUN_STOPPING           = (1<<3), /* waiting for acknowledgment from tracker */
     TR_RUN_STOPPED            = (1<<4)  /* stopped */
 }
@@ -106 +101 @@
 #define TR_ID_LEN  20
 
-struct tr_torrent_s
+struct tr_torrent
 {
-    tr_handle_t               * handle;
-    tr_info_t                   info;
+    tr_handle                 * handle;
+    tr_info                     info;
 
-    tr_speedlimit_t             uploadLimitMode;
-    tr_speedlimit_t             downloadLimitMode;
-    struct tr_ratecontrol_s   * upload;
-    struct tr_ratecontrol_s   * download;
-    struct tr_ratecontrol_s   * swarmspeed;
+    tr_speedlimit               uploadLimitMode;
+    tr_speedlimit               downloadLimitMode;
+    struct tr_ratecontrol     * upload;
+    struct tr_ratecontrol     * download;
+    struct tr_ratecontrol     * swarmspeed;
+
+    struct tr_timer           * saveTimer;
 
     int                        error;
     char                       errorString[128];
     int                        hasChangedState;
+
+    uint8_t                    obfuscatedHash[SHA_DIGEST_LENGTH];
 
     uint8_t                  * azId;
@@ -137 +136 @@
     int                        blockCountInLastPiece;
     
-    struct tr_completion_s   * completion;
+    struct tr_completion     * completion;
 
     volatile char              dieFlag;
-    struct tr_bitfield_s     * uncheckedPieces;
+    struct tr_bitfield       * uncheckedPieces;
     run_status_t               runStatus;
     run_status_t               runStatusToSave;
     char                       runStatusToSaveIsSet;
     cp_status_t                cpStatus;
-    struct tr_thread_s       * thread;
-    struct tr_rwlock_s       * lock;
+    struct tr_lock           * lock;
 
-    struct tr_tracker_s      * tracker;
+    struct tr_tracker        * tracker;
     struct tr_publisher_tag  * trackerSubscription;
-    struct tr_io_s           * io;
     uint64_t                   startDate;
     uint64_t                   stopDate;
-    char                       ioLoaded;
-    char                       fastResumeDirty;
-
-    int                        peerCount;
-    struct tr_peer_s *         peers[TR_MAX_PEER_COUNT];
 
     uint64_t                   downloadedCur;
@@ -170 +162 @@
 
     int8_t                     statCur;
-    tr_stat_t                  stats[2];
+    tr_stat                    stats[2];
 
-    tr_torrent_t             * next;
+    tr_torrent               * next;
 };
 
-struct tr_handle_s
+struct tr_handle
 {
-    struct tr_event_handle_s * events;
+    tr_encryption_mode         encryptionMode;
+
+    struct tr_event_handle   * events;
 
     int                        torrentCount;
-    tr_torrent_t             * torrentList;
+    tr_torrent               * torrentList;
 
     char                     * tag;
@@ -187 +181 @@
     char                       useUploadLimit;
     char                       useDownloadLimit;
-    struct tr_ratecontrol_s  * upload;
-    struct tr_ratecontrol_s  * download;
+    struct tr_ratecontrol    * upload;
+    struct tr_ratecontrol    * download;
 
-    struct tr_shared_s       * shared;
+    struct tr_peerMgr        * peerMgr;
+    struct tr_shared         * shared;
 
-    tr_handle_status_t         stats[2];
+    tr_handle_status           stats[2];
     int                        statCur;
+
+    uint8_t                    isClosed;
 
 #define TR_AZ_ID_LEN 20

trunk/libtransmission/ipcparse.c

@@ -586 +586 @@
 
 int
-ipc_addinfo( benc_val_t * list, int tor, const tr_info_t * inf, int types )
+ipc_addinfo( benc_val_t * list, int tor, const tr_info * inf, int types )
 {
     benc_val_t * dict, * item, * file, * tier;
@@ -728 +728 @@
 int
 ipc_addstat( benc_val_t * list, int tor,
-             const tr_stat_t * st, int types )
+             const tr_stat * st, int types )
 {
     benc_val_t  * dict, * item;

trunk/libtransmission/ipcparse.h

@@ -28 +28 @@
 #include <inttypes.h>
 
-/* yay for typedefs, we can't forward declare benc_val_t or tr_info_t
+/* yay for typedefs, we can't forward declare benc_val_t or tr_info
    like with structs */
 #include "bencode.h"
@@ -160 +160 @@
 uint8_t *    ipc_mkgetinfo( struct ipc_info *, size_t *, enum ipc_msg, int64_t,
                             int, const int * );
-int          ipc_addinfo  ( benc_val_t *, int, const tr_info_t *, int );
-int          ipc_addstat  ( benc_val_t *, int, const tr_stat_t *, int );
+int          ipc_addinfo  ( benc_val_t *, int, const tr_info *, int );
+int          ipc_addstat  ( benc_val_t *, int, const tr_stat *, int );
 
 /* sets errno to EINVAL on parse error or

trunk/libtransmission/list.c

@@ -15 +15 @@
 #include "utils.h"
 
-static tr_list_t*
+static tr_list*
 node_alloc( void )
 {
-    return tr_new0( tr_list_t, 1 );
+    return tr_new0( tr_list, 1 );
 }
 
 static void
-node_free( tr_list_t* node )
+node_free( tr_list* node )
 {
     tr_free( node );
@@ -32 +32 @@
 
 void
-tr_list_free( tr_list_t** list )
+tr_list_free( tr_list** list )
 {
     while( *list )
     {
-        tr_list_t * node = *list;
+        tr_list * node = *list;
         *list = (*list)->next;
         node_free( node );
@@ -43 +43 @@
 
 void
-tr_list_prepend( tr_list_t ** list, void * data )
+tr_list_prepend( tr_list ** list, void * data )
 {
-    tr_list_t * node = node_alloc ();
+    tr_list * node = node_alloc ();
     node->data = data;
     node->next = *list;
@@ -54 +54 @@
 
 void
-tr_list_append( tr_list_t ** list, void * data )
+tr_list_append( tr_list ** list, void * data )
 {
-    tr_list_t * node = node_alloc( );
+    tr_list * node = node_alloc( );
     node->data = data;
     if( !*list )
         *list = node;
     else {
-        tr_list_t * l = *list;
+        tr_list * l = *list;
         while( l->next )
             l = l->next;
@@ -70 +70 @@
 
 void
-tr_list_insert_sorted( tr_list_t ** list,
+tr_list_insert_sorted( tr_list ** list,
                        void       * data,
                        int          compare(const void*,const void*) )
 {
     /* find l, the node that we'll insert this data before */
-    tr_list_t * l;
+    tr_list * l;
     for( l=*list; l!=NULL; l=l->next ) {
         const int c = (compare)( data, l->data );
@@ -87 +87 @@
         tr_list_prepend( list, data );
     else {
-        tr_list_t * node = node_alloc( );
+        tr_list * node = node_alloc( );
         node->data = data;
         if( l->prev ) { node->prev = l->prev; node->prev->next = node; }
@@ -96 +96 @@
 
 
-tr_list_t*
-tr_list_find_data ( tr_list_t * list, const void * data )
+tr_list*
+tr_list_find_data ( tr_list * list, const void * data )
 {
     for(; list; list=list->next )
@@ -106 +106 @@
 }
 
-void
-tr_list_remove_data ( tr_list_t ** list, const void * data )
+static void*
+tr_list_remove_node ( tr_list ** list, tr_list * node )
 {
-    tr_list_t * node = tr_list_find_data( *list, data );
-    tr_list_t * prev = node ? node->prev : NULL;
-    tr_list_t * next = node ? node->next : NULL;
+    void * data;
+    tr_list * prev = node ? node->prev : NULL;
+    tr_list * next = node ? node->next : NULL;
     if( prev ) prev->next = next;
     if( next ) next->prev = prev;
     if( *list == node ) *list = next;
+    data = node ? node->data : NULL;
     node_free( node );
+    return data;
 }
 
-tr_list_t*
-tr_list_find ( tr_list_t * list , const void * b, TrListCompareFunc func )
+void*
+tr_list_pop_front( tr_list ** list )
+{
+    void * ret = NULL;
+    if( *list != NULL )
+    {
+        ret = (*list)->data;
+        tr_list_remove_node( list, *list );
+    }
+    return ret;
+}
+
+void*
+tr_list_remove_data ( tr_list ** list, const void * data )
+{
+    return tr_list_remove_node( list, tr_list_find_data( *list, data ) );
+}
+
+void*
+tr_list_remove( tr_list         ** list,
+                const void       * b,
+                TrListCompareFunc  compare_func )
+{
+    return tr_list_remove_node( list, tr_list_find( *list, b, compare_func ) );
+}
+
+
+tr_list*
+tr_list_find ( tr_list * list , const void * b, TrListCompareFunc func )
 {
     for( ; list; list=list->next )
@@ -129 +158 @@
 
 void
-tr_list_foreach( tr_list_t * list, TrListForeachFunc func )
+tr_list_foreach( tr_list * list, TrListForeachFunc func )
 {
-    while( list )
-    {
+    while( list != NULL ) {
         func( list->data );
         list = list->next;
     }
 }
+
+int
+tr_list_size( const tr_list * list )
+{
+    int size = 0;
+    while( list != NULL ) {
+        ++size;
+        list = list->next;
+    }
+    return size;
+}

trunk/libtransmission/list.h

@@ -14 +14 @@
 #define TR_LIST_H
 
-typedef struct tr_list_s
+typedef struct tr_list
 {
-    void              * data;
-    struct tr_list_s  * next;
-    struct tr_list_s  * prev;
+    void            * data;
+    struct tr_list  * next;
+    struct tr_list  * prev;
 }
-tr_list_t;
+tr_list;
 
 typedef int (*TrListCompareFunc)(const void * a, const void * b);
 typedef void (*TrListForeachFunc)(void *);
 
-void        tr_list_free           ( tr_list_t         ** list );
+int         tr_list_size           ( const tr_list    * list );
 
-void        tr_list_append         ( tr_list_t         ** list,
-                                     void               * data );
+void        tr_list_free           ( tr_list         ** list );
 
-void        tr_list_prepend        ( tr_list_t         ** list,
-                                     void               * data );
+void        tr_list_append         ( tr_list         ** list,
+                                     void             * data );
 
-void        tr_list_remove_data    ( tr_list_t         ** list,
-                                     const void         * data );
+void        tr_list_prepend        ( tr_list         ** list,
+                                     void             * data );
 
-void        tr_list_insert_sorted  ( tr_list_t         ** list,
-                                     void               * data,
-                                     TrListCompareFunc    compare_func );
+void*       tr_list_pop_front      ( tr_list         ** list );
 
-tr_list_t*  tr_list_find           ( tr_list_t          * list,
-                                     const void         * b,
-                                     TrListCompareFunc    compare_func );
+void*       tr_list_remove_data    ( tr_list         ** list,
+                                     const void       * data );
 
-tr_list_t*  tr_list_find_data      ( tr_list_t          * list,
-                                     const void         * data );
+void*       tr_list_remove         ( tr_list         ** list,
+                                     const void       * b,
+                                     TrListCompareFunc  compare_func );
 
-void        tr_list_foreach        ( tr_list_t          * list,
-                                     TrListForeachFunc    foreach_func );
+void        tr_list_insert_sorted  ( tr_list         ** list,
+                                     void             * data,
+                                     TrListCompareFunc  compare_func );
+
+tr_list*  tr_list_find           ( tr_list          * list,
+                                   const void       * b,
+                                   TrListCompareFunc  compare_func );
+
+tr_list*  tr_list_find_data      ( tr_list          * list,
+                                   const void       * data );
+
+void        tr_list_foreach      ( tr_list          * list,
+                                   TrListForeachFunc  foreach_func );
 
 #endif /* TR_LIST_H */

trunk/libtransmission/makemeta.c

@@ -22 +22 @@
 #include <dirent.h>
 
-#include "trcompat.h" /* for strlcpy */
+#include "crypto.h" /* tr_sha1 */
+#include "trcompat.h" /* strlcpy */
 #include "transmission.h"
-#include "internal.h" /* for tr_torrent_t */
 #include "bencode.h"
 #include "makemeta.h"
 #include "platform.h" /* threads, locks */
 #include "shared.h" /* shared lock */
-#include "sha1.h"
 #include "utils.h" /* buildpath */
 #include "version.h"
@@ -232 +231 @@
         assert( bufptr-buf == (int)thisPieceSize );
         assert( pieceRemain == 0 );
-        SHA1( buf, thisPieceSize, walk );
+        tr_sha1( buf, walk, thisPieceSize, NULL );
         walk += SHA_DIGEST_LENGTH;
 
@@ -411 +410 @@
 static tr_metainfo_builder_t * queue = NULL;
 
-static tr_thread_t * workerThread = NULL;
-
-static tr_lock_t* getQueueLock( tr_handle_t * h )
-{
-    static tr_lock_t * lock = NULL;
+static tr_thread * workerThread = NULL;
+
+static tr_lock* getQueueLock( tr_handle_t * h )
+{
+    static tr_lock * lock = NULL;
 
     tr_sharedLock( h->shared );
@@ -434 +433 @@
 
         /* find the next builder to process */
-        tr_lock_t * lock = getQueueLock ( handle );
+        tr_lock * lock = getQueueLock ( handle );
         tr_lockLock( lock );
         if( queue != NULL ) {
@@ -459 +458 @@
                  int                      isPrivate )
 {
-    tr_lock_t * lock;
+    tr_lock * lock;
 
     builder->abortFlag = 0;

trunk/libtransmission/metainfo.c

@@ -34 +34 @@
 #include "transmission.h"
 #include "bencode.h"
+#include "crypto.h" /* tr_sha1 */
 #include "http.h" /* tr_httpParseUrl */
 #include "metainfo.h"
 #include "platform.h"
-#include "sha1.h"
 #include "utils.h"
 
@@ -45 +45 @@
  * Local prototypes
  **********************************************************************/
-static int realparse( tr_info_t * inf, const uint8_t * buf, size_t len );
+static int realparse( tr_info * inf, const uint8_t * buf, size_t len );
 static void savedname( char * name, size_t len, const char * hash,
                        const char * tag );
@@ -53 +53 @@
 static int getfile( char * buf, int size,
                     const char * prefix, benc_val_t * name );
-static int getannounce( tr_info_t * inf, benc_val_t * meta );
+static int getannounce( tr_info * inf, benc_val_t * meta );
 static char * announceToScrape( const char * announce );
-static int parseFiles( tr_info_t * inf, benc_val_t * name,
+static int parseFiles( tr_info * inf, benc_val_t * name,
                        benc_val_t * files, benc_val_t * length );
 
@@ -64 +64 @@
  **********************************************************************/
 int
-tr_metainfoParseFile( tr_info_t * inf, const char * tag,
+tr_metainfoParseFile( tr_info * inf, const char * tag,
                       const char * path, int save )
 {
@@ -103 +103 @@
 
 int
-tr_metainfoParseData( tr_info_t * inf, const char * tag,
+tr_metainfoParseData( tr_info * inf, const char * tag,
                       const uint8_t * data, size_t size, int save )
 {
@@ -124 +124 @@
 
 int
-tr_metainfoParseHash( tr_info_t * inf, const char * tag, const char * hash )
+tr_metainfoParseHash( tr_info * inf, const char * tag, const char * hash )
 {
     struct stat sb;
@@ -173 +173 @@
 
 static int
-realparse( tr_info_t * inf, const uint8_t * buf, size_t size )
+realparse( tr_info * inf, const uint8_t * buf, size_t size )
 {
     benc_val_t   meta, * beInfo, * val, * val2;
@@ -193 +193 @@
         return TR_EINVALID;
     }
-    SHA1( (uint8_t *) beInfo->begin,
-          (long) beInfo->end - (long) beInfo->begin, inf->hash );
+
+    tr_sha1( inf->hash, beInfo->begin, beInfo->end - beInfo->begin, NULL );
+
     for( i = 0; i < SHA_DIGEST_LENGTH; i++ )
     {
@@ -255 +256 @@
     inf->pieceCount = val->val.s.i / SHA_DIGEST_LENGTH;
 
-    inf->pieces = calloc ( inf->pieceCount, sizeof(tr_piece_t) );
+    inf->pieces = calloc ( inf->pieceCount, sizeof(tr_piece) );
 
     for ( i=0; i<inf->pieceCount; ++i )
@@ -308 +309 @@
 }
 
-void tr_metainfoFree( tr_info_t * inf )
+void tr_metainfoFree( tr_info * inf )
 {
     int i, j;
@@ -323 +324 @@
     tr_free( inf->trackerList );
 
-    memset( inf, '\0', sizeof(tr_info_t) );
+    memset( inf, '\0', sizeof(tr_info) );
 }
 
@@ -382 +383 @@
 }
 
-static int getannounce( tr_info_t * inf, benc_val_t * meta )
+static int getannounce( tr_info * inf, benc_val_t * meta )
 {
     benc_val_t        * val, * subval, * urlval;
     char              * address, * announce;
     int                 ii, jj, port, random, subcount;
-    tr_tracker_info_t * sublist;
+    tr_tracker_info   * sublist;
     void * swapping;
 
@@ -412 +413 @@
             for( jj = 0; jj < subval->val.l.count; jj++ )
             {
-                tr_tracker_info_t tmp;
+                tr_tracker_info tmp;
 
                 urlval = &subval->val.l.vals[jj];
@@ -559 +560 @@
 
 int
-tr_trackerInfoInit( tr_tracker_info_t  * info,
-                    const char         * address,
-                    int                  address_len )
+tr_trackerInfoInit( tr_tracker_info  * info,
+                    const char       * address,
+                    int                address_len )
 {
     int ret = tr_httpParseUrl( address, address_len,
@@ -574 +575 @@
 
 void
-tr_trackerInfoClear( tr_tracker_info_t * info )
+tr_trackerInfoClear( tr_tracker_info * info )
 {
     tr_free( info->address );
     tr_free( info->announce );
     tr_free( info->scrape );
-    memset( info, '\0', sizeof(tr_tracker_info_t) );
+    memset( info, '\0', sizeof(tr_tracker_info) );
 }
 
@@ -691 +692 @@
 
 static int
-parseFiles( tr_info_t * inf, benc_val_t * name,
+parseFiles( tr_info * inf, benc_val_t * name,
             benc_val_t * files, benc_val_t * length )
 {

trunk/libtransmission/metainfo.h

@@ -28 +28 @@
 #include "transmission.h"
 
-int tr_metainfoParseFile( tr_info_t *, const char * tag,
+int tr_metainfoParseFile( tr_info *, const char * tag,
                           const char * path, int save );
-int tr_metainfoParseData( tr_info_t *, const char * tag,
+int tr_metainfoParseData( tr_info *, const char * tag,
                           const uint8_t * data, size_t size, int save );
-int tr_metainfoParseHash( tr_info_t *, const char * tag, const char * hash );
-void tr_metainfoFree( tr_info_t * inf );
+int tr_metainfoParseHash( tr_info *, const char * tag, const char * hash );
+void tr_metainfoFree( tr_info * inf );
 void tr_metainfoRemoveSaved( const char * hashString, const char * tag );
 

trunk/libtransmission/net.c

@@ -58 +58 @@
 /***********************************************************************
  * DNS resolution
- **********************************************************************/
-
-/***********************************************************************
- * tr_netResolve
- ***********************************************************************
+ * 
  * Synchronous "resolution": only works with character strings
  * representing numbers expressed in the Internet standard `.' notation.
@@ -71 +67 @@
     addr->s_addr = inet_addr( address );
     return ( addr->s_addr == 0xFFFFFFFF );
-}
-
-static tr_thread_t  * resolveThread;
-static tr_lock_t    * resolveLock;
-static tr_cond_t    * resolveCond;
-static volatile int   resolveDie;
-static tr_resolve_t * resolveQueue;
-
-static void resolveRelease ( tr_resolve_t * );
-static void resolveFunc    ( void * );
-
-struct tr_resolve_s
-{
-    tr_tristate_t  status;
-    char           * address;
-    struct in_addr addr;
-
-    int            refcount;
-    tr_resolve_t   * next;
-};
-
-/***********************************************************************
- * tr_netResolveThreadInit
- ***********************************************************************
- * Initializes the static variables used for resolution and launch the
- * gethostbyname thread.
- **********************************************************************/
-void tr_netResolveThreadInit( void )
-{
-    resolveDie   = 0;
-    resolveQueue = NULL;
-    resolveLock = tr_lockNew( );
-    resolveCond = tr_condNew( );
-    resolveThread = tr_threadNew( resolveFunc, NULL, "resolve" );
-}
-
-/***********************************************************************
- * tr_netResolveThreadClose
- ***********************************************************************
- * Notices the gethostbyname thread that is should terminate. Doesn't
- * wait until it does, in case it is stuck in a resolution: we let it
- * die and clean itself up.
- **********************************************************************/
-void tr_netResolveThreadClose( void )
-{
-    tr_lockLock( resolveLock );
-    resolveDie = 1;
-    tr_lockUnlock( resolveLock );
-    tr_condSignal( resolveCond );
-    tr_wait( 200 );
-}
-
-/***********************************************************************
- * tr_netResolveInit
- ***********************************************************************
- * Adds an address to the resolution queue.
- **********************************************************************/
-tr_resolve_t * tr_netResolveInit( const char * address )
-{
-    tr_resolve_t * r = tr_new0( tr_resolve_t, 1 );
-    r->status   = TR_NET_WAIT;
-    r->address  = strdup( address );
-    r->refcount = 2;
-    r->next     = NULL;
-
-    tr_lockLock( resolveLock );
-    if( !resolveQueue )
-    {
-        resolveQueue = r;
-    }
-    else
-    {
-        tr_resolve_t * iter;
-        for( iter = resolveQueue; iter->next; iter = iter->next );
-        iter->next = r;
-    }
-    tr_lockUnlock( resolveLock );
-    tr_condSignal( resolveCond );
-
-    return r;
-}
-
-/***********************************************************************
- * tr_netResolvePulse
- ***********************************************************************
- * Checks the current status of a resolution.
- **********************************************************************/
-tr_tristate_t tr_netResolvePulse( tr_resolve_t * r, struct in_addr * addr )
-{
-    tr_tristate_t ret;
-
-    tr_lockLock( resolveLock );
-    ret = r->status;
-    if( ret == TR_NET_OK )
-    {
-        *addr = r->addr;
-    }
-    tr_lockUnlock( resolveLock );
-
-    return ret;
-}
-
-/***********************************************************************
- * tr_netResolveClose
- ***********************************************************************
- * 
- **********************************************************************/
-void tr_netResolveClose( tr_resolve_t * r )
-{
-    resolveRelease( r );
-}
-
-/***********************************************************************
- * resolveRelease
- ***********************************************************************
- * The allocated tr_resolve_t structures should be freed when
- * tr_netResolveClose was called *and* it was removed from the queue.
- * This can happen in any order, so we use a refcount to know we can
- * take it out.
- **********************************************************************/
-static void resolveRelease( tr_resolve_t * r )
-{
-    if( --r->refcount < 1 )
-    {
-        free( r->address );
-        free( r );
-    }
-}
-
-/***********************************************************************
- * resolveFunc
- ***********************************************************************
- * Keeps waiting for addresses to resolve, and removes them from the
- * queue once resolution is done.
- **********************************************************************/
-static void resolveFunc( void * arg UNUSED )
-{
-    tr_resolve_t * r;
-    struct hostent * host;
-
-    tr_lockLock( resolveLock );
-
-    while( !resolveDie )
-    {
-        if( !( r = resolveQueue ) )
-        {
-            tr_condWait( resolveCond, resolveLock );
-            continue;
-        }
-
-        /* Blocking resolution */
-        tr_lockUnlock( resolveLock );
-        host = gethostbyname( r->address );
-        tr_lockLock( resolveLock );
-
-        if( host )
-        {
-            memcpy( &r->addr, host->h_addr, host->h_length );
-            r->status = TR_NET_OK;
-        }
-        else
-        {
-            r->status = TR_NET_ERROR;
-        }
-        
-        resolveQueue = r->next;
-        resolveRelease( r );
-    }
-
-    /* Clean up  */
-    tr_lockUnlock( resolveLock );
-    tr_lockFree( resolveLock );
-    resolveLock = NULL;
-    while( ( r = resolveQueue ) )
-    {
-        resolveQueue = r->next;
-        resolveRelease( r );
-    }
 }
 
@@ -470 +288 @@
 }
 
-void tr_netClose( int s )
+void
+tr_netClose( int s )
 {
     tr_fdSocketClose( s );
 }
 
-void tr_netNtop( const struct in_addr * addr, char * buf, int len )
+void
+tr_netNtop( const struct in_addr * addr, char * buf, int len )
 {
     const uint8_t * cast;

trunk/libtransmission/net.h

@@ -68 +68 @@
 int tr_netResolve( const char *, struct in_addr * );
 
-typedef struct tr_resolve_s tr_resolve_t;
-void           tr_netResolveThreadInit( void );
-void           tr_netResolveThreadClose( void );
-tr_resolve_t * tr_netResolveInit( const char * address );
-tr_tristate_t  tr_netResolvePulse( tr_resolve_t *, struct in_addr * );
-void           tr_netResolveClose( tr_resolve_t * );
-
 
 /***********************************************************************

trunk/libtransmission/peer.c

@@ -175 +175 @@
 struct tr_peer_s
 {
-    tr_torrent_t      * tor;
+    tr_torrent        * tor;
 
     struct in_addr      addr;
@@ -215 +215 @@
 
     /* The pieces that the peer has */
-    tr_bitfield_t     * bitfield;
+    tr_bitfield       * bitfield;
 
     /* blocks we've requested from this peer */
-    tr_bitfield_t     * reqfield;
+    tr_bitfield       * reqfield;
     int                 pieceCount;
     float               progress;
@@ -226 +226 @@
     int                 banned;
     /* The pieces that the peer is contributing to */
-    tr_bitfield_t     * blamefield;
+    tr_bitfield       * blamefield;
     /* The bad pieces that the peer has contributed to */
-    tr_bitfield_t     * banfield;
+    tr_bitfield       * banfield;
 
     uint8_t           * buf;
@@ -250 +250 @@
     int                 inLength;
 
-    tr_list_t         * outRequests;
+    tr_list           * outRequests;
     uint64_t            outDate;
 
-    tr_ratecontrol_t  * download;
-    tr_ratecontrol_t  * upload;
+    tr_ratecontrol    * download;
+    tr_ratecontrol    * upload;
 
     char              * client;
@@ -290 +290 @@
     const uint32_t u = htonl( a );
     memcpy ( p, &u, sizeof( uint32_t ) );
-}
-
-static const char* getPeerId( void )
-{
-    static char * peerId = NULL;
-    if( !peerId ) {
-        peerId = tr_new0( char, TR_ID_LEN + 1 );
-        tr_peerIdNew( peerId, TR_ID_LEN + 1 );
-    }
-    return peerId;
 }
 
@@ -354 +344 @@
 void tr_peerDestroy( tr_peer_t * peer )
 {
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
     tr_request_t * r;
     int i, block;
@@ -424 +414 @@
 }
 
-void tr_peerSetTorrent( tr_peer_t * peer, tr_torrent_t * tor )
+void tr_peerSetTorrent( tr_peer_t * peer, tr_torrent * tor )
 {
     peer->tor = tor;
@@ -436 +426 @@
 int tr_peerRead( tr_peer_t * peer )
 {
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
     int ret;
     uint64_t date;
@@ -543 +533 @@
 int tr_peerPulse( tr_peer_t * peer )
 {
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
     int ret, size;
     uint8_t * p;
@@ -581 +571 @@
     {
         uint8_t buf[HANDSHAKE_SIZE];
-        const tr_info_t * inf;
+        const tr_info * inf;
 
         inf = tr_torrentInfo( tor );
@@ -794 +784 @@
 }
 
-int tr_peerIsFrom( const tr_peer_t * peer )
+int tr_peerGetFrom( const tr_peer_t * peer )
 {
     return peer->from;
@@ -886 +876 @@
 void tr_peerBlame( tr_peer_t * peer, int piece, int success )
 {
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
 
     if( !peer->blamefield || !tr_bitfieldHas( peer->blamefield, piece ) )
@@ -927 +917 @@
 }
 
-int tr_peerGetConnectable( const tr_torrent_t * tor, uint8_t ** _buf )
+int tr_peerGetConnectable( const tr_torrent * tor, uint8_t ** _buf )
 {
     int count = 0;
@@ -970 +960 @@
 tr_peerPieceIsCorrupt( tr_peer_t * peer, int pieceIndex )
 {
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
 
     const uint64_t byteCount = tr_torPieceCountBytes( tor, pieceIndex );
@@ -987 +977 @@
 tr_peerSentBlockToUs( tr_peer_t * peer, int byteCount )
 {
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
 
     assert( byteCount >= 0 );
@@ -1003 +993 @@
 tr_peerGotBlockFromUs ( tr_peer_t * peer, int byteCount )
 {
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
 
     assert( byteCount >= 0 );
@@ -1017 +1007 @@
 
 static void
-tr_torrentSwiftPulse ( tr_torrent_t * tor )
+tr_torrentSwiftPulse ( tr_torrent * tor )
 {
     /* Preferred # of seconds for the request queue's turnaround time.
@@ -1092 +1082 @@
     if( lastPulseTime + SWIFT_REFRESH_INTERVAL_SEC <= time( NULL ) )
     {
-        tr_torrent_t * tor;
+        tr_torrent * tor;
         for( tor=h->torrentList; tor; tor=tor->next )
             tr_torrentSwiftPulse( tor );

trunk/libtransmission/peer.h

@@ -35 +35 @@
 const char *tr_peerClient          ( tr_peer_t * );
 void        tr_peerSetPrivate      ( tr_peer_t *, int );
-void        tr_peerSetTorrent      ( tr_peer_t *, struct tr_torrent_s * );
+void        tr_peerSetTorrent      ( tr_peer_t *, struct tr_torrent * );
 void        tr_peerSentBlockToUs   ( tr_peer_t *, int byteCount );
 void        tr_peerGotBlockFromUs  ( tr_peer_t *, int byteCount );
@@ -43 +43 @@
 int         tr_peerPulse           ( tr_peer_t * );
 int         tr_peerIsConnected     ( const tr_peer_t * );
-int         tr_peerIsFrom          ( const tr_peer_t * );
+int         tr_peerGetFrom         ( const tr_peer_t * );
 int         tr_peerTimesChoked     ( const tr_peer_t * );
 int         tr_peerIsChokingUs     ( const tr_peer_t * );
@@ -61 +61 @@
 void        tr_peerBlame           ( tr_peer_t *, int piece, int success );
 struct in_addr * tr_peerAddress    ( tr_peer_t * );
-int         tr_peerGetConnectable  ( const struct tr_torrent_s *, uint8_t ** );
+int         tr_peerGetConnectable  ( const struct tr_torrent *, uint8_t ** );
 
 void        tr_swiftPulse          ( tr_handle_t * );

trunk/libtransmission/peeraz.h

@@ -98 +98 @@
 
 static uint8_t *
-makeAZHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * buflen )
+makeAZHandshake( tr_torrent * tor, tr_peer_t * peer, int * buflen )
 {
     char       * buf;
@@ -225 +225 @@
 
 static int
-makeAZPex( tr_torrent_t * tor, tr_peer_t * peer, char ** buf, int * len )
+makeAZPex( tr_torrent * tor, tr_peer_t * peer, char ** buf, int * len )
 {
     benc_val_t val;
@@ -236 +236 @@
 
 static int
-sendAZHandshake( tr_torrent_t * tor, tr_peer_t * peer )
+sendAZHandshake( tr_torrent * tor, tr_peer_t * peer )
 {
     uint8_t * buf;
@@ -373 +373 @@
 {
     benc_val_t      val, * sub, * sub2, * dict, * subsub;
-    tr_bitfield_t * msgs;
+    tr_bitfield   * msgs;
     int             ii, idx, newclient;
     char          * client;
@@ -493 +493 @@
 
 static int
-parseAZPex( tr_torrent_t * tor, tr_peer_t * peer, uint8_t * buf, int len )
-{
-    tr_info_t * info = &tor->info;
+parseAZPex( tr_torrent * tor, tr_peer_t * peer, uint8_t * buf, int len )
+{
+    tr_info * info = &tor->info;
     benc_val_t  val, * list, * pair;
     int         ii, used;

trunk/libtransmission/peerext.h

@@ -27 +27 @@
 
 static int
-makeCommonPex( tr_torrent_t * tor, tr_peer_t * peer,
+makeCommonPex( tr_torrent * tor, tr_peer_t * peer,
                int ( *peerfunc )( tr_peertree_t *, benc_val_t * ),
                const char * extrakey, benc_val_t * extraval,
@@ -123 +123 @@
 
 static char *
-makeExtendedHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * len )
+makeExtendedHandshake( tr_torrent * tor, tr_peer_t * peer, int * len )
 {
     benc_val_t val, * msgsval;
@@ -206 +206 @@
 
 static int
-makeUTPex( tr_torrent_t * tor, tr_peer_t * peer, char ** buf, int * len )
+makeUTPex( tr_torrent * tor, tr_peer_t * peer, char ** buf, int * len )
 {
     benc_val_t val;
@@ -300 +300 @@
 
 static int
-parseUTPex( tr_torrent_t * tor, tr_peer_t * peer, uint8_t * buf, int len )
+parseUTPex( tr_torrent * tor, tr_peer_t * peer, uint8_t * buf, int len )
 {
     benc_val_t val, * sub;
@@ -327 +327 @@
     if( NULL != sub && TYPE_STR == sub->type && 0 == sub->val.s.i % 6 )
     {
+#if 0
         used = tr_torrentAddCompact( tor, TR_PEER_FROM_PEX,
                                      ( uint8_t * )sub->val.s.s,
@@ -332 +333 @@
         peer_dbg( "GET  extended-pex, got %i peers, used %i",
                   sub->val.s.i / 6, used );
+#endif
     }
     else

trunk/libtransmission/peermessages.h

@@ -106 +106 @@
 
 static uint8_t *
-blockPending( tr_torrent_t  * tor,
-              tr_peer_t     * peer,
-              int           * size )
+blockPending( tr_torrent  * tor,
+              tr_peer_t   * peer,
+              int         * size )
 {
     if( !peer->outBlockLoaded ) /* we need to load the block for the next request */
@@ -144 +144 @@
         buf += 4;
 
-        tr_ioRead( tor->io, r->index, r->begin, r->length, buf );
+        tr_ioRead( tor, r->index, r->begin, r->length, buf );
 
         peer_dbg( "SEND piece %d/%d (%d bytes)",
@@ -275 +275 @@
  *  - bitfield     (X bytes)
  **********************************************************************/
-static void sendBitfield( tr_torrent_t * tor, tr_peer_t * peer )
+static void sendBitfield( tr_torrent * tor, tr_peer_t * peer )
 {
     uint8_t             * p;
-    const tr_bitfield_t * bitfield;
+    const tr_bitfield   * bitfield;
 
     bitfield = tr_cpPieceBitfield( tor->completion );
@@ -293 +293 @@
  *
  **********************************************************************/
-static void sendRequest( tr_torrent_t * tor, tr_peer_t * peer, int block )
-{
-    tr_info_t * inf = &tor->info;
+static void sendRequest( tr_torrent * tor, tr_peer_t * peer, int block )
+{
+    tr_info * inf = &tor->info;
     tr_request_t * r;
     uint8_t * p;
@@ -344 +344 @@
  *
  **********************************************************************/
-static void broadcastCancel( tr_torrent_t * tor, int index, int begin,
+static void broadcastCancel( tr_torrent * tor, int index, int begin,
                              int length )
 {
@@ -386 +386 @@
  *  - data         (X bytes)
  **********************************************************************/
-static int sendExtended( tr_torrent_t * tor, tr_peer_t * peer, int id )
+static int sendExtended( tr_torrent * tor, tr_peer_t * peer, int id )
 {
     uint8_t * p;
@@ -434 +434 @@
  *
  **********************************************************************/
-static int sendAZPex( tr_torrent_t * tor, tr_peer_t * peer )
+static int sendAZPex( tr_torrent * tor, tr_peer_t * peer )
 {
     uint8_t * p;

trunk/libtransmission/peerparse.h

@@ -33 +33 @@
  **********************************************************************/
 
-static int parseChoke( tr_torrent_t  * tor,
-                       tr_peer_t     * peer,
-                       int             len,
-                       int             choking )
+static int parseChoke( tr_torrent  * tor,
+                       tr_peer_t   * peer,
+                       int           len,
+                       int           choking )
 {
     tr_request_t * r;
@@ -102 +102 @@
  *
  **********************************************************************/
-static int parseHave( tr_torrent_t * tor, tr_peer_t * peer,
-                             uint8_t * p, int len )
-{
-    tr_info_t * inf = &tor->info;
+static int parseHave( tr_torrent * tor, tr_peer_t * peer,
+                      uint8_t * p, int len )
+{
+    tr_info * inf = &tor->info;
     uint32_t piece;
 
@@ -140 +140 @@
 }
 
-static int parseBitfield( tr_torrent_t * tor, tr_peer_t * peer,
-                                 uint8_t * p, int len )
-{
-    tr_info_t * inf = &tor->info;
+static int parseBitfield( tr_torrent * tor, tr_peer_t * peer,
+                          uint8_t * p, int len )
+{
+    tr_info * inf = &tor->info;
     int bitfieldSize;
     int i;
@@ -195 +195 @@
 }
 
-static int parseRequest( tr_torrent_t * tor, tr_peer_t * peer,
-                                uint8_t * p, int len )
-{
-    tr_info_t * inf = &tor->info;
+static int parseRequest( tr_torrent * tor, tr_peer_t * peer,
+                         uint8_t * p, int len )
+{
+    tr_info * inf = &tor->info;
     int index, begin, length;
     tr_request_t * r;
@@ -282 +282 @@
 }
 
-static int parsePiece( tr_torrent_t * tor, tr_peer_t * peer,
-                              uint8_t * p, int len )
-{
-    tr_info_t * inf = &tor->info;
+static int parsePiece( tr_torrent * tor, tr_peer_t * peer,
+                       uint8_t * p, int len )
+{
+    tr_info * inf = &tor->info;
     int index, begin, block, i, ret;
 
@@ -335 +335 @@
 
     /* Write to disk */
-    if( ( ret = tr_ioWrite( tor->io, index, begin, len - 8, &p[8] ) ) )
+    if( ( ret = tr_ioWrite( tor, index, begin, len - 8, &p[8] ) ) )
     {
         return ret;
@@ -380 +380 @@
 }
 
-static int parseCancel( tr_torrent_t * tor, tr_peer_t * peer,
-                               uint8_t * p, int len )
-{
-    tr_info_t * inf = &tor->info;
+static int parseCancel( tr_torrent * tor, tr_peer_t * peer,
+                        uint8_t * p, int len )
+{
+    tr_info * inf = &tor->info;
     int index, begin, length;
     tr_request_t req;
-    tr_list_t * l;
+    tr_list * l;
 
     if( len != 12 )
@@ -475 +475 @@
 }
 
-static int parseMessage( tr_torrent_t * tor, tr_peer_t * peer,
-                                int id, uint8_t * p, int len )
+static int parseMessage( tr_torrent * tor, tr_peer_t * peer,
+                         int id, uint8_t * p, int len )
 {
     int extid;
@@ -598 +598 @@
 }
 
-static int parseHandshake( tr_torrent_t * tor, tr_peer_t * peer )
-{
-    tr_info_t * inf = &tor->info;
+static int parseHandshake( tr_torrent * tor, tr_peer_t * peer )
+{
+    tr_info * inf = &tor->info;
     int         ii, extmsgs, azproto;
     char      * dbgsup, * dbgwant;
@@ -695 +695 @@
 }
 
-static int sendInitial( tr_torrent_t * tor, tr_peer_t * peer )
+static int sendInitial( tr_torrent * tor, tr_peer_t * peer )
 {
     if( PEER_STATUS_CONNECTED != peer->status )
@@ -716 +716 @@
 }
 
-static int parseBuf( tr_torrent_t * tor, tr_peer_t * peer )
+static int parseBuf( tr_torrent * tor, tr_peer_t * peer )
 {
     int       len, ret, msgid;

trunk/libtransmission/peerutils.h

@@ -39 +39 @@
 {
     int ret;
-    tr_torrent_t * tor = peer->tor;
+    tr_torrent * tor = peer->tor;
     const uint64_t now = tr_date( );
     const uint64_t idleTime = now - peer->date;
@@ -138 +138 @@
 }
 
-static int isPieceInteresting( const tr_torrent_t  * tor,
-                               const tr_peer_t     * peer,
-                               int                   piece )
+static int isPieceInteresting( const tr_torrent  * tor,
+                               const tr_peer_t   * peer,
+                               int                 piece )
 {
     if( tor->info.pieces[piece].dnd ) /* we don't want it */
@@ -163 +163 @@
  * haven't completed, or 0 otherwise.
  **********************************************************************/
-static int isInteresting( const tr_torrent_t * tor, const tr_peer_t * peer )
+static int isInteresting( const tr_torrent * tor, const tr_peer_t * peer )
 {
     int i;
-    const tr_bitfield_t * bitfield = tr_cpPieceBitfield( tor->completion );
+    const tr_bitfield   * bitfield = tr_cpPieceBitfield( tor->completion );
 
     if( !peer->bitfield )
@@ -184 +184 @@
 
 static void
-updateInterest( tr_torrent_t * tor, tr_peer_t * peer )
+updateInterest( tr_torrent * tor, tr_peer_t * peer )
 {
     const int i = !!isInteresting( tor, peer );
@@ -224 +224 @@
 }
 
-static int* getPreferredPieces( const tr_torrent_t  * tor,
-                                const tr_peer_t     * peer,
-                                int                 * pieceCount,
-                                int                 * isEndgame )
-{
-    const tr_info_t * inf = &tor->info;
+static int* getPreferredPieces( const tr_torrent  * tor,
+                                const tr_peer_t   * peer,
+                                int               * pieceCount,
+                                int               * isEndgame )
+{
+    const tr_info * inf = &tor->info;
 
     int i;

trunk/libtransmission/platform.c

@@ -57 +57 @@
 ***/
 
-struct tr_thread_s
+struct tr_thread
 {
     void          (* func ) ( void * );
     void           * arg;
-    char           * name;
+    const char     * name;
 
 #ifdef __BEOS__
@@ -83 +83 @@
 ThreadFunc( void * _t )
 {
-    tr_thread_t * t = _t;
-    char* name = tr_strdup( t->name );
+    tr_thread * t = _t;
+    const char * name = t->name;
 
 #ifdef __BEOS__
@@ -96 +96 @@
     tr_dbg( "Thread '%s' exited", name );
 
-    tr_free( name );
-
 #ifdef WIN32
     _endthreadex( 0 );
@@ -104 +102 @@
 }
 
-tr_thread_t *
+tr_thread *
 tr_threadNew( void (*func)(void *),
               void * arg,
               const char * name )
 {
-    tr_thread_t * t = tr_new0( tr_thread_t, 1 );
+    tr_thread * t = tr_new0( tr_thread, 1 );
     t->func = func;
     t->arg  = arg;
-    t->name = tr_strdup( name );
+    t->name = name;
 
 #ifdef __BEOS__
@@ -127 +125 @@
 
 int
-tr_amInThread ( const tr_thread_t * t )
-{
-    int ret;
-#ifdef __BEOS__
-    ret = find_thread(NULL) == t->thread;
-#elif defined(WIN32)
-    ret = GetCurrentThreadId() == t->thread_id;
-#else
-    ret = pthread_equal( t->thread, pthread_self( ) );
-#endif
-    return ret;
+tr_amInThread ( const tr_thread * t )
+{
+#ifdef __BEOS__
+    return find_thread(NULL) == t->thread;
+#elif defined(WIN32)
+    return GetCurrentThreadId() == t->thread_id;
+#else
+    return pthread_equal( t->thread, pthread_self( ) );
+#endif
 }
     
 void
-tr_threadJoin( tr_thread_t * t )
+tr_threadJoin( tr_thread * t )
 {
     if( t != NULL )
@@ -156 +152 @@
 
         tr_dbg( "Thread '%s' joined", t->name );
-        tr_free( t->name );
         t->name = NULL;
         t->func = NULL;
@@ -167 +162 @@
 ***/
 
-struct tr_lock_s
+struct tr_lock
 {
 #ifdef __BEOS__
@@ -178 +173 @@
 };
 
-tr_lock_t*
+tr_lock*
 tr_lockNew( void )
 {
-    tr_lock_t * l = tr_new0( tr_lock_t, 1 );
+    tr_lock * l = tr_new0( tr_lock, 1 );
 
 #ifdef __BEOS__
@@ -195 +190 @@
 
 void
-tr_lockFree( tr_lock_t * l )
+tr_lockFree( tr_lock * l )
 {
 #ifdef __BEOS__
@@ -208 +203 @@
 
 int
-tr_lockTryLock( tr_lock_t * l ) /* success on zero! */
+tr_lockTryLock( tr_lock * l ) /* success on zero! */
 {
 #ifdef __BEOS__
@@ -220 +215 @@
 
 void
-tr_lockLock( tr_lock_t * l )
+tr_lockLock( tr_lock * l )
 {
 #ifdef __BEOS__
@@ -232 +227 @@
 
 void
-tr_lockUnlock( tr_lock_t * l )
+tr_lockUnlock( tr_lock * l )
 {
 #ifdef __BEOS__
@@ -241 +236 @@
     pthread_mutex_unlock( &l->lock );
 #endif
-}
-
-/***
-****  RW LOCK
-***/
-
-struct tr_rwlock_s
-{
-    tr_lock_t * lock;
-    tr_cond_t * readCond;
-    tr_cond_t * writeCond;
-    size_t readCount;
-    size_t wantToRead;
-    size_t wantToWrite;
-    int haveWriter;
-};
-
-static void
-tr_rwSignal( tr_rwlock_t * rw )
-{
-  if ( rw->wantToWrite )
-    tr_condSignal( rw->writeCond );
-  else if ( rw->wantToRead )
-    tr_condBroadcast( rw->readCond );
-}
-
-tr_rwlock_t*
-tr_rwNew ( void )
-{
-    tr_rwlock_t * rw = tr_new0( tr_rwlock_t, 1 );
-    rw->lock = tr_lockNew( );
-    rw->readCond = tr_condNew( );
-    rw->writeCond = tr_condNew( );
-    return rw;
-}
-
-void
-tr_rwReaderLock( tr_rwlock_t * rw )
-{
-    tr_lockLock( rw->lock );
-    rw->wantToRead++;
-    while( rw->haveWriter || rw->wantToWrite )
-        tr_condWait( rw->readCond, rw->lock );
-    rw->wantToRead--;
-    rw->readCount++;
-    tr_lockUnlock( rw->lock );
-}
-
-int
-tr_rwReaderTrylock( tr_rwlock_t * rw )
-{
-    int ret = FALSE;
-    tr_lockLock( rw->lock );
-    if ( !rw->haveWriter && !rw->wantToWrite ) {
-        rw->readCount++;
-        ret = TRUE;
-    }
-    tr_lockUnlock( rw->lock );
-    return ret;
-
-}
-
-void
-tr_rwReaderUnlock( tr_rwlock_t * rw )
-{
-    tr_lockLock( rw->lock );
-    --rw->readCount;
-    if( !rw->readCount )
-        tr_rwSignal( rw );
-    tr_lockUnlock( rw->lock );
-}
-
-void
-tr_rwWriterLock( tr_rwlock_t * rw )
-{
-    tr_lockLock( rw->lock );
-    rw->wantToWrite++;
-    while( rw->haveWriter || rw->readCount )
-        tr_condWait( rw->writeCond, rw->lock );
-    rw->wantToWrite--;
-    rw->haveWriter = TRUE;
-    tr_lockUnlock( rw->lock );
-}
-
-int
-tr_rwWriterTrylock( tr_rwlock_t * rw )
-{
-    int ret = FALSE;
-    tr_lockLock( rw->lock );
-    if( !rw->haveWriter && !rw->readCount )
-        ret = rw->haveWriter = TRUE;
-    tr_lockUnlock( rw->lock );
-    return ret;
-}
-void
-tr_rwWriterUnlock( tr_rwlock_t * rw )
-{
-    tr_lockLock( rw->lock );
-    rw->haveWriter = FALSE;
-    tr_rwSignal( rw );
-    tr_lockUnlock( rw->lock );
-}
-
-void
-tr_rwFree( tr_rwlock_t * rw )
-{
-    tr_condFree( rw->writeCond );
-    tr_condFree( rw->readCond );
-    tr_lockFree( rw->lock );
-    tr_free( rw );
 }
 
@@ -357 +242 @@
 ***/
 
-struct tr_cond_s
+struct tr_cond
 {
 #ifdef __BEOS__
@@ -365 +250 @@
 #elif defined(WIN32)
     tr_list * events;
-    tr_lock_t * lock;
+    tr_lock * lock;
 #else
     pthread_cond_t cond;
@@ -384 +269 @@
 #endif
 
-tr_cond_t*
+tr_cond*
 tr_condNew( void )
 {
-    tr_cond_t * c = tr_new0( tr_cond_t, 1 );
+    tr_cond * c = tr_new0( tr_cond, 1 );
 #ifdef __BEOS__
     c->sem = create_sem( 1, "" );
@@ -402 +287 @@
 
 void
-tr_condWait( tr_cond_t * c, tr_lock_t * l )
+tr_condWait( tr_cond * c, tr_lock * l )
 {
 #ifdef __BEOS__
@@ -450 +335 @@
 
 #ifdef __BEOS__
-static int condTrySignal( tr_cond_t * c )
+static int condTrySignal( tr_cond * c )
 {
     if( c->start == c->end )
@@ -474 +359 @@
 #endif
 void
-tr_condSignal( tr_cond_t * c )
+tr_condSignal( tr_cond * c )
 {
 #ifdef __BEOS__
@@ -497 +382 @@
 
 void
-tr_condBroadcast( tr_cond_t * c )
+tr_condBroadcast( tr_cond * c )
 {
 #ifdef __BEOS__
@@ -521 +406 @@
 
 void
-tr_condFree( tr_cond_t * c )
+tr_condFree( tr_cond * c )
 {
 #ifdef __BEOS__

trunk/libtransmission/platform.h

@@ -25 +25 @@
 #define TR_PLATFORM_H
 
-typedef struct tr_lock_s   tr_lock_t;
-typedef struct tr_cond_s   tr_cond_t;
-typedef struct tr_thread_s tr_thread_t;
+typedef struct tr_lock   tr_lock;
+typedef struct tr_cond   tr_cond;
+typedef struct tr_thread tr_thread;
 
 const char * tr_getHomeDirectory( void );
@@ -33 +33 @@
 const char * tr_getTorrentsDirectory( void );
 
-tr_thread_t*  tr_threadNew  ( void (*func)(void *), void * arg, const char * name );
-void          tr_threadJoin ( tr_thread_t * );
+tr_thread*   tr_threadNew  ( void (*func)(void *), void * arg, const char * name );
+void         tr_threadJoin ( tr_thread * );
+int          tr_amInThread ( const tr_thread * );
 int           tr_amInThread ( const tr_thread_t * );
 
-tr_lock_t * tr_lockNew        ( void );
-void        tr_lockFree       ( tr_lock_t * );
-int         tr_lockTryLock    ( tr_lock_t * );
-void        tr_lockLock       ( tr_lock_t * );
-void        tr_lockUnlock     ( tr_lock_t * );
+tr_lock *    tr_lockNew        ( void );
+void         tr_lockFree       ( tr_lock * );
+int          tr_lockTryLock    ( tr_lock * );
+void         tr_lockLock       ( tr_lock * );
+void         tr_lockUnlock     ( tr_lock * );
 
-tr_cond_t * tr_condNew       ( void );
-void        tr_condFree      ( tr_cond_t * );
-void        tr_condSignal    ( tr_cond_t * );
-void        tr_condBroadcast ( tr_cond_t * );
-void        tr_condWait      ( tr_cond_t *, tr_lock_t * );
-
-/***
-**** RW lock:
-**** The lock can be had by one writer or any number of readers.
-***/
-
-typedef struct tr_rwlock_s tr_rwlock_t;
-
-tr_rwlock_t*  tr_rwNew           ( void );
-void          tr_rwFree          ( tr_rwlock_t * );
-void          tr_rwReaderLock    ( tr_rwlock_t * );
-int           tr_rwReaderTrylock ( tr_rwlock_t * );
-void          tr_rwReaderUnlock  ( tr_rwlock_t * );
-void          tr_rwWriterLock    ( tr_rwlock_t * );
-int           tr_rwWriterTrylock ( tr_rwlock_t * );
-void          tr_rwWriterUnlock  ( tr_rwlock_t * );
-
+tr_cond *    tr_condNew       ( void );
+void         tr_condFree      ( tr_cond * );
+void         tr_condSignal    ( tr_cond * );
+void         tr_condBroadcast ( tr_cond * );
+void         tr_condWait      ( tr_cond *, tr_lock * );
 
 struct in_addr; /* forward declaration to calm gcc down */

trunk/libtransmission/ptrarray.c

@@ -20 +20 @@
 #define GROW 32
 
-struct tr_ptrArray_s
+struct tr_ptrArray
 {
     void ** items;
@@ -27 +27 @@
 };
 
-tr_ptrArray_t*
+tr_ptrArray*
 tr_ptrArrayNew( void )
 {
-    tr_ptrArray_t * p;
+    tr_ptrArray * p;
 
-    p = tr_new( tr_ptrArray_t, 1 );
+    p = tr_new( tr_ptrArray, 1 );
     p->n_items = 0;
     p->n_alloc = GROW;
@@ -41 +41 @@
 
 void
-tr_ptrArrayFree( tr_ptrArray_t * t )
+tr_ptrArrayFree( tr_ptrArray * t )
 {
     assert( t != NULL );
@@ -51 +51 @@
 
 void**
-tr_ptrArrayPeek( tr_ptrArray_t * t, int * size )
+tr_ptrArrayPeek( tr_ptrArray * t, int * size )
 {
     *size = t->n_items;
@@ -57 +57 @@
 }
 
+void*
+tr_ptrArrayNth( tr_ptrArray* t, int i )
+{
+    assert( t != NULL  );
+    assert( i >= 0 );
+    assert( i < t->n_items );
+
+    return t->items[i];
+}
+
 int
-tr_ptrArraySize( const tr_ptrArray_t * t )
+tr_ptrArraySize( const tr_ptrArray * t )
 {
     return t->n_items;
@@ -64 +74 @@
 
 int
-tr_ptrArrayEmpty( const tr_ptrArray_t * t )
+tr_ptrArrayEmpty( const tr_ptrArray * t )
 {
     return t->n_items == 0;
@@ -70 +80 @@
 
 void
-tr_ptrArrayClear( tr_ptrArray_t * t )
+tr_ptrArrayClear( tr_ptrArray * t )
 {
     t->n_items = 0;
@@ -76 +86 @@
 
 int
-tr_ptrArrayInsert( tr_ptrArray_t * t, void * ptr, int pos )
+tr_ptrArrayInsert( tr_ptrArray * t, void * ptr, int pos )
 {
     if( pos<0 || pos>t->n_items )
@@ -96 +106 @@
 
 int
-tr_ptrArrayAppend( tr_ptrArray_t * t, void * ptr )
+tr_ptrArrayAppend( tr_ptrArray * t, void * ptr )
 {
     return tr_ptrArrayInsert( t, ptr, -1 );
@@ -102 +112 @@
 
 void
-tr_ptrArrayErase( tr_ptrArray_t * t, int begin, int end )
+tr_ptrArrayErase( tr_ptrArray * t, int begin, int end )
 {
     assert( begin >= 0 );
@@ -121 +131 @@
 
 int
-tr_ptrArrayLowerBound( const tr_ptrArray_t * t,
-                       void                * ptr,
-                       int                   compare( const void *,const void * ),
-                       int                 * exact_match )
+tr_ptrArrayLowerBound( const tr_ptrArray * t,
+                       const void        * ptr,
+                       int                 compare( const void *,const void * ),
+                       int               * exact_match )
 {
-    int c = -1;
     int len = t->n_items;
     int first = 0;
@@ -134 +143 @@
         int half = len / 2;
         int middle = first + half;
-        c = compare( t->items[middle], ptr );
+        const int c = compare( t->items[middle], ptr );
         if( c < 0 ) {
             first = middle + 1;
@@ -155 +164 @@
 
 int
-tr_ptrArrayInsertSorted( tr_ptrArray_t  * t,
-                         void           * ptr,
-                         int              compare(const void*,const void*) )
+tr_ptrArrayInsertSorted( tr_ptrArray  * t,
+                         void         * ptr,
+                         int            compare(const void*,const void*) )
 {
     const int pos = tr_ptrArrayLowerBound( t, ptr, compare, NULL );
@@ -164 +173 @@
 
 void*
-tr_ptrArrayFindSorted( tr_ptrArray_t  * t,
-                       void           * ptr,
-                       int              compare(const void*,const void*) )
+tr_ptrArrayFindSorted( tr_ptrArray  * t,
+                       const void   * ptr,
+                       int            compare(const void*,const void*) )
 {
     int match;
@@ -174 +183 @@
 
 void*
-tr_ptrArrayRemoveSorted( tr_ptrArray_t  * t,
-                         void           * ptr,
-                         int              compare(const void*,const void*) )
+tr_ptrArrayRemoveSorted( tr_ptrArray  * t,
+                         void         * ptr,
+                         int            compare(const void*,const void*) )
 {
     void * ret = NULL;

trunk/libtransmission/ptrarray.h

@@ -17 +17 @@
  * A simple pointer array that resizes itself dynamically.
  */
-typedef struct tr_ptrArray_s tr_ptrArray_t;
+typedef struct tr_ptrArray tr_ptrArray;
 
-tr_ptrArray_t * tr_ptrArrayNew         ( void );
-void            tr_ptrArrayFree        ( tr_ptrArray_t* );
-void**          tr_ptrArrayPeek        ( tr_ptrArray_t*, int * size );
-void**          tr_ptrArrayBase        ( tr_ptrArray_t* );
-void            tr_ptrArrayClear       ( tr_ptrArray_t* );
-int             tr_ptrArrayInsert      ( tr_ptrArray_t*, void*, int pos );
-int             tr_ptrArrayAppend      ( tr_ptrArray_t*, void* );
-void            tr_ptrArrayErase       ( tr_ptrArray_t*, int begin, int end );
-int             tr_ptrArraySize        ( const tr_ptrArray_t* );
-int             tr_ptrArrayEmpty       ( const tr_ptrArray_t* );
+tr_ptrArray * tr_ptrArrayNew     ( void );
 
-int             tr_ptrArrayInsertSorted( tr_ptrArray_t*, void*,
-                                         int compare(const void*,const void*) );
-void*           tr_ptrArrayRemoveSorted( tr_ptrArray_t*, void*,
-                                         int compare(const void*,const void*) );
-void*           tr_ptrArrayFindSorted  ( tr_ptrArray_t*, void*,
-                                         int compare(const void*,const void*) );
+void    tr_ptrArrayFree          ( tr_ptrArray* );
+void*   tr_ptrArrayNth           ( tr_ptrArray*, int n );
+void**  tr_ptrArrayPeek          ( tr_ptrArray*, int * size );
+void**  tr_ptrArrayBase          ( tr_ptrArray* );
+void    tr_ptrArrayClear         ( tr_ptrArray* );
+int     tr_ptrArrayInsert        ( tr_ptrArray*, void*, int pos );
+int     tr_ptrArrayAppend        ( tr_ptrArray*, void* );
+void    tr_ptrArrayErase         ( tr_ptrArray*, int begin, int end );
+int     tr_ptrArraySize          ( const tr_ptrArray* );
+int     tr_ptrArrayEmpty         ( const tr_ptrArray* );
+int     tr_ptrArrayInsertSorted  ( tr_ptrArray*, void*,
+                                   int compare(const void*,const void*) );
+void*   tr_ptrArrayRemoveSorted  ( tr_ptrArray*, void*,
+                                   int compare(const void*,const void*) );
+void*   tr_ptrArrayFindSorted    ( tr_ptrArray*, const void*,
+                                   int compare(const void*,const void*) );
 
 #endif

trunk/libtransmission/publish.c

@@ -11 +11 @@
  */
 
+#include <assert.h>
 #include "list.h"
 #include "publish.h"
@@ -23 +24 @@
 struct tr_publisher_s
 {
-    tr_list_t * list;
+    tr_list * list;
 };
 
@@ -33 +34 @@
 
 void
-tr_publisherFree( tr_publisher_t * p )
+tr_publisherFree( tr_publisher_t ** p )
 {
-    tr_list_free( &p->list );
-    tr_free( p );
+    assert( p != NULL );
+    assert( *p != NULL );
+
+    tr_list_free( &(*p)->list );
+    tr_free( *p );
+    *p = NULL;
 }
 
@@ -64 +69 @@
                      void            * event )
 {
-    tr_list_t * walk;
+    tr_list * walk;
     for( walk=p->list; walk!=NULL; )
     {
-        tr_list_t * next = walk->next;
+        tr_list * next = walk->next;
         struct tr_publisher_node * node = (struct tr_publisher_node*)walk->data;
         (node->func)(source, event, node->user_data);

trunk/libtransmission/publish.h

@@ -43 +43 @@
 tr_publisher_t *   tr_publisherNew         ( void );
 
-void               tr_publisherFree        ( tr_publisher_t    * publisher );
+void               tr_publisherFree        ( tr_publisher_t   ** publisher );
 
 void               tr_publisherPublish     ( tr_publisher_t    * publisher,

trunk/libtransmission/ratecontrol.c

@@ -39 +39 @@
 {
     uint64_t date;
-    int      size;
+    uint64_t size;
 }
 tr_transfer_t;
 
-struct tr_ratecontrol_s
+struct tr_ratecontrol
 {
-    tr_lock_t * lock;
+    tr_lock * lock;
     int limit;
     int newest;
@@ -53 +53 @@
 /* return the xfer rate over the last `interval' seconds in KiB/sec */
 static float
-rateForInterval( const tr_ratecontrol_t * r, int interval_msec )
+rateForInterval( const tr_ratecontrol * r, int interval_msec )
 {
     uint64_t bytes = 0;
-    const uint64_t now = tr_date ();
+    const uint64_t cutoff = tr_date () - interval_msec;
     int i = r->newest;
     for( ;; )
     {
-        if( r->transfers[i].date + interval_msec < now )
+        if( r->transfers[i].date < cutoff )
             break;
 
@@ -76 +76 @@
 ***/
 
-tr_ratecontrol_t*
+tr_ratecontrol*
 tr_rcInit( void )
 {
-    tr_ratecontrol_t * r = tr_new0( tr_ratecontrol_t, 1 );
+    tr_ratecontrol * r = tr_new0( tr_ratecontrol, 1 );
     r->limit = 0;
     r->lock = tr_lockNew( );
@@ -86 +86 @@
 
 void
-tr_rcClose( tr_ratecontrol_t * r )
+tr_rcClose( tr_ratecontrol * r )
 {
     tr_rcReset( r );
@@ -98 +98 @@
 
 int
-tr_rcCanTransfer( const tr_ratecontrol_t * r )
+tr_rcCanTransfer( const tr_ratecontrol * r )
 {
     int ret;
-    tr_lockLock( (tr_lock_t*)r->lock );
 
-    ret = rateForInterval( r, SHORT_INTERVAL_MSEC ) < r->limit;
+    if( r == NULL )
+        ret = 0;
+    else {
+        tr_lockLock( (tr_lock*)r->lock );
+        ret = rateForInterval( r, SHORT_INTERVAL_MSEC ) < r->limit;
+        tr_lockUnlock( (tr_lock*)r->lock );
+    }
 
-    tr_lockUnlock( (tr_lock_t*)r->lock );
     return ret;
 }
 
 float
-tr_rcRate( const tr_ratecontrol_t * r )
+tr_rcRate( const tr_ratecontrol * r )
 {
     float ret;
-    tr_lockLock( (tr_lock_t*)r->lock );
 
-    ret = rateForInterval( r, LONG_INTERVAL_MSEC );
+    if( r == NULL )
+        ret = 0.0f;
+    else {
+        tr_lockLock( (tr_lock*)r->lock );
+        ret = rateForInterval( r, LONG_INTERVAL_MSEC );
+        tr_lockUnlock( (tr_lock*)r->lock );
+    }
 
-    tr_lockUnlock( (tr_lock_t*)r->lock );
     return ret;
 }
@@ -126 +134 @@
 
 void
-tr_rcTransferred( tr_ratecontrol_t * r, int size )
+tr_rcTransferred( tr_ratecontrol * r, size_t size )
 {
     uint64_t now;
@@ -133 +141 @@
         return;
     
-    tr_lockLock( (tr_lock_t*)r->lock );
+    tr_lockLock( (tr_lock*)r->lock );
 
     now = tr_date ();
@@ -144 +152 @@
     }
 
-    tr_lockUnlock( (tr_lock_t*)r->lock );
+    tr_lockUnlock( (tr_lock*)r->lock );
 }
 
 void
-tr_rcReset( tr_ratecontrol_t * r )
+tr_rcReset( tr_ratecontrol * r )
 {
-    tr_lockLock( (tr_lock_t*)r->lock );
+    tr_lockLock( (tr_lock*)r->lock );
     r->newest = 0;
     memset( r->transfers, 0, sizeof(tr_transfer_t) * HISTORY_SIZE );
-    tr_lockUnlock( (tr_lock_t*)r->lock );
+    tr_lockUnlock( (tr_lock*)r->lock );
 }
 
 void
-tr_rcSetLimit( tr_ratecontrol_t * r, int limit )
+tr_rcSetLimit( tr_ratecontrol * r, int limit )
 {
-    tr_lockLock( (tr_lock_t*)r->lock );
+    tr_lockLock( (tr_lock*)r->lock );
     r->limit = limit;
-    tr_lockUnlock( (tr_lock_t*)r->lock );
+    tr_lockUnlock( (tr_lock*)r->lock );
 }
 
 int
-tr_rcGetLimit( const tr_ratecontrol_t * r )
+tr_rcGetLimit( const tr_ratecontrol * r )
 {
     return r->limit;

trunk/libtransmission/ratecontrol.h

@@ -26 +26 @@
 #define _TR_RATECONTROL_H_
 
-typedef struct tr_ratecontrol_s tr_ratecontrol_t;
+typedef struct tr_ratecontrol tr_ratecontrol;
 
-tr_ratecontrol_t * tr_rcInit( void );
-void               tr_rcSetLimit( tr_ratecontrol_t *, int );
-int                tr_rcGetLimit( const tr_ratecontrol_t * );
-int                tr_rcCanTransfer( const tr_ratecontrol_t * );
-void               tr_rcTransferred( tr_ratecontrol_t *, int );
-float              tr_rcRate( const tr_ratecontrol_t * );
-void               tr_rcReset( tr_ratecontrol_t * );
-void               tr_rcClose( tr_ratecontrol_t * );
+tr_ratecontrol * tr_rcInit( void );
+void             tr_rcSetLimit( tr_ratecontrol *, int );
+int              tr_rcGetLimit( const tr_ratecontrol * );
+int              tr_rcCanTransfer( const tr_ratecontrol * );
+void             tr_rcTransferred( tr_ratecontrol *, size_t byteCount );
+float            tr_rcRate( const tr_ratecontrol * );
+void             tr_rcReset( tr_ratecontrol * );
+void             tr_rcClose( tr_ratecontrol * );
 
 #endif

trunk/libtransmission/shared.c

@@ -26 +26 @@
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 
 #include <sys/types.h>
 
 #include "transmission.h"
-#include "choking.h"
+#include "handshake.h"
 #include "natpmp.h"
 #include "net.h"
-#include "peer.h"
+#include "peer-io.h"
+#include "peer-mgr.h"
 #include "platform.h"
 #include "shared.h"
+#include "trevent.h"
 #include "upnp.h"
 #include "utils.h"
 
-/* Maximum number of peers that we keep in our local list */
-/* This is an arbitrary number, but it seems to work well */
-#define MAX_PEER_COUNT 128
-
-struct tr_shared_s
-{
-    tr_handle_t  * h;
-    volatile int   die;
-    tr_thread_t  * thread;
-    tr_lock_t    * lock;
+struct tr_shared
+{
+    tr_handle    * h;
+    tr_lock      * lock;
+    tr_timer     * pulseTimer;
 
     /* Incoming connections */
-    int          publicPort;
-    int          bindPort;
-    int          bindSocket;
-    int          peerCount;
-    tr_peer_t    * peers[MAX_PEER_COUNT];
+    int publicPort;
+    int bindPort;
+    int bindSocket;
 
     /* NAT-PMP/UPnP */
     tr_natpmp_t  * natpmp;
     tr_upnp_t    * upnp;
-
-    /* Choking */
-    tr_choking_t * choking;
 };
 
@@ -68 +61 @@
  * Local prototypes
  **********************************************************************/
-static void SharedLoop( void * );
-static void SetPublicPort( tr_shared_t *, int );
-static void AcceptPeers( tr_shared_t * );
-static void ReadPeers( tr_shared_t * );
-static void DispatchPeers( tr_shared_t * );
+static int SharedLoop( void * );
+static void SetPublicPort( tr_shared *, int );
+static void AcceptPeers( tr_shared * );
 
 
@@ -80 +71 @@
  *
  **********************************************************************/
-tr_shared_t * tr_sharedInit( tr_handle_t * h )
-{
-    tr_shared_t * s = calloc( 1, sizeof( tr_shared_t ) );
+tr_shared * tr_sharedInit( tr_handle * h )
+{
+    tr_shared * s = calloc( 1, sizeof( tr_shared ) );
 
     s->h          = h;
@@ -91 +82 @@
     s->natpmp     = tr_natpmpInit();
     s->upnp       = tr_upnpInit();
-    s->choking    = tr_chokingInit( h );
-    s->die        = 0;
-    s->thread     = tr_threadNew( SharedLoop, s, "shared" );
+    s->pulseTimer   = tr_timerNew( h, SharedLoop, s, 250 );
 
     return s;
@@ -103 +92 @@
  *
  **********************************************************************/
-void tr_sharedClose( tr_shared_t * s )
-{
-    int ii;
-
-    /* Stop the thread */
-    s->die = 1;
-    tr_threadJoin( s->thread );
-
-    /* Clean up */
-    for( ii = 0; ii < s->peerCount; ii++ )
-    {
-        tr_peerDestroy( s->peers[ii] );
-    }
-    if( s->bindSocket > -1 )
-    {
-        tr_netClose( s->bindSocket );
-    }
+void tr_sharedClose( tr_shared * s )
+{
+fprintf( stderr, "deleting pulse tag\n" );
+    tr_timerFree( &s->pulseTimer );
+
+    tr_netClose( s->bindSocket );
     tr_lockFree( s->lock );
     tr_natpmpClose( s->natpmp );
     tr_upnpClose( s->upnp );
-    tr_chokingClose( s->choking );
     free( s );
 }
 
-/***********************************************************************
- * tr_sharedLock, tr_sharedUnlock
- ***********************************************************************
- *
- **********************************************************************/
-void tr_sharedLock( tr_shared_t * s )
+/**
+***
+**/
+
+void tr_sharedLock( tr_shared * s )
 {
     tr_lockLock( s->lock );
 }
-void tr_sharedUnlock( tr_shared_t * s )
+void tr_sharedUnlock( tr_shared * s )
 {
     tr_lockUnlock( s->lock );
@@ -146 +122 @@
  *
  **********************************************************************/
-void tr_sharedSetPort( tr_shared_t * s, int port )
+void tr_sharedSetPort( tr_shared * s, int port )
 {
 #ifdef BEOS_NETSERVER
@@ -197 +173 @@
 }
 
-/***********************************************************************
- * tr_sharedGetPublicPort
- ***********************************************************************
- *
- **********************************************************************/
-int tr_sharedGetPublicPort( tr_shared_t * s )
+int tr_sharedGetPublicPort( tr_shared * s )
 {
     return s->publicPort;
@@ -212 +183 @@
  *
  **********************************************************************/
-void tr_sharedTraversalEnable( tr_shared_t * s, int enable )
+void tr_sharedTraversalEnable( tr_shared * s, int enable )
 {
     if( enable )
@@ -226 +197 @@
 }
 
-int tr_sharedTraversalStatus( tr_shared_t * s )
+int tr_sharedTraversalStatus( tr_shared * s )
 {
     int statuses[] = {
@@ -256 +227 @@
 }
 
-/***********************************************************************
- * tr_sharedSetLimit
- **********************************************************************/
-void tr_sharedSetLimit( tr_shared_t * s, int limit )
-{
-    tr_chokingSetLimit( s->choking, limit );
-}
-
 
 /***********************************************************************
@@ -272 +235 @@
  * SharedLoop
  **********************************************************************/
-static void SharedLoop( void * _s )
-{
-    tr_shared_t * s = _s;
-    uint64_t      date1, date2, lastchoke = 0;
-    int           newPort;
+static int
+SharedLoop( void * vs )
+{
+    int newPort;
+    tr_shared * s = vs;
 
     tr_sharedLock( s );
 
-    while( !s->die )
-    {
-        date1 = tr_date();
-
-        /* NAT-PMP and UPnP pulses */
-        newPort = -1;
-        tr_natpmpPulse( s->natpmp, &newPort );
-        if( 0 < newPort && newPort != s->publicPort )
-        {
-            SetPublicPort( s, newPort );
-        }
-        tr_upnpPulse( s->upnp );
-
-        /* Handle incoming connections */
-        AcceptPeers( s );
-        ReadPeers( s );
-        DispatchPeers( s );
-
-        /* Update choking every second */
-        if( date1 > lastchoke + 1000 )
-        {
-            tr_chokingPulse( s->choking );
-            lastchoke = date1;
-        }
-
-        tr_swiftPulse ( s->h );
-
-        /* Wait up to 20 ms */
-        date2 = tr_date();
-        if( date2 < date1 + 20 )
-        {
-            tr_sharedUnlock( s );
-            tr_wait( date1 + 20 - date2 );
-            tr_sharedLock( s );
-        }
-    }
+    /* NAT-PMP and UPnP pulses */
+    newPort = -1;
+    tr_natpmpPulse( s->natpmp, &newPort );
+    if( 0 < newPort && newPort != s->publicPort )
+        SetPublicPort( s, newPort );
+    tr_upnpPulse( s->upnp );
+
+    /* Handle incoming connections */
+    AcceptPeers( s );
 
     tr_sharedUnlock( s );
+
+    return TRUE;
 }
 
@@ -323 +261 @@
  * SetPublicPort
  **********************************************************************/
-static void SetPublicPort( tr_shared_t * s, int port )
-{
-    tr_handle_t * h = s->h;
-    tr_torrent_t * tor;
+static void SetPublicPort( tr_shared * s, int port )
+{
+    tr_handle * h = s->h;
+    tr_torrent * tor;
 
     s->publicPort = port;
@@ -339 +277 @@
  * Check incoming connections and add the peers to our local list
  **********************************************************************/
-static void AcceptPeers( tr_shared_t * s )
-{
-    int socket;
-    struct in_addr addr;
-
+
+static void
+AcceptPeers( tr_shared * s )
+{
     for( ;; )
     {
-        if( s->bindSocket < 0 || s->peerCount >= MAX_PEER_COUNT )
-        {
+        int socket;
+        struct in_addr addr;
+
+        if( s->bindSocket < 0 || !tr_peerMgrIsAcceptingConnections( s->h->peerMgr ) )
             break;
-        }
 
         socket = tr_netAccept( s->bindSocket, &addr, NULL );
         if( socket < 0 )
-        {
             break;
-        }
-        s->peers[s->peerCount++] = tr_peerInit( &addr, 0, socket,
-                                                TR_PEER_FROM_INCOMING );
-    }
-}
-
-/***********************************************************************
- * ReadPeers
- ***********************************************************************
- * Try to read handshakes
- **********************************************************************/
-static void ReadPeers( tr_shared_t * s )
-{
-    int ii;
-
-    for( ii = 0; ii < s->peerCount; )
-    {
-        if( tr_peerRead( s->peers[ii] ) )
-        {
-            tr_peerDestroy( s->peers[ii] );
-            s->peerCount--;
-            memmove( &s->peers[ii], &s->peers[ii+1],
-                     ( s->peerCount - ii ) * sizeof( tr_peer_t * ) );
-            continue;
-        }
-        ii++;
-    }
-}
-
-/***********************************************************************
- * DispatchPeers
- ***********************************************************************
- * If we got a handshake, try to find the torrent for this peer
- **********************************************************************/
-static void DispatchPeers( tr_shared_t * s )
-{
-    tr_handle_t * h = s->h;
-    int ii;
-    const uint64_t now = tr_date();
-
-    for( ii = 0; ii < s->peerCount; )
-    {
-        const uint8_t * hash = tr_peerHash( s->peers[ii] );
-
-        if( !hash && now > tr_peerDate( s->peers[ii] ) + 10000 )
-        {
-            /* 10 seconds and no handshake, drop it */
-            tr_peerDestroy( s->peers[ii] );
-            goto removePeer;
-        }
-        if( hash )
-        {
-            tr_torrent_t * tor;
-
-            for( tor = h->torrentList; tor; tor = tor->next )
-            {
-                tr_torrentWriterLock( tor );
-                if( tor->runStatus != TR_RUN_RUNNING )
-                {
-                    tr_torrentWriterUnlock( tor );
-                    continue;
-                }
-
-                if( !memcmp( tor->info.hash, hash, SHA_DIGEST_LENGTH ) )
-                {
-                    /* Found it! */
-                    tr_torrentAttachPeer( tor, s->peers[ii] );
-                    tr_torrentWriterUnlock( tor );
-                    goto removePeer;
-                }
-                tr_torrentWriterUnlock( tor );
-            }
-
-            /* Couldn't find a torrent, we probably removed it */
-            tr_peerDestroy( s->peers[ii] );
-            goto removePeer;
-        }
-        ii++;
-        continue;
-
-removePeer:
-        s->peerCount--;
-        memmove( &s->peers[ii], &s->peers[ii+1],
-                ( s->peerCount - ii ) * sizeof( tr_peer_t * ) );
-    }
-}
-
+
+        tr_peerMgrAddIncoming( s->h->peerMgr, &addr, socket );
+    }
+}

trunk/libtransmission/shared.h

@@ -28 +28 @@
 #include "transmission.h"
 
-typedef struct tr_shared_s tr_shared_t;
+typedef struct tr_shared tr_shared;
 
 /***********************************************************************
@@ -36 +36 @@
  * among the torrents: NAT-PMP/UPnP, incoming connections, peer choking
  **********************************************************************/
-tr_shared_t * tr_sharedInit           ( tr_handle_t * );
-void          tr_sharedClose          ( tr_shared_t * );
+tr_shared * tr_sharedInit           ( tr_handle * );
+void        tr_sharedClose          ( tr_shared * );
 
 /***********************************************************************
@@ -45 +45 @@
  * thread
  **********************************************************************/
-void          tr_sharedLock           ( tr_shared_t * );
-void          tr_sharedUnlock         ( tr_shared_t * );
+void          tr_sharedLock           ( tr_shared * );
+void          tr_sharedUnlock         ( tr_shared * );
 
 /***********************************************************************
@@ -54 +54 @@
  * should be called with the shared lock held.
  **********************************************************************/
-void         tr_sharedSetPort         ( tr_shared_t *, int port );
-int          tr_sharedGetPublicPort   ( tr_shared_t * s );
+void         tr_sharedSetPort         ( tr_shared *, int port );
+int          tr_sharedGetPublicPort   ( tr_shared * s );
 
 /***********************************************************************
@@ -63 +63 @@
  * be called with the shared lock held.
  **********************************************************************/
-void         tr_sharedTraversalEnable ( tr_shared_t *, int enable );
-int          tr_sharedTraversalStatus ( tr_shared_t * );
+void         tr_sharedTraversalEnable ( tr_shared *, int enable );
+int          tr_sharedTraversalStatus ( tr_shared * );
 
-/***********************************************************************
- * tr_sharedSetLimit
- ***********************************************************************
- *
- **********************************************************************/
-void         tr_sharedSetLimit        ( tr_shared_t *, int limit );
 
 #endif

trunk/libtransmission/torrent.c

@@ -32 +32 @@
 #include "transmission.h"
 #include "completion.h"
+#include "crypto.h" /* for tr_sha1 */
 #include "fastresume.h"
+#include "handshake.h"
 #include "inout.h"
 #include "metainfo.h"
 #include "net.h" /* tr_netNtop */
 #include "peer.h"
+#include "peer-mgr.h"
 #include "platform.h"
 #include "ratecontrol.h"
@@ -42 +45 @@
 #include "tracker.h"
 #include "trcompat.h" /* for strlcpy */
+#include "trevent.h"
 #include "utils.h"
+
+/***
+****
+***/
+
+int
+tr_torrentExists( tr_handle       * handle,
+                  const uint8_t   * torrentHash )
+{
+    return tr_torrentFindFromHash( handle, torrentHash ) != NULL;
+}
+
+tr_torrent*
+tr_torrentFindFromHash( tr_handle      * handle,
+                        const uint8_t  * torrentHash )
+{
+    tr_torrent * tor;
+
+    for( tor = handle->torrentList; tor; tor = tor->next )
+        if( !memcmp( tor->info.hash, torrentHash, SHA_DIGEST_LENGTH ) )
+            return tor;
+
+    return NULL;
+}
+
+tr_torrent*
+tr_torrentFindFromObfuscatedHash( tr_handle      * handle,
+                                  const uint8_t  * obfuscatedTorrentHash )
+{
+    tr_torrent * tor;
+
+    for( tor = handle->torrentList; tor; tor = tor->next )
+        if( !memcmp( tor->obfuscatedHash, obfuscatedTorrentHash, SHA_DIGEST_LENGTH ) )
+            return tor;
+
+    return NULL;
+}
 
 /***
@@ -49 +90 @@
 
 void
-tr_torrentReaderLock( const tr_torrent_t * tor )
-{
-    tr_rwReaderLock ( (tr_rwlock_t*)tor->lock );
-}
-
-void
-tr_torrentReaderUnlock( const tr_torrent_t * tor )
-{
-    tr_rwReaderUnlock ( (tr_rwlock_t*)tor->lock );
-}
-
-void
-tr_torrentWriterLock( tr_torrent_t * tor )
-{
-    tr_rwWriterLock ( tor->lock );
-}
-
-void
-tr_torrentWriterUnlock( tr_torrent_t * tor )
-{
-    tr_rwWriterUnlock ( tor->lock );
+tr_torrentLock( const tr_torrent * tor )
+{
+    tr_lockLock ( (tr_lock*)tor->lock );
+}
+
+void
+tr_torrentUnlock( const tr_torrent * tor )
+{
+    tr_lockUnlock ( (tr_lock*)tor->lock );
 }
 
@@ -77 +106 @@
 
 void
-tr_torrentSetSpeedMode( tr_torrent_t     * tor,
-                        int                up_or_down,
-                        tr_speedlimit_t    mode )
-{
-    tr_speedlimit_t * limit = up_or_down==TR_UP
+tr_torrentSetSpeedMode( tr_torrent   * tor,
+                        int            up_or_down,
+                        tr_speedlimit  mode )
+{
+    tr_speedlimit * limit = up_or_down==TR_UP
         ? &tor->uploadLimitMode
         : &tor->downloadLimitMode;
@@ -87 +116 @@
 }
 
-tr_speedlimit_t
-tr_torrentGetSpeedMode( const tr_torrent_t * tor,
-                        int                  up_or_down)
+tr_speedlimit
+tr_torrentGetSpeedMode( const tr_torrent * tor,
+                        int                up_or_down)
 {
     return up_or_down==TR_UP ? tor->uploadLimitMode
@@ -96 +125 @@
 
 void
-tr_torrentSetSpeedLimit( tr_torrent_t   * tor,
-                         int              up_or_down,
-                         int              single_KiB_sec )
-{
-    tr_ratecontrol_t * rc = up_or_down==TR_UP ? tor->upload : tor->download;
+tr_torrentSetSpeedLimit( tr_torrent   * tor,
+                         int            up_or_down,
+                         int            single_KiB_sec )
+{
+    tr_ratecontrol * rc = up_or_down==TR_UP ? tor->upload : tor->download;
     tr_rcSetLimit( rc, single_KiB_sec );
 }
 
 int
-tr_torrentGetSpeedLimit( const tr_torrent_t  * tor,
-                         int                   up_or_down )
-{
-    tr_ratecontrol_t * rc = up_or_down==TR_UP ? tor->upload : tor->download;
+tr_torrentGetSpeedLimit( const tr_torrent  * tor,
+                         int                 up_or_down )
+{
+    tr_ratecontrol * rc = up_or_down==TR_UP ? tor->upload : tor->download;
     return tr_rcGetLimit( rc );
 }
@@ -116 +145 @@
 ***/
 
-static void setRunState( tr_torrent_t *, run_status_t );
-
 static void
 onTrackerResponse( void * tracker UNUSED, void * vevent, void * user_data )
 {
-    tr_torrent_t * tor = (tr_torrent_t *) user_data;
+    tr_torrent * tor = (tr_torrent *) user_data;
     tr_tracker_event_t * event = (tr_tracker_event_t *) vevent;
 
@@ -127 +154 @@
     {
         case TR_TRACKER_PEERS:
-            tr_torrentAddCompact( tor, TR_PEER_FROM_TRACKER,
-                                  event->peerCompact, event->peerCount );
+            tr_peerMgrAddPeers( tor->handle->peerMgr,
+                                tor->info.hash,
+                                TR_PEER_FROM_TRACKER,
+                                event->peerCompact,
+                                event->peerCount );
             break;
 
@@ -144 +174 @@
 
         case TR_TRACKER_STOPPED:
-            if( tor->runStatus == TR_RUN_STOPPING_NET_WAIT )
-                setRunState( tor, TR_RUN_STOPPED );
+            //assert( tor->runStatus == TR_RUN_STOPPING );
+            tor->runStatus = TR_RUN_STOPPED;
             break;
     }
@@ -157 +187 @@
 
 static int
-getBytePiece( const tr_info_t * info, uint64_t byteOffset )
+getBytePiece( const tr_info * info, uint64_t byteOffset )
 {
     assert( info != NULL );
@@ -166 +196 @@
 
 static void
-initFilePieces ( tr_info_t * info, int fileIndex )
-{
-    tr_file_t * file = &info->files[fileIndex];
+initFilePieces ( tr_info * info, int fileIndex )
+{
+    tr_file * file = &info->files[fileIndex];
     uint64_t firstByte, lastByte;
 
@@ -182 +212 @@
 
 static tr_priority_t
-calculatePiecePriority ( const tr_torrent_t * tor,
-                         int                  piece )
+calculatePiecePriority ( const tr_torrent * tor,
+                         int                piece )
 {
     int i;
@@ -190 +220 @@
     for( i=0; i<tor->info.fileCount; ++i )
     {
-        const tr_file_t * file = &tor->info.files[i];
+        const tr_file * file = &tor->info.files[i];
         if ( file->firstPiece <= piece
           && file->lastPiece  >= piece
@@ -208 +238 @@
 
 static void
-tr_torrentInitFilePieces( tr_torrent_t * tor )
+tr_torrentInitFilePieces( tr_torrent * tor )
 {
     int i;
@@ -225 +255 @@
 }
 
-static void torrentThreadLoop( void * );
+static void recheckCpState( tr_torrent * );
 
 static void
-torrentRealInit( tr_handle_t   * h,
-                 tr_torrent_t  * tor,
-                 const char    * destination,
-                 int             flags )
+tr_torrentStartImpl( tr_torrent * tor )
+{
+    assert( tor != NULL );
+    assert( tor->runStatus == TR_RUN_RUNNING );
+
+    *tor->errorString = '\0';
+    tr_torrentResetTransferStats( tor );
+    recheckCpState( tor );
+    tor->startDate = tr_date();
+    tr_trackerStart( tor->tracker );
+    tr_peerMgrStartTorrent( tor->handle->peerMgr, tor->info.hash );
+}
+
+static void
+recheckDoneCB( tr_torrent * tor )
+{
+    recheckCpState( tor );
+
+    if( tor->runStatus == TR_RUN_RUNNING )
+        tr_torrentStartImpl( tor );
+}
+
+static void
+torrentRealInit( tr_handle_t * h,
+                 tr_torrent  * tor,
+                 const char  * destination,
+                 int           flags )
 {
     uint64_t loaded;
     uint64_t t;
-    char name[512];
-    tr_bitfield_t * uncheckedPieces;
-    tr_info_t * info = &tor->info;
+    tr_bitfield * uncheckedPieces;
+    tr_info * info = &tor->info;
     
     tor->info.flags |= flags;
@@ -299 +351 @@
     tr_torrentInitFilePieces( tor );
 
-    tor->lock = tr_rwNew( );
+    tor->lock = tr_lockNew( );
 
     tor->upload         = tr_rcInit();
     tor->download       = tr_rcInit();
     tor->swarmspeed     = tr_rcInit();
+
+    tr_sha1( tor->obfuscatedHash, "req2", 4,
+                                  info->hash, SHA_DIGEST_LENGTH,
+                                  NULL );
  
     /* We have a new torrent */
@@ -309 +365 @@
 
     tr_sharedUnlock( h->shared );
+
+    tr_peerMgrAddTorrent( h->peerMgr, tor );
 
     if( !h->isPortSet )
@@ -347 +405 @@
     tor->tracker = tr_trackerNew( tor );
     tor->trackerSubscription = tr_trackerSubscribe( tor->tracker, onTrackerResponse, tor );
-    if( tor->runStatus == TR_RUN_RUNNING )
-        tr_trackerStart( tor->tracker );
 
     tr_sharedLock( h->shared );
@@ -356 +412 @@
     tr_sharedUnlock( h->shared );
 
-    snprintf( name, sizeof( name ), "torrent %p (%s)", tor, tor->info.name );
-    tor->thread = tr_threadNew( torrentThreadLoop, tor, name );
+    tr_ioRecheckAdd( tor, recheckDoneCB, tor->runStatus );
 }
 
@@ -365 +420 @@
               const char          * name )
 {
-    const tr_torrent_t * tor;
+    const tr_torrent * tor;
     
     for( tor=h->torrentList; tor; tor=tor->next )
@@ -379 +434 @@
             const uint8_t       * hash )
 {
-    const tr_torrent_t * tor;
+    const tr_torrent * tor;
 
     for( tor=h->torrentList; tor; tor=tor->next )
@@ -391 +446 @@
 infoCanAdd( const tr_handle_t   * h,
             const char          * destination,
-            const tr_info_t     * info )
+            const tr_info     * info )
 {
     if( hashExists( h, info->hash ) )
@@ -406 +461 @@
                  const char         * path,
                  const char         * destination,
-                 tr_info_t          * setme_info )
+                 tr_info          * setme_info )
 {
     int ret, doFree;
-    tr_info_t tmp;
+    tr_info tmp;
 
     if( setme_info == NULL )
         setme_info = &tmp;
 
-    memset( setme_info, 0, sizeof( tr_info_t ) );
+    memset( setme_info, 0, sizeof( tr_info ) );
     ret = tr_metainfoParseFile( setme_info, h->tag, path, FALSE );
     doFree = !ret && (setme_info == &tmp);
@@ -427 +482 @@
 }
  
-tr_torrent_t *
+tr_torrent *
 tr_torrentInit( tr_handle_t   * h,
                 const char    * path,
@@ -436 +491 @@
     int val;
     int tmpError;
-    tr_torrent_t * tor = NULL;
+    tr_torrent * tor = NULL;
 
     if( !error )
@@ -443 +498 @@
     if(( val = tr_torrentParse( h, path, destination, NULL )))
         *error = val;
-    else if(!(( tor = tr_new0( tr_torrent_t, 1 ))))
+    else if(!(( tor = tr_new0( tr_torrent, 1 ))))
         *error = TR_EOTHER;
     else {
@@ -457 +512 @@
                      const char         * hashStr,
                      const char         * destination,
-                     tr_info_t          * setme_info )
+                     tr_info          * setme_info )
 {
     int ret, doFree;
-    tr_info_t tmp;
+    tr_info tmp;
 
     if( setme_info == NULL )
         setme_info = &tmp;
 
-    memset( setme_info, 0, sizeof( tr_info_t ) );
+    memset( setme_info, 0, sizeof( tr_info ) );
     ret = tr_metainfoParseHash( setme_info, h->tag, hashStr );
     doFree = !ret && (setme_info == &tmp);
@@ -478 +533 @@
 }
 
-tr_torrent_t *
+tr_torrent *
 tr_torrentInitSaved( tr_handle_t    * h,
                      const char     * hashStr,
@@ -487 +542 @@
     int val;
     int tmpError;
-    tr_torrent_t * tor = NULL;
+    tr_torrent * tor = NULL;
 
     if( !error )
@@ -494 +549 @@
     if(( val = tr_torrentParseHash( h, hashStr, destination, NULL )))
         *error = val;
-    else if(!(( tor = tr_new0( tr_torrent_t, 1 ))))
+    else if(!(( tor = tr_new0( tr_torrent, 1 ))))
         *error = TR_EOTHER;
     else {
@@ -509 +564 @@
                      size_t               size,
                      const char         * destination,
-                     tr_info_t          * setme_info )
+                     tr_info          * setme_info )
 {
     int ret, doFree;
-    tr_info_t tmp;
+    tr_info tmp;
 
     if( setme_info == NULL )
         setme_info = &tmp;
 
-    memset( setme_info, 0, sizeof( tr_info_t ) );
+    memset( setme_info, 0, sizeof( tr_info ) );
     ret = tr_metainfoParseData( setme_info, h->tag, data, size, FALSE );
     doFree = !ret && (setme_info == &tmp);
@@ -530 +585 @@
 }
 
-tr_torrent_t *
+tr_torrent *
 tr_torrentInitData( tr_handle_t    * h,
                     const uint8_t  * data,
@@ -540 +595 @@
     int val;
     int tmpError;
-    tr_torrent_t * tor = NULL;
+    tr_torrent * tor = NULL;
 
     if( !error )
@@ -547 +602 @@
     if(( val = tr_torrentParseData( h, data, size, destination, NULL )))
         *error = val;
-    else if(!(( tor = tr_new0( tr_torrent_t, 1 ))))
+    else if(!(( tor = tr_new0( tr_torrent, 1 ))))
         *error = TR_EOTHER;
     else {
@@ -557 +612 @@
 }
 
-const tr_info_t *
-tr_torrentInfo( const tr_torrent_t * tor )
+const tr_info *
+tr_torrentInfo( const tr_torrent * tor )
 {
     return &tor->info;
@@ -568 +623 @@
 
 #if 0
-int tr_torrentScrape( tr_torrent_t * tor, int * s, int * l, int * d )
+int tr_torrentScrape( tr_torrent * tor, int * s, int * l, int * d )
 {
     return tr_trackerScrape( tor, s, l, d );
@@ -574 +629 @@
 #endif
 
+static int
+saveFastResumeNow( void * vtor )
+{
+    tr_torrent * tor = (tr_torrent *) vtor;
+
+    tr_fastResumeSave( tor );
+    recheckCpState( tor );
+
+    tr_timerFree( &tor->saveTimer );
+    return FALSE;
+}
+
 static void
-fastResumeSave( tr_torrent_t * tor )
-{
-    tr_fastResumeSave( tor );
-    tor->fastResumeDirty = FALSE;
-}
-
-void
-tr_torrentSetFolder( tr_torrent_t * tor, const char * path )
+saveFastResumeSoon( void * vtor )
+{
+    tr_torrent * tor = (tr_torrent *) vtor;
+
+    if( tor->saveTimer == NULL )
+        tor->saveTimer = tr_timerNew( tor->handle, saveFastResumeNow, tor, 1000 );
+}
+
+/**
+***
+**/
+
+void
+tr_torrentSetFolder( tr_torrent * tor, const char * path )
 {
     tr_free( tor->destination );
     tor->destination = tr_strdup( path );
-    fastResumeSave( tor );
+    saveFastResumeSoon( tor );
 }
 
 const char*
-tr_torrentGetFolder( const tr_torrent_t * tor )
+tr_torrentGetFolder( const tr_torrent * tor )
 {
     return tor->destination;
@@ -596 +669 @@
 
 void
-tr_torrentChangeMyPort( tr_torrent_t * tor, int port )
-{
-    tr_torrentWriterLock( tor );
+tr_torrentChangeMyPort( tr_torrent * tor, int port )
+{
+    tr_torrentLock( tor );
 
     tor->publicPort = port;
@@ -605 +678 @@
         tr_trackerChangeMyPort( tor->tracker );
 
-    tr_torrentWriterUnlock( tor );
-}
-
-/***********************************************************************
- * torrentReallyStop
- ***********************************************************************
- * Joins the download thread and frees/closes everything related to it.
- **********************************************************************/
-
-void tr_torrentDisablePex( tr_torrent_t * tor, int disable )
-{
-    tr_torrentWriterLock( tor );
-
-    if( ! ( TR_FLAG_PRIVATE & tor->info.flags ) )
-    {
-        if( tor->pexDisabled != disable )
-        {
-            int i;
-            tor->pexDisabled = disable;
-            for( i=0; i<tor->peerCount; ++i )
-                tr_peerSetPrivate( tor->peers[i], disable );
-        }
-    }
-
-    tr_torrentWriterUnlock( tor );
-}
-
-static int tr_didStateChangeTo ( tr_torrent_t * tor, int status )
+    tr_torrentUnlock( tor );
+}
+
+
+void
+tr_torrentDisablePex( tr_torrent * tor, int disable )
+{
+    assert( tor != NULL );
+    assert( disable==0 || disable==1 );
+    //assert( tor->runStatus != TR_RUN_RUNNING );
+
+    /* pex is ALWAYS disabled for private torrents */
+    if( tor->info.flags & TR_FLAG_PRIVATE )
+        disable = TRUE;
+
+    tor->pexDisabled = disable;
+}
+
+static int tr_didStateChangeTo ( tr_torrent * tor, int status )
 {
     int ret;
 
-    tr_torrentWriterLock( tor );
+    tr_torrentLock( tor );
     if (( ret = tor->hasChangedState == status ))
         tor->hasChangedState = -1;
-    tr_torrentWriterUnlock( tor );
+    tr_torrentUnlock( tor );
 
     return ret;
 }
 
-int tr_getIncomplete( tr_torrent_t * tor )
+int tr_getIncomplete( tr_torrent * tor )
 {
     return tr_didStateChangeTo( tor, TR_CP_INCOMPLETE );
 }
-int tr_getDone( tr_torrent_t * tor )
+int tr_getDone( tr_torrent * tor )
 {
     return tr_didStateChangeTo( tor, TR_CP_DONE );
 }
-int tr_getComplete( tr_torrent_t * tor )
+int tr_getComplete( tr_torrent * tor )
 {
     return tr_didStateChangeTo( tor, TR_CP_COMPLETE );
@@ -658 +722 @@
 
 void
-tr_manualUpdate( tr_torrent_t * tor )
+tr_manualUpdate( tr_torrent * tor )
 {
     if( tor->runStatus == TR_RUN_RUNNING )
-        tr_trackerReannounce( tor->tracker );
+    tr_trackerReannounce( tor->tracker );
 }
 int
-tr_torrentCanManualUpdate( const tr_torrent_t * tor )
+tr_torrentCanManualUpdate( const tr_torrent * tor )
 {
     return ( tor != NULL )
@@ -671 +735 @@
 }
 
-const tr_stat_t *
-tr_torrentStat( tr_torrent_t * tor )
-{
-    tr_stat_t * s;
-    struct tr_tracker_s * tc;
-    int i;
-
-    tr_torrentReaderLock( tor );
+const tr_stat *
+tr_torrentStat( tr_torrent * tor )
+{
+    tr_stat * s;
+    struct tr_tracker * tc;
+
+    tr_torrentLock( tor );
 
     tor->statCur = ( tor->statCur + 1 ) % 2;
@@ -690 +753 @@
     s->tracker = tr_trackerGetAddress( tor->tracker );
 
-    /* peers... */
-    memset( s->peersFrom, 0, sizeof( s->peersFrom ) );
-    s->peersTotal          = tor->peerCount;
-    s->peersConnected      = 0;
-    s->peersSendingToUs    = 0;
-    s->peersGettingFromUs  = 0;
-
-    for( i=0; i<tor->peerCount; ++i )
-    {
-        const tr_peer_t * peer = tor->peers[i];
-
-        if( tr_peerIsConnected( peer ) )
-        {
-            ++s->peersConnected;
-            ++s->peersFrom[tr_peerIsFrom(peer)];
-
-            if( tr_peerDownloadRate( peer ) > 0.01 )
-                ++s->peersSendingToUs;
-
-            if( tr_peerUploadRate( peer ) > 0.01 )
-                ++s->peersGettingFromUs;
-        }
-    }
+    tr_peerMgrTorrentStats( tor->handle->peerMgr,
+                            tor->info.hash,
+                            &s->peersTotal,
+                            &s->peersConnected,
+                            &s->peersSendingToUs,
+                            &s->peersGettingFromUs,
+                             s->peersFrom );
 
     s->percentComplete = tr_cpPercentComplete ( tor->completion );
@@ -719 +766 @@
     s->left = tr_cpLeftUntilDone( tor->completion );
 
-    if( tor->uncheckedPieces )
-        s->status = tor->runStatus==TR_RUN_CHECKING
-            ? TR_STATUS_CHECK
-            : TR_STATUS_CHECK_WAIT;
-    else switch( tor->runStatus ) {
-        case TR_RUN_STOPPING: /* fallthrough */
-        case TR_RUN_STOPPING_NET_WAIT: s->status = TR_STATUS_STOPPING; break;
+    switch( tor->runStatus ) {
+        case TR_RUN_CHECKING_WAIT: s->status = TR_STATUS_CHECK_WAIT; break;
+        case TR_RUN_CHECKING: s->status = TR_STATUS_CHECK; break;
+        case TR_RUN_STOPPING: s->status = TR_STATUS_STOPPING; break;
         case TR_RUN_STOPPED: s->status = TR_STATUS_STOPPED; break;
-        case TR_RUN_CHECKING: s->status = TR_STATUS_CHECK; break;
         case TR_RUN_RUNNING: switch( tor->cpStatus ) {
             case TR_CP_INCOMPLETE: s->status = TR_STATUS_DOWNLOAD; break;
@@ -773 +816 @@
       : TR_RATIO_NA; 
     
-    tr_torrentReaderUnlock( tor );
+    tr_torrentUnlock( tor );
 
     return s;
@@ -783 +826 @@
 
 static uint64_t
-fileBytesCompleted ( const tr_torrent_t * tor, int fileIndex )
-{
-    const tr_file_t * file     =  &tor->info.files[fileIndex];
+fileBytesCompleted ( const tr_torrent * tor, int fileIndex )
+{
+    const tr_file * file     =  &tor->info.files[fileIndex];
     const uint64_t firstBlock       =  file->offset / tor->blockSize;
     const uint64_t firstBlockOffset =  file->offset % tor->blockSize;
@@ -825 +868 @@
 }
 
-tr_file_stat_t *
-tr_torrentFiles( const tr_torrent_t * tor, int * fileCount )
+tr_file_stat *
+tr_torrentFiles( const tr_torrent * tor, int * fileCount )
 {
     int i;
     const int n = tor->info.fileCount;
-    tr_file_stat_t * files = tr_new0( tr_file_stat_t, n );
-    tr_file_stat_t * walk = files;
+    tr_file_stat * files = tr_new0( tr_file_stat, n );
+    tr_file_stat * walk = files;
 
     for( i=0; i<n; ++i, ++walk )
     {
-        const tr_file_t * file = tor->info.files + i;
+        const tr_file * file = tor->info.files + i;
         cp_status_t cp;
 
@@ -860 +903 @@
 
 void
-tr_torrentFilesFree( tr_file_stat_t * files, int fileCount UNUSED )
+tr_torrentFilesFree( tr_file_stat * files, int fileCount UNUSED )
 {
     tr_free( files );
@@ -869 +912 @@
 ***/
 
-tr_peer_stat_t *
-tr_torrentPeers( const tr_torrent_t * tor, int * peerCount )
-{
-    tr_peer_stat_t * peers;
-
-    tr_torrentReaderLock( tor );
-
-    *peerCount = tor->peerCount;
-   
-    peers = tr_new0( tr_peer_stat_t, tor->peerCount ); 
-    if (peers != NULL)
-    {
-        tr_peer_t * peer;
-        struct in_addr * addr;
-        int i;
-        for( i=0; i<tor->peerCount; ++i )
-        {
-            peer = tor->peers[i];
-            
-            addr = tr_peerAddress( peer );
-            if( NULL != addr )
-            {
-                tr_netNtop( addr, peers[i].addr,
-                           sizeof( peers[i].addr ) );
-            }
-            
-            peers[i].client           =  tr_peerClient( peer );
-            peers[i].isConnected      =  tr_peerIsConnected( peer );
-            peers[i].from             =  tr_peerIsFrom( peer );
-            peers[i].progress         =  tr_peerProgress( peer );
-            peers[i].port             =  tr_peerPort( peer );
-
-            peers[i].uploadToRate     =  tr_peerUploadRate( peer );
-            peers[i].downloadFromRate =  tr_peerDownloadRate( peer );
-            
-            peers[i].isDownloading    =  peers[i].uploadToRate > 0.01;
-            peers[i].isUploading      =  peers[i].downloadFromRate > 0.01;
-        }
-    }
-    
-    tr_torrentReaderUnlock( tor );
-    
-    return peers;
-}
-
-void tr_torrentPeersFree( tr_peer_stat_t * peers, int peerCount UNUSED )
+tr_peer_stat *
+tr_torrentPeers( const tr_torrent * tor, int * peerCount )
+{
+    return tr_peerMgrPeerStats( tor->handle->peerMgr,
+                                tor->info.hash, peerCount );
+}
+
+void tr_torrentPeersFree( tr_peer_stat * peers, int peerCount UNUSED )
 {
     tr_free( peers );
 }
 
-void tr_torrentAvailability( const tr_torrent_t * tor, int8_t * tab, int size )
-{
-    int i, j, piece;
-    float interval;
-
-    tr_torrentReaderLock( tor );
-
-    interval = (float)tor->info.pieceCount / (float)size;
-    for( i = 0; i < size; i++ )
-    {
-        piece = i * interval;
-
-        if( tr_cpPieceIsComplete( tor->completion, piece ) )
-        {
-            tab[i] = -1;
-            continue;
-        }
-
-        tab[i] = 0;
-        for( j = 0; j < tor->peerCount; j++ )
-        {
-            if( tr_peerHasPiece( tor->peers[j], piece ) )
-            {
-                (tab[i])++;
-            }
-        }
-    }
-
-    tr_torrentReaderUnlock( tor );
-}
-
-void tr_torrentAmountFinished( const tr_torrent_t * tor, float * tab, int size )
+void tr_torrentAvailability( const tr_torrent * tor, int8_t * tab, int size )
+{
+    return tr_peerMgrTorrentAvailability( tor->handle->peerMgr,
+                                          tor->info.hash,
+                                          tab, size );
+}
+
+void tr_torrentAmountFinished( const tr_torrent * tor, float * tab, int size )
 {
     int i;
     float interval;
-    tr_torrentReaderLock( tor );
+    tr_torrentLock( tor );
 
     interval = (float)tor->info.pieceCount / (float)size;
@@ -963 +944 @@
     }
 
-    tr_torrentReaderUnlock( tor );
-}
-
-void
-tr_torrentResetTransferStats( tr_torrent_t * tor )
-{
-    tr_torrentWriterLock( tor );
+    tr_torrentUnlock( tor );
+}
+
+void
+tr_torrentResetTransferStats( tr_torrent * tor )
+{
+    tr_torrentLock( tor );
 
     tor->downloadedPrev += tor->downloadedCur;
@@ -978 +959 @@
     tor->corruptCur      = 0;
 
-    tr_torrentWriterUnlock( tor );
-}
-
-
-void
-tr_torrentSetHasPiece( tr_torrent_t * tor, int pieceIndex, int has )
-{
-    tr_torrentWriterLock( tor );
+    tr_torrentUnlock( tor );
+}
+
+
+void
+tr_torrentSetHasPiece( tr_torrent * tor, int pieceIndex, int has )
+{
+    tr_torrentLock( tor );
 
     if( has )
@@ -992 +973 @@
         tr_cpPieceRem( tor->completion, pieceIndex );
 
-    tr_torrentWriterUnlock( tor );
-}
-
-void tr_torrentRemoveSaved( tr_torrent_t * tor )
+    tr_torrentUnlock( tor );
+}
+
+void tr_torrentRemoveSaved( tr_torrent * tor )
 {
     tr_metainfoRemoveSaved( tor->info.hashString, tor->handle->tag );
 }
 
-void tr_torrentRecheck( tr_torrent_t * tor )
+void tr_torrentRecheck( tr_torrent * tor )
 {
     if( !tor->uncheckedPieces )
         tor->uncheckedPieces = tr_bitfieldNew( tor->info.pieceCount );
     tr_bitfieldAddRange( tor->uncheckedPieces, 0, tor->info.pieceCount );
-}
-
-
-int tr_torrentAttachPeer( tr_torrent_t * tor, tr_peer_t * peer )
-{
-    int i;
-    tr_peer_t * otherPeer;
-
-    assert( tor != NULL );
-    assert( peer != NULL );
-
-    if( tor->peerCount >= TR_MAX_PEER_COUNT )
-    {
-        tr_peerDestroy(  peer );
-        return 0;
-    }
-
-    /* Don't accept two connections from the same IP */
-    for( i = 0; i < tor->peerCount; i++ )
-    {
-        otherPeer = tor->peers[i];
-        if( !memcmp( tr_peerAddress( peer ), tr_peerAddress( otherPeer ), 4 ) )
-        {
-            tr_peerDestroy(  peer );
-            return 0;
-        }
-    }
-
-    tr_peerSetPrivate( peer, tor->info.flags & TR_FLAG_PRIVATE ||
-                       tor->pexDisabled );
-    tr_peerSetTorrent( peer, tor );
-    tor->peers[tor->peerCount++] = peer;
-
-    return 1;
-}
-
-int tr_torrentAddCompact( tr_torrent_t * tor, int from,
-                           const uint8_t * buf, int count )
-{
-    struct in_addr addr;
-    tr_port_t port;
-    int i, added;
-    tr_peer_t * peer;
-
-    added = 0;
-    for( i=0; i<count; ++i )
-    {
-        memcpy( &addr, buf, 4 ); buf += 4;
-        memcpy( &port, buf, 2 ); buf += 2;
-        peer = tr_peerInit( &addr, port, -1, from );
-        added += tr_torrentAttachPeer( tor, peer );
-    }
-
-    return added;
+
+    tr_ioRecheckAdd( tor, recheckDoneCB, tor->runStatus );
 }
 
@@ -1065 +994 @@
 ***/
 
-static void setRunState( tr_torrent_t * tor, run_status_t run )
-{
-    tr_torrentWriterLock( tor );
-    tor->runStatus = run;
-    tr_torrentWriterUnlock( tor );
-}
-
-void tr_torrentStart( tr_torrent_t * tor )
-{
-    setRunState( tor, TR_RUN_RUNNING );
-
-    tr_trackerStart( tor->tracker );
-}
-
-void tr_torrentStop( tr_torrent_t * tor )
-{
-    if((tor->runStatus != TR_RUN_STOPPING) && (tor->runStatus != TR_RUN_STOPPED) )
-        setRunState( tor, TR_RUN_STOPPING );
-}
-
-void tr_torrentClose( tr_torrent_t * tor )
-{
-    tor->runStatusToSave = tor->runStatus;
-    tor->runStatusToSaveIsSet = TRUE;
-    tr_torrentStop( tor );
-    tor->dieFlag = TRUE;
+void
+tr_torrentStart( tr_torrent * tor )
+{
+    tr_ioRecheckAdd( tor, recheckDoneCB, TR_RUN_RUNNING );
 }
 
 static void
-tr_torrentFree( tr_torrent_t * tor )
-{
-    tr_torrent_t * t;
+tr_torrentFree( tr_torrent * tor )
+{
+    tr_torrent * t;
     tr_handle_t * h = tor->handle;
-    tr_info_t * inf = &tor->info;
+    tr_info * inf = &tor->info;
+fprintf( stderr, "closing torrent %s\n", tor->info.name );
+
+    assert( tor != NULL );
+    assert( tor->runStatus == TR_RUN_STOPPED );
 
     tr_sharedLock( h->shared );
 
-    tr_rwFree( tor->lock );
+    tr_lockFree( tor->lock );
     tr_cpClose( tor->completion );
 
@@ -1114 +1025 @@
 
     tr_free( tor->destination );
-
-    tr_metainfoFree( inf );
 
     if( tor == h->torrentList )
@@ -1126 +1035 @@
     }
 
+    assert( h->torrentCount >= 1 );
     h->torrentCount--;
 
@@ -1131 +1041 @@
             tor->info.name, h->torrentCount );
 
+    tr_peerMgrRemoveTorrent( h->peerMgr, tor->info.hash );
+
+    tr_metainfoFree( inf );
     tr_free( tor );
 
@@ -1136 +1049 @@
 }
 
+static int
+freeWhenStopped( void * vtor )
+{
+    tr_torrent * tor = vtor;
+
+    if( tor->runStatus != TR_RUN_STOPPED ) /* keep waiting */
+        return TRUE;
+
+    tr_torrentFree( tor );
+    return FALSE;
+}
+
 static void
-recheckCpState( tr_torrent_t * tor )
+tr_torrentStopImpl( void * vtor )
+{
+    tr_torrent * tor = vtor;
+
+    switch( tor->runStatus )
+    {
+        case TR_RUN_CHECKING_WAIT:
+        case TR_RUN_CHECKING:
+            tr_ioRecheckRemove( tor );
+            tr_torrentStop( tor );
+            break;
+
+        case TR_RUN_RUNNING:
+            saveFastResumeNow( tor );
+            tr_peerMgrStopTorrent( tor->handle->peerMgr, tor->info.hash );
+            tor->runStatus = TR_RUN_STOPPING;
+            tor->stopDate = tr_date( );
+            tr_trackerStop( tor->tracker );
+            tr_ioClose( tor );
+            break;
+
+        case TR_RUN_STOPPING:
+        case TR_RUN_STOPPED:
+            break;
+    }
+}
+
+void
+tr_torrentStop( tr_torrent * tor )
+{
+    tr_runInEventThread( tor->handle, tr_torrentStopImpl, tor );
+}
+
+void
+tr_torrentClose( tr_torrent * tor )
+{
+    tor->runStatusToSave = tor->runStatus;
+    tor->runStatusToSaveIsSet = TRUE;
+    tor->dieFlag = TRUE;
+    tr_torrentStop( tor );
+    tr_timerNew( tor->handle, freeWhenStopped, tor, 250 );
+}
+
+static void
+recheckCpState( tr_torrent * tor )
 {
     cp_status_t cpStatus;
 
-    tr_torrentWriterLock( tor );
+    tr_torrentLock( tor );
 
     cpStatus = tr_cpGetStatus( tor->completion );
@@ -1151 +1120 @@
             tr_trackerCompleted( tor->tracker ); /* tell the tracker */
         }
-        tr_ioSync( tor->io );
-        fastResumeSave( tor );
-    }
-    tr_torrentWriterUnlock( tor );
-}
-
-static void
-torrentThreadLoop ( void * _tor )
-{
-    static tr_lock_t * checkFilesLock = NULL;
-    tr_torrent_t * tor = _tor;
-
-    /* create the check-files mutex */
-    if( !checkFilesLock )
-         checkFilesLock = tr_lockNew( );
-
-    /* loop until the torrent is being deleted */
-    while( ! ( tor->dieFlag && (tor->runStatus == TR_RUN_STOPPED) ) )
-    {
-        /* sleep a little while */
-        tr_wait( tor->runStatus == TR_RUN_STOPPED ? 1600 : 600 );
-
-        if( tor->fastResumeDirty )
-        {
-            fastResumeSave( tor );
-            recheckCpState( tor );
-        }
-
-        /* if we're stopping... */
-        if( tor->runStatus == TR_RUN_STOPPING )
-        {
-            int i;
-            tr_torrentWriterLock( tor );
-
-            /* close the IO */
-            tr_ioClose( tor->io );
-            tor->io = NULL;
-            fastResumeSave( tor );
-
-            /* close the peers */
-            for( i=0; i<tor->peerCount; ++i )
-                tr_peerDestroy( tor->peers[i] );
-            tor->peerCount = 0;
-
-            /* resest the transfer rates */
-            tr_rcReset( tor->download );
-            tr_rcReset( tor->upload );
-            tr_rcReset( tor->swarmspeed );
-
-            /* tell the tracker we're stopping */
-            tr_trackerStop( tor->tracker );
-            tor->runStatus = TR_RUN_STOPPING_NET_WAIT;
-            tor->stopDate = tr_date();
-            tr_torrentWriterUnlock( tor );
-        }
-
-        if( tor->runStatus == TR_RUN_STOPPING_NET_WAIT )
-        {
-#if 0
-            tr_torrentWriterLock( tor );
-            tor->runStatus = TR_RUN_STOPPED;
-            tr_torrentWriterUnlock( tor );
-#endif
-            continue;
-        }
-
-        /* do we need to check files? */
-        if( tor->uncheckedPieces )
-        {
-            if( !tr_lockTryLock( checkFilesLock ) )
-            {
-                run_status_t realStatus;
-
-                tr_torrentWriterLock( tor );
-                realStatus = tor->runStatus;
-                tor->runStatus = TR_RUN_CHECKING;
-                tr_torrentWriterUnlock( tor );
-
-                tr_ioCheckFiles( tor );
-                setRunState( tor, realStatus );
-
-                tr_torrentWriterLock( tor );
-                tor->cpStatus = tr_cpGetStatus( tor->completion );
-                tr_torrentWriterUnlock( tor );
-
-                tr_lockUnlock( checkFilesLock );
-            }
-            continue;
-        }
-
-        /* if we're paused or stopped, not much to do... */
-        if( tor->runStatus == TR_RUN_STOPPED )
-            continue;
-
-        /* ping our peers if we're running... */
-        if( tor->runStatus == TR_RUN_RUNNING )
-        {
-            int i;
-
-            /* starting to run... */
-            if( tor->io == NULL )
-            {
-                *tor->errorString = '\0';
-                tr_torrentResetTransferStats( tor );
-                tor->io = tr_ioNew( tor );
-                tor->startDate = tr_date();
-            }
-
-            /* refresh our completion state */
-            recheckCpState( tor );
-
-            /* Shuffle peers */
-            if ( tor->peerCount > 1 ) {
-                tr_peer_t * tmp = tor->peers[0];
-                memmove( tor->peers, tor->peers+1,
-                        (tor->peerCount-1) * sizeof(void*) );
-                tor->peers[tor->peerCount - 1] = tmp;
-            }
-
-            /* receive/send messages */
-            tr_torrentWriterLock( tor );
-            for( i=0; i<tor->peerCount; ) {
-                tr_peer_t * peer = tor->peers[i];
-                int ret = tr_peerPulse( peer );
-                if( ret & TR_ERROR_IO_MASK ) {
-                    tr_err( "Fatal error, stopping download (%d)", ret );
-                    tor->runStatus = TR_RUN_STOPPING;
-                    tor->error = ret;
-                    strlcpy( tor->errorString,
-                             tr_errorString(ret),
-                             sizeof(tor->errorString) );
-                    break;
-                }
-                if( ret ) {
-                    tr_peerDestroy( peer );
-                    tor->peerCount--;
-                    memmove( &tor->peers[i], &tor->peers[i+1],
-                             (tor->peerCount-i)*sizeof(void*) );
-                    continue;
-                }
-                i++;
-            }
-            tr_torrentWriterUnlock( tor );
-        }
-    }
-
-    tr_ioClose( tor->io );
-    tr_torrentFree( tor );
-}
-
+        tr_ioClose( tor );
+        saveFastResumeSoon( tor );
+    }
+    tr_torrentUnlock( tor );
+}
 
 /**
@@ -1307 +1131 @@
 
 void
-tr_torrentSetFilePriority( tr_torrent_t   * tor,
-                           int              fileIndex,
-                           tr_priority_t    priority )
+tr_torrentSetFilePriority( tr_torrent   * tor,
+                           int            fileIndex,
+                           tr_priority_t  priority )
 {
     int i;
-    tr_file_t * file;
-
-    tr_torrentWriterLock( tor );
+    tr_file * file;
+
+    tr_torrentLock( tor );
 
     assert( tor != NULL );
@@ -1329 +1153 @@
              priority, tor->info.files[fileIndex].name );
 
-    tor->fastResumeDirty = TRUE;
-
-    tr_torrentWriterUnlock( tor );
-}
-
-void
-tr_torrentSetFilePriorities( tr_torrent_t        * tor,
-                             int                 * files,
-                             int                   fileCount,
-                             tr_priority_t         priority )
+    saveFastResumeSoon( tor );
+
+    tr_torrentUnlock( tor );
+}
+
+void
+tr_torrentSetFilePriorities( tr_torrent     * tor,
+                             int            * files,
+                             int              fileCount,
+                             tr_priority_t    priority )
 {
     int i;
@@ -1346 +1170 @@
 
 tr_priority_t
-tr_torrentGetFilePriority( const tr_torrent_t *  tor, int file )
+tr_torrentGetFilePriority( const tr_torrent *  tor, int file )
 {
     tr_priority_t ret;
 
-    tr_torrentReaderLock( tor );
+    tr_torrentLock( tor );
     assert( tor != NULL );
     assert( 0<=file && file<tor->info.fileCount );
     ret = tor->info.files[file].priority;
-    tr_torrentReaderUnlock( tor );
+    tr_torrentUnlock( tor );
 
     return ret;
@@ -1361 +1185 @@
 
 tr_priority_t*
-tr_torrentGetFilePriorities( const tr_torrent_t * tor )
+tr_torrentGetFilePriorities( const tr_torrent * tor )
 {
     int i;
     tr_priority_t * p;
 
-    tr_torrentReaderLock( tor );
+    tr_torrentLock( tor );
     p = tr_new0( tr_priority_t, tor->info.fileCount );
     for( i=0; i<tor->info.fileCount; ++i )
         p[i] = tor->info.files[i].priority;
-    tr_torrentReaderUnlock( tor );
+    tr_torrentUnlock( tor );
 
     return p;
@@ -1380 +1204 @@
 
 int
-tr_torrentGetFileDL( const tr_torrent_t * tor,
-                     int                  file )
+tr_torrentGetFileDL( const tr_torrent * tor,
+                     int                file )
 {
     int doDownload;
-    tr_torrentReaderLock( tor );
+    tr_torrentLock( tor );
 
     assert( 0<=file && file<tor->info.fileCount );
     doDownload = !tor->info.files[file].dnd;