Changeset 137

Timestamp:

Mar 8, 2006, 9:28:09 PM (16 years ago)

Author:

titer

Message:

Adds a permanent handle for every torrent.
Removed the limit on the number of open torrents.

Location:

branches/new_api

Files:

• libtransmission/choking.c (modified) (4 diffs)
• libtransmission/internal.h (modified) (5 diffs)
• libtransmission/tracker.c (modified) (3 diffs)
• libtransmission/tracker.h (modified) (1 diff)
• libtransmission/transmission.c (modified) (14 diffs)
• libtransmission/transmission.h (modified) (8 diffs)
• transmissioncli.c (modified) (9 diffs)

branches/new_api/libtransmission/choking.c

@@ -139 +139 @@
 void tr_chokingPulse( tr_choking_t * c )
 {
-    int i, peersTotalCount, unchoked, mustOptimistic = 1;
+    int peersTotalCount, unchoked, mustOptimistic = 1;
     tr_peer_t ** canChoke, ** canUnchoke;
     tr_peer_t ** canChokeZero, ** canUnchokeZero;
@@ -153 +153 @@
     /* Lock all torrents and get the total number of peers */
     peersTotalCount = 0;
-    for( i = 0; i < c->h->torrentCount; i++ )
-    {
-        tor = c->h->torrents[i];
+    for( tor = c->h->torrentList; tor; tor = tor->next )
+    {
         tr_lockLock( &tor->lock );
         peersTotalCount += tor->peerCount;
@@ -166 +165 @@
     unchoked        = 0;
 
-    for( i = 0; i < c->h->torrentCount; i++ )
+    for( tor = c->h->torrentList; tor; tor = tor->next )
     {
         tr_peer_t * peer;
-        int j;
-
-        tor = c->h->torrents[i];
-        for( j = 0; j < tor->peerCount; j++ )
+        int i;
+
+        for( i = 0; i < tor->peerCount; i++ )
         {
-            peer = tor->peers[j];
+            peer = tor->peers[i];
 
             if( !tr_peerIsConnected( peer ) )
@@ -321 +319 @@
 
     /* Unlock all torrents */
-    for( i = 0; i < c->h->torrentCount; i++ )
-    {
-        tr_lockUnlock( &c->h->torrents[i]->lock );
+    for( tor = c->h->torrentList; tor; tor = tor->next )
+    {
+        tr_lockUnlock( &tor->lock );
     }
 

branches/new_api/libtransmission/internal.h

@@ -1 +1 @@
 /******************************************************************************
- * Copyright (c) 2005 Eric Petit
+ * Copyright (c) 2005-2006 Transmission authors and contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -83 +83 @@
 #define TR_MAX_PEER_COUNT 60
 
-typedef struct tr_torrent_s tr_torrent_t;
 typedef struct tr_completion_s tr_completion_t;
 
@@ -127 +126 @@
     int               blockCount;
     
-#if 0
-    /* Status for each block
-       -1 = we have it
-        n = we are downloading it from n peers */
-    char            * blockHave;
-    int               blockHaveCount;
-    uint8_t         * bitfield;
-#endif
     tr_completion_t * completion;
 
@@ -151 +142 @@
     uint64_t          downloaded;
     uint64_t          uploaded;
+
+    tr_stat_t         stats[2];
+    int               statCur;
+
+    tr_torrent_t    * prev;
+    tr_torrent_t    * next;
 };
 
@@ -159 +156 @@
 {
     int            torrentCount;
-    tr_torrent_t * torrents[TR_MAX_TORRENT_COUNT];
+    tr_torrent_t * torrentList;
 
     tr_ratecontrol_t * upload;

branches/new_api/libtransmission/tracker.c

@@ -58 +58 @@
 static void recvAnswer ( tr_tracker_t * tc );
 
-tr_tracker_t * tr_trackerInit( tr_handle_t * h, tr_torrent_t * tor )
+tr_tracker_t * tr_trackerInit( tr_torrent_t * tor )
 {
     tr_tracker_t * tc;
@@ -64 +64 @@
     tc           = calloc( 1, sizeof( tr_tracker_t ) );
     tc->tor      = tor;
-    tc->id       = h->id;
+    tc->id       = tor->id;
 
     tc->started  = 1;
@@ -75 +75 @@
     tc->buf      = malloc( tc->size );
 
-    tc->bindPort = h->bindPort;
+    //tc->bindPort = h->bindPort;
+    tc->bindPort = 9090; /*FIXME*/
     tc->newPort  = -1;
 

branches/new_api/libtransmission/tracker.h

@@ -26 +26 @@
 typedef struct tr_tracker_s tr_tracker_t;
 
-tr_tracker_t * tr_trackerInit      ( tr_handle_t *, tr_torrent_t * );
+tr_tracker_t * tr_trackerInit      ( tr_torrent_t * );
 void           tr_trackerChangePort( tr_tracker_t *, int );
 int            tr_trackerPulse     ( tr_tracker_t * );

branches/new_api/libtransmission/transmission.c

@@ -26 +26 @@
  * Local prototypes
  **********************************************************************/
-static void torrentReallyStop( tr_handle_t * h, int t );
+static void torrentReallyStop( tr_torrent_t * );
 static void  downloadLoop( void * );
 static void  acceptLoop( void * );
@@ -86 +86 @@
 void tr_setBindPort( tr_handle_t * h, int port )
 {
-    int ii, sock;
+    int sock;
+    tr_torrent_t * tor;
 
     if( h->bindPort == port )
@@ -107 +108 @@
     h->bindPort = port;
 
-    for( ii = 0; ii < h->torrentCount; ii++ )
-    {
-        tr_lockLock( &h->torrents[ii]->lock );
-        if( NULL != h->torrents[ii]->tracker )
-        {
-            tr_trackerChangePort( h->torrents[ii]->tracker, port );
-        }
-        tr_lockUnlock( &h->torrents[ii]->lock );
+    for( tor = h->torrentList; tor; tor = tor->next )
+    {
+        tr_lockLock( &tor->lock );
+        if( NULL != tor->tracker )
+        {
+            tr_trackerChangePort( tor->tracker, port );
+        }
+        tr_lockUnlock( &tor->lock );
     }
 
@@ -147 +148 @@
 {
     tr_torrent_t * tor;
-    int i;
 
     *dl = 0.0;
     *ul = 0.0;
-    for( i = 0; i < h->torrentCount; i++ )
-    {
-        tor = h->torrents[i];
+    for( tor = h->torrentList; tor; tor = tor->next )
+    {
         tr_lockLock( &tor->lock );
         if( tor->status & TR_STATUS_DOWNLOAD )
@@ -168 +167 @@
  * to fill it.
  **********************************************************************/
-int tr_torrentInit( tr_handle_t * h, const char * path )
-{
-    tr_torrent_t  * tor;
+tr_torrent_t * tr_torrentInit( tr_handle_t * h, const char * path )
+{
+    tr_torrent_t  * tor, * tor_tmp;
     tr_info_t     * inf;
     int             i;
     char          * s1, * s2;
 
-    if( h->torrentCount >= TR_MAX_TORRENT_COUNT )
-    {
-        tr_err( "Maximum number of torrents reached" );
-        return 1;
-    }
-
     tor = calloc( sizeof( tr_torrent_t ), 1 );
     inf = &tor->info;
@@ -188 +181 @@
     {
         free( tor );
-        return 1;
+        return NULL;
     }
 
     /* Make sure this torrent is not already open */
-    for( i = 0; i < h->torrentCount; i++ )
-    {
-        if( !memcmp( tor->info.hash, h->torrents[i]->info.hash,
+    for( tor_tmp = h->torrentList; tor_tmp; tor_tmp = tor_tmp->next )
+    {
+        if( !memcmp( tor->info.hash, tor_tmp->info.hash,
                      SHA_DIGEST_LENGTH ) )
         {
             tr_err( "Torrent already open" );
             free( tor );
-            return 1;
+            return NULL;
         }
     }
@@ -247 +240 @@
     /* We have a new torrent */
     tr_lockLock( &h->acceptLock );
-    h->torrents[h->torrentCount] = tor;
+    tor->prev = NULL;
+    tor->next = h->torrentList;
+    if( tor->next )
+    {
+        tor->next->prev = tor;
+    }
+    h->torrentList = tor;
     (h->torrentCount)++;
     tr_lockUnlock( &h->acceptLock );
 
-    return 0;
+    return tor;
 }
 
 /***********************************************************************
  * tr_torrentScrape
- ***********************************************************************
- * Allocates a tr_torrent_t structure, then relies on tr_metainfoParse
- * to fill it.
- **********************************************************************/
-int tr_torrentScrape( tr_handle_t * h, int t, int * s, int * l )
-{
-    return tr_trackerScrape( h->torrents[t], s, l );
-}
-
-void tr_torrentSetFolder( tr_handle_t * h, int t, const char * path )
-{
-    tr_torrent_t * tor = h->torrents[t];
-
+ **********************************************************************/
+int tr_torrentScrape( tr_torrent_t * tor, int * s, int * l )
+{
+    return tr_trackerScrape( tor, s, l );
+}
+
+void tr_torrentSetFolder( tr_torrent_t * tor, const char * path )
+{
     tor->destination = strdup( path );
 }
 
-char * tr_torrentGetFolder( tr_handle_t * h, int t )
-{
-    tr_torrent_t * tor = h->torrents[t];
-
+char * tr_torrentGetFolder( tr_torrent_t * tor )
+{
     return tor->destination;
 }
 
-void tr_torrentStart( tr_handle_t * h, int t )
-{
-    tr_torrent_t * tor = h->torrents[t];
-
+void tr_torrentStart( tr_torrent_t * tor )
+{
     if( tor->status & ( TR_STATUS_STOPPING | TR_STATUS_STOPPED ) )
     {
         /* Join the thread first */
-        torrentReallyStop( h, t );
-    }
-
-    tor->status   = TR_STATUS_CHECK;
-    tor->tracker  = tr_trackerInit( h, tor );
-
-    if( 0 > h->bindPort )
-    {
-        tr_setBindPort( h, TR_DEFAULT_PORT );
-    }
+        torrentReallyStop( tor );
+    }
+
+    tor->status  = TR_STATUS_CHECK;
+    tor->tracker = tr_trackerInit( tor );
 
     tor->date = tr_date();
@@ -302 +287 @@
 }
 
-void tr_torrentStop( tr_handle_t * h, int t )
-{
-    tr_torrent_t * tor = h->torrents[t];
-
+void tr_torrentStop( tr_torrent_t * tor )
+{
     tr_lockLock( &tor->lock );
     tr_trackerStopped( tor->tracker );
@@ -320 +303 @@
  * Joins the download thread and frees/closes everything related to it.
  **********************************************************************/
-static void torrentReallyStop( tr_handle_t * h, int t )
-{
-    tr_torrent_t * tor = h->torrents[t];
-
+static void torrentReallyStop( tr_torrent_t * tor )
+{
     tor->die = 1;
     tr_threadJoin( &tor->thread );
@@ -346 +327 @@
 }
 
-int tr_getFinished( tr_handle_t * h, int i)
-{
-        return h->torrents[i]->finished;
-}
-void tr_setFinished( tr_handle_t * h, int i, int val)
-{
-        h->torrents[i]->finished = val;
-}
-
-int tr_torrentStat( tr_handle_t * h, tr_stat_t ** stat )
+int tr_getFinished( tr_torrent_t * tor )
+{
+        return tor->finished;
+}
+void tr_setFinished( tr_torrent_t * tor, int val)
+{
+        tor->finished = val;
+}
+
+tr_stat_t * tr_torrentStat( tr_torrent_t * tor )
 {
     tr_stat_t * s;
-    tr_torrent_t * tor;
-    tr_info_t * inf;
-    int i, j, k, piece;
-
-    if( h->torrentCount < 1 )
-    {
-        *stat = NULL;
-        return 0;
-    }
-
-    s = malloc( h->torrentCount * sizeof( tr_stat_t ) );
-
-    for( i = 0; i < h->torrentCount; i++ )
-    {
-        tor = h->torrents[i];
-        inf = &tor->info;
-
-        if( ( tor->status & TR_STATUS_STOPPED ) ||
-            ( ( tor->status & TR_STATUS_STOPPING ) &&
-              tr_date() > tor->stopDate + 60000 ) )
-        {
-            torrentReallyStop( h, i );
-            tor->status = TR_STATUS_PAUSE;
-        }
-
-        tr_lockLock( &tor->lock );
-
-        memcpy( &s[i].info, &tor->info, sizeof( tr_info_t ) );
-        s[i].status = tor->status;
-        memcpy( s[i].error, tor->error, sizeof( s[i].error ) );
-
-        s[i].peersTotal       = 0;
-        s[i].peersUploading   = 0;
-        s[i].peersDownloading = 0;
-
+    tr_info_t * inf = &tor->info;
+    int i, j, piece;
+
+    tor->statCur = ( tor->statCur + 1 ) % 2;
+    s = &tor->stats[tor->statCur];
+
+    if( ( tor->status & TR_STATUS_STOPPED ) ||
+        ( ( tor->status & TR_STATUS_STOPPING ) &&
+          tr_date() > tor->stopDate + 60000 ) )
+    {
+        torrentReallyStop( tor );
+        tor->status = TR_STATUS_PAUSE;
+    }
+
+    tr_lockLock( &tor->lock );
+
+    memcpy( &s->info, &tor->info, sizeof( tr_info_t ) );
+    s->status = tor->status;
+    memcpy( s->error, tor->error, sizeof( s->error ) );
+
+    s->peersTotal       = 0;
+    s->peersUploading   = 0;
+    s->peersDownloading = 0;
+
+    for( i = 0; i < tor->peerCount; i++ )
+    {
+        if( tr_peerIsConnected( tor->peers[i] ) )
+        {
+            (s->peersTotal)++;
+            if( tr_peerIsUploading( tor->peers[i] ) )
+            {
+                (s->peersUploading)++;
+            }
+            if( tr_peerIsDownloading( tor->peers[i] ) )
+            {
+                (s->peersDownloading)++;
+            }
+        }
+    }
+
+    s->progress = tr_cpCompletionAsFloat( tor->completion );
+    if( tor->status & TR_STATUS_DOWNLOAD )
+        s->rateDownload = tr_rcRate( tor->download );
+    else
+        /* tr_rcRate() doesn't make the difference between 'piece'
+           messages and other messages, which causes a non-zero
+           download rate even tough we are not downloading. So we
+           force it to zero not to confuse the user. */
+        s->rateDownload = 0.0;
+    s->rateUpload = tr_rcRate( tor->upload );
+    
+    s->seeders    = tr_trackerSeeders(tor);
+        s->leechers       = tr_trackerLeechers(tor);
+
+    if( s->rateDownload < 0.1 )
+    {
+        s->eta = -1;
+    }
+    else
+    {
+        s->eta = (float) ( 1.0 - s->progress ) *
+            (float) inf->totalSize / s->rateDownload / 1024.0;
+        if( s->eta > 99 * 3600 + 59 * 60 + 59 )
+        {
+            s->eta = -1;
+        }
+    }
+
+    for( i = 0; i < 120; i++ )
+    {
+        piece = i * inf->pieceCount / 120;
+
+        if( tr_cpPieceIsComplete( tor->completion, piece ) )
+        {
+            s->pieces[i] = -1;
+            continue;
+        }
+
+        s->pieces[i] = 0;
+        
         for( j = 0; j < tor->peerCount; j++ )
         {
-            if( tr_peerIsConnected( tor->peers[j] ) )
-            {
-                (s[i].peersTotal)++;
-                if( tr_peerIsUploading( tor->peers[j] ) )
-                {
-                    (s[i].peersUploading)++;
-                }
-                if( tr_peerIsDownloading( tor->peers[j] ) )
-                {
-                    (s[i].peersDownloading)++;
-                }
-            }
-        }
-
-        s[i].progress     = tr_cpCompletionAsFloat( tor->completion );
-        if( tor->status & TR_STATUS_DOWNLOAD )
-            s[i].rateDownload = tr_rcRate( tor->download );
-        else
-            /* tr_rcRate() doesn't make the difference between 'piece'
-               messages and other messages, which causes a non-zero
-               download rate even tough we are not downloading. So we
-               force it to zero not to confuse the user. */
-            s[i].rateDownload = 0.0;
-        s[i].rateUpload = tr_rcRate( tor->upload );
-        
-        s[i].seeders      = tr_trackerSeeders(tor);
-                s[i].leechers     = tr_trackerLeechers(tor);
-
-        if( s[i].rateDownload < 0.1 )
-        {
-            s[i].eta = -1;
-        }
-        else
-        {
-            s[i].eta = (float) ( 1.0 - s[i].progress ) *
-                (float) inf->totalSize / s[i].rateDownload / 1024.0;
-            if( s[i].eta > 99 * 3600 + 59 * 60 + 59 )
-            {
-                s[i].eta = -1;
-            }
-        }
-
-        for( j = 0; j < 120; j++ )
-        {
-            piece = j * inf->pieceCount / 120;
-
-            if( tr_cpPieceIsComplete( tor->completion, piece ) )
-            {
-                s[i].pieces[j] = -1;
-                continue;
-            }
-
-            s[i].pieces[j] = 0;
-            
-            for( k = 0; k < tor->peerCount; k++ )
-            {
-                if( tr_peerBitfield( tor->peers[k] ) &&
-                    tr_bitfieldHas( tr_peerBitfield( tor->peers[k] ), piece ) )
-                {
-                    (s[i].pieces[j])++;
-                }
-            }
-        }
-
-        s[i].downloaded = tor->downloaded;
-        s[i].uploaded   = tor->uploaded;
-
-        s[i].folder = tor->destination;
-
-        tr_lockUnlock( &tor->lock );
-    }
-
-    *stat = s;
-    return h->torrentCount;
+            if( tr_peerBitfield( tor->peers[j] ) &&
+                tr_bitfieldHas( tr_peerBitfield( tor->peers[j] ), piece ) )
+            {
+                (s->pieces[i])++;
+            }
+        }
+    }
+
+    s->downloaded = tor->downloaded;
+    s->uploaded   = tor->uploaded;
+
+    s->folder = tor->destination;
+
+    tr_lockUnlock( &tor->lock );
+
+    return s;
 }
 
@@ -476 +444 @@
  * Frees memory allocated by tr_torrentInit.
  **********************************************************************/
-void tr_torrentClose( tr_handle_t * h, int t )
-{
-    tr_torrent_t * tor = h->torrents[t];
-    tr_info_t    * inf = &tor->info;
+void tr_torrentClose( tr_handle_t * h, tr_torrent_t * tor )
+{
+    tr_info_t * inf = &tor->info;
 
     if( tor->status & ( TR_STATUS_STOPPING | TR_STATUS_STOPPED ) )
     {
         /* Join the thread first */
-        torrentReallyStop( h, t );
+        torrentReallyStop( tor );
     }
 
@@ -503 +470 @@
     free( inf->pieces );
     free( inf->files );
+
+    if( tor->prev )
+    {
+        tor->prev->next = tor->next;
+    }
+    if( tor->next )
+    {
+        tor->next->prev = tor->prev;
+    }
     free( tor );
-
-    memmove( &h->torrents[t], &h->torrents[t+1],
-             ( h->torrentCount - t ) * sizeof( void * ) );
 
     tr_lockUnlock( &h->acceptLock );
@@ -596 +569 @@
     tr_handle_t * h = _h;
     uint64_t      date1, date2, lastchoke = 0;
-    int           ii, jj;
+    int           ii;
     uint8_t     * hash;
+    tr_torrent_t * tor;
 
     tr_dbg( "Accept thread started" );
@@ -641 +615 @@
             if( NULL != ( hash = tr_peerHash( h->acceptPeers[ii] ) ) )
             {
-                for( jj = 0; jj < h->torrentCount; jj++ )
+                for( tor = h->torrentList; tor; tor = tor->next )
                 {
-                    tr_lockLock( &h->torrents[jj]->lock );
-                    if( 0 == memcmp( h->torrents[jj]->info.hash, hash,
+                    tr_lockLock( &tor->lock );
+                    if( 0 == memcmp( tor->info.hash, hash,
                                      SHA_DIGEST_LENGTH ) )
                     {
-                      tr_peerAttach( h->torrents[jj], h->acceptPeers[ii] );
-                      tr_lockUnlock( &h->torrents[jj]->lock );
+                      tr_peerAttach( tor, h->acceptPeers[ii] );
+                      tr_lockUnlock( &tor->lock );
                       goto removePeer;
                     }
-                    tr_lockUnlock( &h->torrents[jj]->lock );
+                    tr_lockUnlock( &tor->lock );
                 }
                 tr_peerDestroy( h->fdlimit, h->acceptPeers[ii] );

branches/new_api/libtransmission/transmission.h

@@ -1 +1 @@
 /******************************************************************************
- * Copyright (c) 2005 Eric Petit
+ * Copyright (c) 2005-2006 Transmission authors and contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -37 +37 @@
 # define MAX_PATH_LENGTH      1024
 #endif
-#define TR_MAX_TORRENT_COUNT 50
 
 #define TR_DEFAULT_PORT      9090
@@ -83 +82 @@
 
 /***********************************************************************
- * tr_getFinished
- ***********************************************************************
- * Tests to see if torrent is finished
- **********************************************************************/
-int tr_getFinished( tr_handle_t *, int );
-
-/***********************************************************************
- * tr_setFinished
- ***********************************************************************
- * Sets the boolean value finished in the torrent back to false
- **********************************************************************/
-void tr_setFinished( tr_handle_t *, int, int );
-
-/***********************************************************************
  * tr_torrentInit
  ***********************************************************************
  * Opens and parses torrent file at 'path'. If the file exists and is a
- * valid torrent file, returns 0 and adds it to the list of torrents
- * (but doesn't start it). Returns a non-zero value otherwise.
- **********************************************************************/
-int tr_torrentInit( tr_handle_t *, const char * path );
+ * valid torrent file, returns an handle and adds it to the list of
+ * torrents (but doesn't start it). Returns NULL otherwise.
+ **********************************************************************/
+typedef struct tr_torrent_s tr_torrent_t;
+
+tr_torrent_t * tr_torrentInit( tr_handle_t *, const char * path );
 
 /***********************************************************************
@@ -114 +101 @@
  * before returning.
  **********************************************************************/
-int tr_torrentScrape( tr_handle_t *, int, int * s, int * l );
+int tr_torrentScrape( tr_torrent_t *, int * s, int * l );
 
 /***********************************************************************
@@ -122 +109 @@
  * therefore tr_torrentStart returns immediately.
  **********************************************************************/
-void   tr_torrentSetFolder( tr_handle_t *, int, const char * );
-char * tr_torrentGetFolder( tr_handle_t *, int );
-void   tr_torrentStart( tr_handle_t *, int );
+void   tr_torrentSetFolder( tr_torrent_t *, const char * );
+char * tr_torrentGetFolder( tr_torrent_t * );
+void   tr_torrentStart( tr_torrent_t * );
 
 /***********************************************************************
@@ -137 +124 @@
  *   waiting any further.
  **********************************************************************/
-void tr_torrentStop( tr_handle_t *, int );
+void tr_torrentStop( tr_torrent_t * );
+
+/***********************************************************************
+ * tr_getFinished
+ ***********************************************************************
+ * Tests to see if torrent is finished
+ **********************************************************************/
+int tr_getFinished( tr_torrent_t * );
+
+/***********************************************************************
+ * tr_setFinished
+ ***********************************************************************
+ * Sets the boolean value finished in the torrent back to false
+ **********************************************************************/
+void tr_setFinished( tr_torrent_t *, int );
+
+
 
 /***********************************************************************
@@ -154 +157 @@
 
 int tr_torrentCount( tr_handle_t * h );
-int tr_torrentStat( tr_handle_t *, tr_stat_t ** s );
+tr_stat_t * tr_torrentStat( tr_torrent_t * );
 
 /***********************************************************************
@@ -162 +165 @@
  * you must call tr_torrentStop() before closing it.
  **********************************************************************/
-void tr_torrentClose( tr_handle_t *, int );
+void tr_torrentClose( tr_handle_t *, tr_torrent_t * );
 
 /***********************************************************************

branches/new_api/transmissioncli.c

@@ -60 +60 @@
 int main( int argc, char ** argv )
 {
-    int           i, count;
-    tr_handle_t * h;
-    tr_stat_t   * s;
+    int i;
+    tr_handle_t  * h;
+    tr_torrent_t * tor;
+    tr_stat_t    * s;
 
     printf( "Transmission %s - http://transmission.m0k.org/\n\n",
@@ -105 +106 @@
 
     /* Open and parse torrent file */
-    if( tr_torrentInit( h, torrentPath ) )
+    if( !( tor = tr_torrentInit( h, torrentPath ) ) )
     {
         printf( "Failed opening torrent file `%s'\n", torrentPath );
@@ -115 +116 @@
         tr_info_t * info;
 
-        count = tr_torrentStat( h, &s );
-        info  = &s[0].info;
+        s = tr_torrentStat( tor );
+        info = &s->info;
 
         /* Print torrent info (quite à la btshowmetainfo) */
@@ -138 +139 @@
         }
 
-        free( s );
         goto cleanup;
     }
@@ -146 +146 @@
         int seeders, leechers;
 
-        if( tr_torrentScrape( h, 0, &seeders, &leechers ) )
+        if( tr_torrentScrape( tor, &seeders, &leechers ) )
         {
             printf( "Scrape failed.\n" );
@@ -163 +163 @@
     tr_setUploadLimit( h, uploadLimit );
     
-    tr_torrentSetFolder( h, 0, "." );
-    tr_torrentStart( h, 0 );
+    tr_torrentSetFolder( tor, "." );
+    tr_torrentStart( tor );
 
     while( !mustDie )
@@ -174 +174 @@
         sleep( 1 );
 
-        count = tr_torrentStat( h, &s );
-
-        if( s[0].status & TR_STATUS_CHECK )
+        s = tr_torrentStat( tor );
+
+        if( s->status & TR_STATUS_CHECK )
         {
             chars = snprintf( string, 80,
-                "Checking files... %.2f %%", 100.0 * s[0].progress );
-        }
-        else if( s[0].status & TR_STATUS_DOWNLOAD )
+                "Checking files... %.2f %%", 100.0 * s->progress );
+        }
+        else if( s->status & TR_STATUS_DOWNLOAD )
         {
             chars = snprintf( string, 80,
                 "Progress: %.2f %%, %d peer%s, dl from %d (%.2f KB/s), "
-                "ul to %d (%.2f KB/s)", 100.0 * s[0].progress,
-                s[0].peersTotal, ( s[0].peersTotal == 1 ) ? "" : "s",
-                s[0].peersUploading, s[0].rateDownload,
-                s[0].peersDownloading, s[0].rateUpload );
-        }
-        else if( s[0].status & TR_STATUS_SEED )
+                "ul to %d (%.2f KB/s)", 100.0 * s->progress,
+                s->peersTotal, ( s->peersTotal == 1 ) ? "" : "s",
+                s->peersUploading, s->rateDownload,
+                s->peersDownloading, s->rateUpload );
+        }
+        else if( s->status & TR_STATUS_SEED )
         {
             chars = snprintf( string, 80,
                 "Seeding, uploading to %d of %d peer(s), %.2f KB/s",
-                s[0].peersDownloading, s[0].peersTotal,
-                s[0].rateUpload );
+                s->peersDownloading, s->peersTotal,
+                s->rateUpload );
         }
         memset( &string[chars], ' ', 79 - chars );
@@ -201 +201 @@
         fprintf( stderr, "\r%s", string );
 
-        if( s[0].status & TR_TRACKER_ERROR )
-        {
-            fprintf( stderr, "\n%s\n", s[0].error );
+        if( s->status & TR_TRACKER_ERROR )
+        {
+            fprintf( stderr, "\n%s\n", s->error );
         }
         else if( verboseLevel > 0 )
@@ -210 +210 @@
         }
         
-        if( tr_getFinished( h, 0 ) )
-        {
-            tr_setFinished( h, 0, 0 );
+        if( tr_getFinished( tor ) )
+        {
+            tr_setFinished( tor, 0 );
             result = system(finishCall);
         }
-
-        free( s );
     }
     fprintf( stderr, "\n" );
 
     /* Try for 5 seconds to notice the tracker that we are leaving */
-    tr_torrentStop( h, 0 );
+    tr_torrentStop( tor );
     for( i = 0; i < 10; i++ )
     {
-        count = tr_torrentStat( h, &s );
-        if( s[0].status & TR_STATUS_PAUSE )
+        s = tr_torrentStat( tor );
+        if( s->status & TR_STATUS_PAUSE )
         {
             /* The 'stopped' message was sent */
-            free( s );
             break;
         }
-        free( s );
         usleep( 500000 );
     }
     
 cleanup:
-    tr_torrentClose( h, 0 );
+    tr_torrentClose( h, tor );
 
 failed: