Changeset 1685

Timestamp:

Apr 8, 2007, 5:41:44 AM (15 years ago)

Author:

joshe

Message:

Refactor multitracker code a bit.

Location:

trunk/libtransmission

Files:

• internal.h (modified) (1 diff)
• tracker.c (modified) (26 diffs)

trunk/libtransmission/internal.h

@@ -132 +132 @@
 typedef enum { TR_NET_OK, TR_NET_ERROR, TR_NET_WAIT } tr_tristate_t;
 
+#include "bsdqueue.h"
+#include "bsdtree.h"
 #include "platform.h"
 #include "bencode.h"

trunk/libtransmission/tracker.c

@@ -26 +26 @@
 #include "shared.h"
 
-typedef struct tr_announce_list_ptr_s tr_announce_list_ptr_t;
-struct tr_announce_list_ptr_s
-{
-    tr_tracker_info_t * item;
-    tr_announce_list_ptr_t * nextItem;
+struct tclist
+{
+    tr_tracker_info_t   * tl_inf;
+    int                   tl_badscrape;
+    SLIST_ENTRY( tclist ) next;
 };
+SLIST_HEAD( tchead, tclist );
 
 struct tr_tracker_s
@@ -40 +41 @@
     char         * trackerid;
 
-    tr_tracker_info_t * info;
-    
-    tr_announce_list_ptr_t ** trackerAnnounceListPtr;
+    struct tchead * tiers;
+    size_t          tierCount;
+    size_t          tierIndex;
+    struct tclist * tcCur;
 
 #define TC_CHANGE_NO        0
@@ -49 +51 @@
 #define TC_CHANGE_REDIRECT  4
     int            shouldChangeAnnounce;
-    int            announceTier;
-    int            announceTierLast;
     
     char         * redirectAddress;
@@ -86 +86 @@
 };
 
-static void        setAnnounce      ( tr_tracker_t * tc, tr_announce_list_ptr_t * announceItem );
+static void        setAnnounce      ( tr_tracker_t * tc, struct tclist * new );
 static void        failureAnnouncing( tr_tracker_t * tc );
 static tr_http_t * getQuery         ( tr_tracker_t * tc );
@@ -102 +102 @@
 
     tr_tracker_t * tc;
-    tr_announce_list_ptr_t * prev, * cur;
-    int ii, jj;
-
-    tc                 = calloc( 1, sizeof( tr_tracker_t ) );
+    struct tclist * item;
+    size_t ii, jj;
+
+    tc = calloc( 1, sizeof *tc );
+    if( NULL == tc )
+    {
+        return NULL;
+    }
+
     tc->tor            = tor;
     tc->id             = tor->id;
@@ -121 +126 @@
 
     tc->publicPort     = tor->publicPort;
-    
-    tc->trackerAnnounceListPtr = calloc( sizeof( int ), inf->trackerTiers );
-    for( ii = 0; ii < inf->trackerTiers; ii++ )
-    {
-        prev = NULL;
-        for( jj = 0; jj < inf->trackerList[ii].count; jj++ )
-        {
-            cur = calloc( sizeof( tr_announce_list_ptr_t ), 1 );
-            cur->item = &inf->trackerList[ii].list[jj];
-            if( NULL == prev )
+
+    assert( 0 <= inf->trackerTiers );
+    assert( sizeof( struct tchead ) == sizeof *tc->tiers );
+    tc->tiers          = calloc( inf->trackerTiers, sizeof *tc->tiers );
+    tc->tierCount      = inf->trackerTiers;
+    for( ii = 0; tc->tierCount > ii; ii++ )
+    {
+        assert( 0 <= inf->trackerList[ii].count );
+        SLIST_INIT( &tc->tiers[ii] );
+        for( jj = inf->trackerList[ii].count; 0 < jj; jj-- )
+        {
+            item = calloc( 1, sizeof *item );
+            if( NULL == item )
             {
-                tc->trackerAnnounceListPtr[ii] = cur;
+                tr_trackerClose( tc );
+                return NULL;
             }
-            else
-            {
-                prev->nextItem = cur;
-            }
-            prev = cur;
-        }
-    }
-    
-    setAnnounce( tc, tc->trackerAnnounceListPtr[0] );
+            item->tl_inf = &inf->trackerList[ii].list[jj-1];
+            SLIST_INSERT_HEAD( &tc->tiers[ii], item, next );
+        }
+    }
+
+    setAnnounce( tc, SLIST_FIRST( &tc->tiers[0] ) );
 
     return tc;
 }
 
-static void setAnnounce( tr_tracker_t * tc, tr_announce_list_ptr_t * announcePtr )
-{
-    tc->info = announcePtr->item;
+static void setAnnounce( tr_tracker_t * tc, struct tclist * new )
+{
+    tc->tcCur = new;
 
     /* Needs a new scrape */
@@ -160 +166 @@
 static void failureAnnouncing( tr_tracker_t * tc )
 {
-    tr_info_t * inf = &tc->tor->info;
-    
-    tc->shouldChangeAnnounce = tc->announceTier + 1 < inf->trackerTiers
-                                || tc->announceTierLast + 1 < inf->trackerList[tc->announceTier].count
-                                ? TC_CHANGE_NEXT : TC_CHANGE_NONEXT;
-    
-    if( tc->shouldChangeAnnounce == TC_CHANGE_NONEXT )
-    {
+    if( NULL != SLIST_NEXT( tc->tcCur, next ) ||
+        tc->tierIndex + 1 < tc->tierCount )
+    {
+        tc->shouldChangeAnnounce = TC_CHANGE_NEXT;
+    }
+    else
+    {
+        tc->shouldChangeAnnounce = TC_CHANGE_NONEXT;
         tc->completelyUnconnectable = 1;
     }
@@ -186 +192 @@
     now = tr_date();
     
-    /* If last attempt was an error and it did not change trackers, then all must have been errors */
+    /* If last attempt was an error and it did not change trackers,
+       then all must have been errors */
     if( tc->lastError )
     {
-        /* Unreachable trackers, wait 10 seconds + random value before trying again */
+        /* Unreachable trackers, wait 10 seconds + random value before
+           trying again */
         if( tc->allUnreachIfError )
         {
@@ -197 +205 @@
             }
         }
-        /* The tracker rejected us (like 4XX code, unauthorized IP...),
-            don't hammer it - we'll probably get the same answer next time anyway */
+        /* The tracker rejected us (like 4XX code, unauthorized
+            IP...), don't hammer it - we'll probably get the same
+            answer next time anyway */
         else
         {
@@ -207 +216 @@
             else
             {
-                tc->allUnreachIfError = 1; //since starting at the top of the list, reset if any were reached previously
+                /* since starting at the top of the list, reset if any
+                   were reached previously */
+                tc->allUnreachIfError = 1;
             }
         }
@@ -263 +274 @@
     /* in process of changing tracker or scrape not supported */
     if( tc->shouldChangeAnnounce != TC_CHANGE_NO ||
-        NULL == tc->info->scrape || tc->stopped )
+        NULL == tc->tcCur->tl_inf->scrape || tc->tcCur->tl_badscrape ||
+        tc->stopped )
     {
         return 0;
@@ -283 +295 @@
                               uint8_t ** peerCompact, int manual )
 {
-    tr_torrent_t * tor = tc->tor;
-    tr_info_t    * inf = &tor->info;
     const char   * data;
     char         * address, * announce;
-    int            len, i, port;
-    tr_announce_list_ptr_t * announcePtr, * prevAnnouncePtr;
+    int            len, port;
+    struct tclist * next;
+    struct tchead * tier;
 
     *peerCount = 0;
@@ -295 +306 @@
     if( ( NULL == tc->http ) && ( manual || shouldConnect( tc ) ) )
     {
-        //if announcing manually, don't consider not reaching a tracker an error
+        /* if announcing manually, don't consider not reaching a
+           tracker an error */
         if( manual )
         {
@@ -313 +325 @@
             {
                 tr_err( "Tracker: redirected URL: %s:%d", address, port );
-                tc->http = tr_httpClient( TR_HTTP_GET, address, port, "%s", announce );
+                tc->http = tr_httpClient( TR_HTTP_GET, address, port,
+                                          "%s", announce );
                 
                 free( address );
@@ -327 +340 @@
             if( tc->shouldChangeAnnounce == TC_CHANGE_NEXT )
             {
-                tr_inf( "Tracker: failed to connect to %s, trying next",
-                        tc->info->address );
-                
-                if( tc->announceTierLast + 1 < inf->trackerList[tc->announceTier].count )
+                tr_inf( "Tracker: failed to connect to %s:%i, trying next",
+                        tc->tcCur->tl_inf->address, tc->tcCur->tl_inf->port );
+                next = SLIST_NEXT( tc->tcCur, next );
+                if( NULL == next )
                 {
-                    tc->announceTierLast++;
-                    
-                    announcePtr = tc->trackerAnnounceListPtr[tc->announceTier];
-                    for( i = 0; i < tc->announceTierLast; i++ )
-                    {
-                        announcePtr = announcePtr->nextItem;
-                    }
-                }
-                else
-                {
-                    tc->announceTierLast = 0;
-                    tc->announceTier++;
-                    
-                    announcePtr = tc->trackerAnnounceListPtr[tc->announceTier];
+                    assert( tc->tierCount > tc->tierIndex + 1 );
+                    tc->tierIndex++;
+                    next = SLIST_FIRST( &tc->tiers[tc->tierIndex] );
+                    /* XXX will there always be at least one tracker
+                       in a tier? */
                 }
                 
-                tr_inf( "Tracker: tracker address set to %s", tc->trackerAnnounceListPtr[tc->announceTier]->item->address );
-                setAnnounce( tc, announcePtr );
+                tr_inf( "Tracker: switching to tracker http://%s:%i%s",
+                        next->tl_inf->address, next->tl_inf->port,
+                        next->tl_inf->announce );
+                setAnnounce( tc, next );
             }
             /* Need to change to first in list */
-            else if( tc->announceTier != 0 || tc->announceTierLast != 0 )
+            else if( SLIST_FIRST( &tc->tiers[0] ) != tc->tcCur )
             {
-                /* Check if the last announce was successful and wasn't the first in the sublist */
-                if( tc->shouldChangeAnnounce == TC_CHANGE_NO && tc->announceTierLast != 0 )
+                tier = &tc->tiers[tc->tierIndex];
+                /* Check if the last announce was successful and
+                   wasn't the first in the sublist */
+                if( tc->shouldChangeAnnounce == TC_CHANGE_NO &&
+                    SLIST_FIRST( tier ) != tc->tcCur )
                 {
-                    announcePtr = tc->trackerAnnounceListPtr[tc->announceTier];
-                    prevAnnouncePtr = NULL;
-                    for( i = 0; i < tc->announceTierLast; i++ )
-                    {
-                        prevAnnouncePtr = announcePtr;
-                        announcePtr = announcePtr->nextItem;
-                    }
-                    
-                    /* Move address to front of tier in announce list */
-                    prevAnnouncePtr->nextItem = announcePtr->nextItem;
-                    announcePtr->nextItem =  tc->trackerAnnounceListPtr[tc->announceTier];
-                    tc->trackerAnnounceListPtr[tc->announceTier] = announcePtr;
+                    SLIST_REMOVE( tier, tc->tcCur, tclist, next );
+                    SLIST_INSERT_HEAD( tier, tc->tcCur, next );
                 }
                 
-                setAnnounce( tc, tc->trackerAnnounceListPtr[0] );
-                tc->announceTier = 0;
-                tc->announceTierLast = 0;
+                setAnnounce( tc, SLIST_FIRST( tier ) );
             }
-            
+
             tc->http = getQuery( tc );
 
             tr_inf( "Tracker: connecting to %s:%d (%s)",
-                    tc->info->address, tc->info->port,
+                    tc->tcCur->tl_inf->address, tc->tcCur->tl_inf->port,
                     tc->started ? "sending 'started'" :
                     ( tc->completed ? "sending 'completed'" :
                       ( tc->stopped ? "sending 'stopped'" :
-                        ( shouldChangePort( tc ) ? "sending 'stopped' to change port" :
+                        ( shouldChangePort( tc ) ?
+                          "sending 'stopped' to change port" :
                           "getting peers" ) ) ) );
         }
@@ -420 +418 @@
         {
             /* Use redirected address */
-            if( !tr_httpParseUrl( tc->redirectScrapeAddress, tc->redirectScrapeAddressLen,
-                                     &address, &port, &announce ) )
+            if( !tr_httpParseUrl( tc->redirectScrapeAddress,
+                                  tc->redirectScrapeAddressLen,
+                                  &address, &port, &announce ) )
             {
                 tr_err( "Scrape: redirected URL: %s:%d", address, port );
-                tc->httpScrape = tr_httpClient( TR_HTTP_GET, address, port, "%s", announce );
+                tc->httpScrape = tr_httpClient( TR_HTTP_GET, address, port,
+                                                "%s", announce );
                 
                 free( address );
@@ -436 +436 @@
         {
             tc->httpScrape = getScrapeQuery( tc );
-            tr_inf( "Scrape: sent HTTP request to %s:%d%s",
-                    tc->info->address, tc->info->port, tc->info->scrape );
+            tr_inf( "Scrape: sent HTTP request for http://%s:%d%s",
+                    tc->tcCur->tl_inf->address,
+                    tc->tcCur->tl_inf->port,
+                    tc->tcCur->tl_inf->scrape );
         }
     }
@@ -486 +488 @@
 void tr_trackerClose( tr_tracker_t * tc )
 {
-    tr_torrent_t * tor = tc->tor;
-    tr_info_t * inf = &tor->info;
-    tr_announce_list_ptr_t * cur, * curFree;
-    int ii;
+    size_t          ii;
+    struct tclist * dead;
 
     killHttp( &tc->http );
     killHttp( &tc->httpScrape );
 
-    for( ii = 0; ii < inf->trackerTiers; ii++ )
-    {
-        for( cur = tc->trackerAnnounceListPtr[ii]; cur; )
-        {
-            curFree = cur;
-            cur = cur->nextItem;
-            free( curFree );
-        }
-    }
-    free( tc->trackerAnnounceListPtr );
+    for( ii = 0; tc->tierCount > ii; ii++ )
+    {
+        while( !SLIST_EMPTY( &tc->tiers[ii] ) )
+        {
+            dead = SLIST_FIRST( &tc->tiers[ii] );
+            SLIST_REMOVE_HEAD( &tc->tiers[ii], next );
+            free( dead );
+        }
+    }
+    free( tc->tiers );
 
     free( tc->trackerid );
@@ -512 +512 @@
 {
     tr_torrent_t * tor = tc->tor;
+    tr_tracker_info_t * tcInf = tc->tcCur->tl_inf;
 
     char         * event, * trackerid, * idparam;
@@ -558 +559 @@
     }
 
-    start = ( strchr( tc->info->announce, '?' ) ? '&' : '?' );
+    start = ( strchr( tcInf->announce, '?' ) ? '&' : '?' );
     left  = tr_cpLeftBytes( tor->completion );
 
-    return tr_httpClient( TR_HTTP_GET, tc->info->address, tc->info->port,
+    return tr_httpClient( TR_HTTP_GET, tcInf->address, tcInf->port,
                           "%s%c"
                           "info_hash=%s&"
@@ -574 +575 @@
                           "%s%s"
                           "%s",
-                          tc->info->announce, start, tor->escapedHashString,
+                          tcInf->announce, start, tor->escapedHashString,
                           tc->id, tc->publicPort, up, down, left, numwant,
                           tor->key, idparam, trackerid, event );
@@ -582 +583 @@
 {
     tr_torrent_t * tor = tc->tor;
+    tr_tracker_info_t * tcInf = tc->tcCur->tl_inf;
     char           start;
 
-    start = ( strchr( tc->info->scrape, '?' ) ? '&' : '?' );
-
-    return tr_httpClient( TR_HTTP_GET, tc->info->address, tc->info->port,
+    start = ( strchr( tcInf->scrape, '?' ) ? '&' : '?' );
+
+    return tr_httpClient( TR_HTTP_GET, tcInf->address, tcInf->port,
                           "%s%c"
                           "info_hash=%s",
-                          tc->info->scrape, start, tor->escapedHashString );
+                          tcInf->scrape, start, tor->escapedHashString );
 }
 
@@ -685 +687 @@
     }
 
-    // tr_bencPrint( &beAll );
+    /* tr_bencPrint( &beAll ); */
 
     if( ( bePeers = tr_bencDictFind( &beAll, "failure reason" ) ) )
@@ -891 +893 @@
         if( TR_HTTP_STATUS_FAIL_CLIENT( code ) )
         {
-            free( tc->info->scrape );
-            tc->info->scrape = NULL;
+            tc->tcCur->tl_badscrape = 1;
         }
         tc->lastScrapeFailed = 1;
@@ -1003 +1004 @@
         return NULL;
     }
-    return tc->info;
+    return tc->tcCur->tl_inf;
 }
 
@@ -1026 +1027 @@
     tc = tr_trackerInit( tor );
 
-    if( NULL == tc->info->scrape )
+    if( NULL == tc->tcCur->tl_inf->scrape || tc->tcCur->tl_badscrape )
     {
         return 1;