Changeset 10150

Timestamp:

Feb 10, 2010, 2:59:15 AM (12 years ago)

Author:

charles

Message:

(trunk libT) fix 1.82 memory corruption error reported by john doe

File:

• trunk/libtransmission/announcer.c (modified) (18 diffs)

trunk/libtransmission/announcer.c

@@ -352 +352 @@
     uint64_t byteCounts[3];
 
+    tr_ptrArray announceEvents; /* const char* */
+
     tr_ptrArray trackers; /* tr_tracker_item */
     tr_tracker_item * currentTracker;
@@ -369 +371 @@
 
     time_t announceAt;
-    const char * announceEvent;
+    //const char * announceEvent;
 
     /* unique lookup key */
@@ -399 +401 @@
     t = tr_new0( tr_tier, 1 );
     t->key = nextKey++;
+    t->announceEvents = TR_PTR_ARRAY_INIT;
     t->trackers = TR_PTR_ARRAY_INIT;
     t->currentTracker = NULL;
@@ -416 +419 @@
     tr_tier * tier = vtier;
     tr_ptrArrayDestruct( &tier->trackers, trackerFree );
+    tr_ptrArrayDestruct( &tier->announceEvents, NULL );
     tr_free( tier );
 }
@@ -862 +866 @@
 
 static void
-tierClearNextAnnounce( tr_tier * tier )
-{
-    tier->announceAt = 0;
-    tier->announceEvent = NULL;
-    dbgmsg( tier, "cleared out announceEvent -- no announces pending." );
-}
-
-static void
-tierSetNextAnnounce( tr_tier * tier, const char * announceEvent, time_t announceAt )
+tierAddAnnounce( tr_tier * tier, const char * announceEvent, time_t announceAt )
 {
     assert( tier != NULL );
-    assert( announceEvent != NULL );
-
-    if( !strcmp( announceEvent, "manual" ) && !tierCanManualAnnounce( tier ) )
-        return;
-
+    assert( event != NULL );
+
+    tr_ptrArrayAppend( &tier->announceEvents, (void*)announceEvent );
     tier->announceAt = announceAt;
-    tier->announceEvent = announceEvent;
-    dbgmsg( tier, "next announce event is \"%s\" in %d seconds\n", announceEvent, (int)difftime(announceAt,time(NULL)) );
-}
-
-static void
-torrentSetNextAnnounce( tr_torrent * tor, const char * announceEvent, time_t announceAt )
+
+    dbgmsg( tier, "appended event \"%s\"; announcing in %d seconds\n", announceEvent, (int)difftime(announceAt,time(NULL)) );
+}
+
+static void
+torrentAddAnnounce( tr_torrent * tor, const char * announceEvent, time_t announceAt )
 {
     int i;
@@ -895 +889 @@
     n = tr_ptrArraySize( &tiers->tiers );
     for( i=0; i<n; ++i )
-        tierSetNextAnnounce( tr_ptrArrayNth( &tiers->tiers, i ), announceEvent, announceAt );
-}
-
+        tierAddAnnounce( tr_ptrArrayNth( &tiers->tiers, i ), announceEvent, announceAt );
+}
+
+void
+tr_announcerTorrentStarted( tr_torrent * tor )
+{
+    torrentAddAnnounce( tor, "started", tr_time( ) );
+}
 void
 tr_announcerManualAnnounce( tr_torrent * tor )
 {
-    torrentSetNextAnnounce( tor, "manual", tr_time( ) );
-}
-void
-tr_announcerTorrentStarted( tr_torrent * tor )
-{
-    torrentSetNextAnnounce( tor, "started", tr_time( ) );
+    torrentAddAnnounce( tor, "", tr_time( ) );
 }
 void
 tr_announcerTorrentStopped( tr_torrent * tor )
 {
-    torrentSetNextAnnounce( tor, "stopped", tr_time( ) );
+    torrentAddAnnounce( tor, "stopped", tr_time( ) );
 }
 void
 tr_announcerTorrentCompleted( tr_torrent * tor )
 {
-    torrentSetNextAnnounce( tor, "completed", tr_time( ) );
+    torrentAddAnnounce( tor, "completed", tr_time( ) );
 }
 void
@@ -1257 +1251 @@
     tr_bool success = FALSE;
     const time_t now = time ( NULL );
-    const tr_bool isStopped = !strcmp( data->event, "stopped" );
+    const char * announceEvent = data->event;
+    const tr_bool isStopped = !strcmp( announceEvent, "stopped" );
 
     if( announcer && tier )
@@ -1325 +1320 @@
             dbgmsg( tier, "No response from tracker... retrying in %d seconds.", interval );
             tier->manualAnnounceAllowedAt = ~(time_t)0;
-            tierSetNextAnnounce( tier, tier->announceEvent, now + interval );
+            tierAddAnnounce( tier, announceEvent, now + interval );
         }
         else if( 200 <= responseCode && responseCode <= 299 )
@@ -1341 +1336 @@
             tier->manualAnnounceAllowedAt = now + tier->announceMinIntervalSec;
 
-            if( strcmp( tier->announceEvent, "stopped" ) == 0 )
-                tierClearNextAnnounce( tier );
-            else
-                tierSetNextAnnounce( tier, "", now + interval );
+            /* if we're running and the queue is empty, add the next update */
+            if( !isStopped && !tr_ptrArraySize( &tier->announceEvents ) )
+            {
+                tierAddAnnounce( tier, "", now + interval );
+            }
         }
         else if( 300 <= responseCode && responseCode <= 399 )
@@ -1351 +1347 @@
             const int interval = 5;
             dbgmsg( tier, "got a redirect. retrying in %d seconds", interval );
-            tierSetNextAnnounce( tier, tier->announceEvent, now + interval );
+            tierAddAnnounce( tier, announceEvent, now + interval );
             tier->manualAnnounceAllowedAt = now + tier->announceMinIntervalSec;
         }
@@ -1362 +1358 @@
                 publishErrorMessageAndStop( tier, _( "Tracker returned a 4xx message" ) );
             tier->manualAnnounceAllowedAt = ~(time_t)0;
-            tierClearNextAnnounce( tier );
         }
         else if( 500 <= responseCode && responseCode <= 599 )
@@ -1372 +1367 @@
             const int interval = getRetryInterval( tier->currentTracker->host );
             tier->manualAnnounceAllowedAt = ~(time_t)0;
-            tierSetNextAnnounce( tier, tier->announceEvent, now + interval );
+            tierAddAnnounce( tier, announceEvent, now + interval );
         }
         else
@@ -1380 +1375 @@
             dbgmsg( tier, "Invalid response from tracker... retrying in two minutes." );
             tier->manualAnnounceAllowedAt = ~(time_t)0;
-            tierSetNextAnnounce( tier, tier->announceEvent, now + interval );
+            tierAddAnnounce( tier, announceEvent, now + interval );
         }
 
@@ -1393 +1388 @@
                 tier->currentTracker->host->lastSuccessfulRequest = now;
         }
-
-        if( !success )
+        else if( responseCode != HTTP_OK )
+        {
             tierIncrementTracker( tier );
+
+            tr_ptrArrayInsert( &tier->announceEvents, (void*)announceEvent, 0 );
+        }
     }
 
@@ -1406 +1404 @@
 }
 
-static const char *
-getAnnounceEvent( const tr_tier * tier )
-{
-    const char * event;
+static const char*
+getNextAnnounceEvent( tr_tier * tier )
+{
+    int i, n;
+    int pos = -1;
+    tr_ptrArray tmp;
+    char ** events;
+    const char * str = NULL;
 
     assert( tier != NULL );
@@ -1415 +1417 @@
     assert( tr_isTorrent( tier->tor ) );
 
-    /* BEP 21: "In order to tell the tracker that a peer is a partial seed,
-     * it MUST send an event=paused parameter in every announce while
-     * it is a partial seed." */
+    /* rule #1: if there's a "stopped" in the queue, ignore everything before it */
+    events = (char**) tr_ptrArrayPeek( &tier->announceEvents, &n );
+    for( i=0; pos<0 && i<n; ++i )
+        if( !strcmp( events[i], "stopped" ) )
+            pos = i;
+
+fprintf( stderr, "in the queue: " );
+for( i=0; i<n; ++i ) fprintf( stderr, "(%d)%s, ", i, events[i] );
+fprintf( stderr, "\n" );
+
+    /* rule #2: if the next two events are the same, ignore the first one */
+    for( i=0; pos<0 && i<=n-2; ++i )
+        if( strcmp( events[i], events[i+1] ) )
+            pos = i;
+
+    /* otherwise use the next announce event in line */
+    if( ( pos < 0 ) && ( n > 0 ) )
+        pos = 0;
+
+    /* rule #3: BEP 21: "In order to tell the tracker that a peer is a
+     * partial seed, it MUST send an event=paused parameter in every
+     * announce while it is a partial seed." */
+    str = pos>=0 ? events[pos] : NULL;
     if( tr_cpGetStatus( &tier->tor->completion ) == TR_PARTIAL_SEED )
-        if( strcmp( tier->announceEvent, "stopped" ) )
-            return "paused";
-
-    event = tier->announceEvent;
-
-    if( !strcmp( event, "manual" ) )
-        return "started";
-
-    return event;
+        if( !str || !strcmp( str, "stopped" ) )
+            str = "paused";
+
+    /* announceEvents array upkeep */
+fprintf( stderr, "what's left in the queue: " );
+    tmp = TR_PTR_ARRAY_INIT;
+    for( i=pos+1; i<n; ++i ) {
+        fprintf( stderr, "(%d)%s, ", i, events[i] );
+        tr_ptrArrayAppend( &tmp, events[i] );
+    }
+    tr_ptrArrayDestruct( &tier->announceEvents, NULL );
+    tier->announceEvents = tmp;
+fprintf( stderr, "\n" );
+
+fprintf( stderr, "returning [%s] (pos %d)\n", (str?str:"(null)"), pos );
+
+    return str;
 }
 
@@ -1433 +1463 @@
 tierAnnounce( tr_announcer * announcer, tr_tier * tier )
 {
-    char * url;
-    struct announce_data * data;
-    const tr_torrent * tor = tier->tor;
-    const time_t now = tr_time( );
+    const char * announceEvent = getNextAnnounceEvent( tier );
 
     assert( !tier->isAnnouncing );
 
-    data = tr_new0( struct announce_data, 1 );
-    data->torrentId = tr_torrentId( tor );
-    data->tierId = tier->key;
-    data->isRunningOnSuccess = tor->isRunning;
-    data->timeSent = now;
-    data->event = getAnnounceEvent( tier );
-    url = createAnnounceURL( announcer, tor, tier, data->event );
-
-    tier->isAnnouncing = TRUE;
-    tier->lastAnnounceStartTime = now;
-    --announcer->slotsAvailable;
-    tr_webRun( announcer->session, url, NULL, onAnnounceDone, data );
-
-    tr_free( url );
+    if( announceEvent != NULL )
+    {
+        char * url;
+        struct announce_data * data;
+        const tr_torrent * tor = tier->tor;
+        const time_t now = tr_time( );
+
+        data = tr_new0( struct announce_data, 1 );
+        data->torrentId = tr_torrentId( tor );
+        data->tierId = tier->key;
+        data->isRunningOnSuccess = tor->isRunning;
+        data->timeSent = now;
+        data->event = announceEvent;
+        url = createAnnounceURL( announcer, tor, tier, data->event );
+
+        tier->isAnnouncing = TRUE;
+        tier->lastAnnounceStartTime = now;
+        --announcer->slotsAvailable;
+        tr_webRun( announcer->session, url, NULL, onAnnounceDone, data );
+
+        tr_free( url );
+    }
 }
 
@@ -1651 +1686 @@
     return !tier->isAnnouncing
         && !tier->isScraping
-        && ( tier->announceEvent != NULL )
-        && ( tier->announceAt <= now );
+        && ( tier->announceAt <= now )
+        && ( tr_ptrArraySize( &tier->announceEvents ) != 0 );
 }