source: trunk/libtransmission/announcer.c @ 10196

Last change on this file since 10196 was 10196, checked in by charles, 12 years ago

(trunk libT) handle 404 errors more gracefully. error reported by Longinus00 in #transmission on freenode

File size: 57.6 KB
Line 
1/*
2 * This file Copyright (C) 2009-2010 Mnemosyne LLC
3 *
4 * This file is licensed by the GPL version 2.  Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id:$
11 */
12
13#include <assert.h>
14#include <limits.h>
15
16#include <event.h>
17#include <evhttp.h> /* for HTTP_OK */
18
19#include "transmission.h"
20#include "announcer.h"
21#include "crypto.h"
22#include "net.h"
23#include "ptrarray.h"
24#include "publish.h"
25#include "session.h"
26#include "tr-dht.h"
27#include "torrent.h"
28#include "utils.h"
29#include "web.h"
30
31#define STARTED "started"
32
33#define dbgmsg( tier, ... ) \
34if( tr_deepLoggingIsActive( ) ) do { \
35  char name[128]; \
36  tr_snprintf( name, sizeof( name ), "[%s--%s]", tr_torrentName( tier->tor ), \
37      ( tier->currentTracker ? tier->currentTracker->host->name : "" ) ); \
38  tr_deepLog( __FILE__, __LINE__, name, __VA_ARGS__ ); \
39} while( 0 )
40
41enum
42{
43    /* unless the tracker says otherwise, rescrape this frequently */
44    DEFAULT_SCRAPE_INTERVAL_SEC = ( 60 * 30 ),
45
46    /* unless the tracker says otherwise, this is the announce interval */
47    DEFAULT_ANNOUNCE_INTERVAL_SEC = ( 60 * 10 ),
48
49    /* unless the tracker says otherwise, this is the announce min_interval */
50    DEFAULT_ANNOUNCE_MIN_INTERVAL_SEC = ( 60 * 2 ),
51
52    /* the length of the 'key' argument passed in tracker requests */
53    KEYLEN = 8,
54
55    /* how many web tasks we allow at one time */
56    MAX_CONCURRENT_TASKS = 48,
57
58    /* if a tracker takes more than this long to respond,
59     * we treat it as nonresponsive */
60    MAX_TRACKER_RESPONSE_TIME_SECS = ( 60 * 2 ),
61
62    /* the value of the 'numwant' argument passed in tracker requests. */
63    NUMWANT = 200,
64
65    /* how long to put slow (nonresponsive) trackers in the penalty box */
66    SLOW_HOST_PENALTY_SECS = ( 60 * 10 ),
67
68    UPKEEP_INTERVAL_SECS = 1
69
70};
71
72/***
73****
74***/
75
76static int
77compareTransfer( int a_uploaded, int a_downloaded,
78                 int b_uploaded, int b_downloaded )
79{
80    /* higher upload count goes first */
81    if( a_uploaded != b_uploaded )
82        return a_uploaded > b_uploaded ? -1 : 1;
83
84    /* then higher download count goes first */
85    if( a_downloaded != b_downloaded )
86        return a_downloaded > b_downloaded ? -1 : 1;
87
88    return 0;
89}
90
91/***
92****
93***/
94
95/**
96 * used by tr_announcer to recognize nonresponsive
97 * trackers and de-prioritize them
98 */
99typedef struct
100{
101    char * name;
102
103    /* how many seconds it took to get the last tracker response */
104    int lastResponseInterval;
105
106    /* the last time we sent an announce or scrape message */
107    time_t lastRequestTime;
108
109    /* the last successful announce/scrape time for this host */
110    time_t lastSuccessfulRequest;
111}
112tr_host;
113
114static int
115compareHosts( const void * va, const void * vb )
116{
117    const tr_host * a = va;
118    const tr_host * b = vb;
119    return strcmp( a->name, b->name );
120}
121
122static int
123compareHostToName( const void * va, const void * vb )
124{
125    const tr_host * a = va;
126    return strcmp( a->name, vb );
127}
128
129/* format: hostname + ':' + port */
130static char *
131getHostName( const char * url )
132{
133    int port = 0;
134    char * host = NULL;
135    char * ret;
136    tr_httpParseURL( url, strlen( url ), &host, &port, NULL );
137    ret = tr_strdup_printf( "%s:%d", ( host ? host : "invalid" ), port );
138    tr_free( host );
139    return ret;
140}
141
142static tr_host*
143hostNew( const char * name )
144{
145    tr_host * host = tr_new0( tr_host, 1 );
146    host->name = tr_strdup( name );
147    return host;
148}
149
150static void
151hostFree( void * vhost )
152{
153    tr_host * host = vhost;
154
155    tr_free( host->name );
156    tr_free( host );
157}
158
159/***
160****
161***/
162
163/**
164 * Since we can't poll a tr_torrent's fields after it's destroyed,
165 * we pre-build the "stop" announcement message when a torrent
166 * is removed from Transmission
167 */
168struct stop_message
169{
170    tr_host * host;
171    char * url;
172    int up;
173    int down;
174};
175
176static void
177stopFree( struct stop_message * stop )
178{
179    tr_free( stop->url );
180    tr_free( stop );
181}
182
183static int
184compareStops( const void * va, const void * vb )
185{
186    const struct stop_message * a = va;
187    const struct stop_message * b = vb;
188    return compareTransfer( a->up, a->down, b->up, b->down);
189}
190
191/***
192****
193***/
194
195/**
196 * "global" (per-tr_session) fields
197 */
198typedef struct tr_announcer
199{
200    tr_ptrArray hosts; /* tr_host */
201    tr_ptrArray stops; /* struct stop_message */
202    tr_session * session;
203    struct event * upkeepTimer;
204    int slotsAvailable;
205}
206tr_announcer;
207
208tr_bool
209tr_announcerHasBacklog( const struct tr_announcer * announcer )
210{
211    return announcer->slotsAvailable < 1;
212}
213
214static tr_host *
215getHost( tr_announcer * announcer, const char * url )
216{
217    char * name = getHostName( url );
218    tr_host * host;
219
220    host = tr_ptrArrayFindSorted( &announcer->hosts, name, compareHostToName );
221    if( host == NULL )
222    {
223        host = hostNew( name );
224        tr_ptrArrayInsertSorted( &announcer->hosts, host, compareHosts );
225    }
226
227    tr_free( name );
228    return host;
229}
230
231static void
232onUpkeepTimer( int foo UNUSED, short bar UNUSED, void * vannouncer );
233
234void
235tr_announcerInit( tr_session * session )
236{
237    tr_announcer * a;
238
239    assert( tr_isSession( session ) );
240
241    a = tr_new0( tr_announcer, 1 );
242    a->hosts = TR_PTR_ARRAY_INIT;
243    a->stops = TR_PTR_ARRAY_INIT;
244    a->session = session;
245    a->slotsAvailable = MAX_CONCURRENT_TASKS;
246    a->upkeepTimer = tr_new0( struct event, 1 );
247    evtimer_set( a->upkeepTimer, onUpkeepTimer, a );
248    tr_timerAdd( a->upkeepTimer, UPKEEP_INTERVAL_SECS, 0 );
249
250    session->announcer = a;
251}
252
253static void flushCloseMessages( tr_announcer * announcer );
254
255void
256tr_announcerClose( tr_session * session )
257{
258    tr_announcer * announcer = session->announcer;
259
260    flushCloseMessages( announcer );
261
262    evtimer_del( announcer->upkeepTimer );
263    tr_free( announcer->upkeepTimer );
264    announcer->upkeepTimer = NULL;
265
266    tr_ptrArrayDestruct( &announcer->stops, NULL );
267    tr_ptrArrayDestruct( &announcer->hosts, hostFree );
268
269    session->announcer = NULL;
270    tr_free( announcer );
271}
272
273/***
274****
275***/
276
277/* a row in tr_tier's list of trackers */
278typedef struct
279{
280    tr_host * host;
281
282    char * announce;
283    char * scrape;
284
285    char * tracker_id;
286
287    int seederCount;
288    int leecherCount;
289    int downloadCount;
290    int downloaderCount;
291
292    uint32_t id;
293
294    /* sent as the "key" argument in tracker requests
295     * to verify us if our IP address changes.
296     * This is immutable for the life of the tracker object.
297     * The +1 is for '\0' */
298    char key_param[KEYLEN + 1];
299}
300tr_tracker_item;
301
302static void
303trackerItemCopyAttributes( tr_tracker_item * t, const tr_tracker_item * o )
304{
305    assert( t != o );
306    assert( t != NULL );
307    assert( o != NULL );
308
309    t->seederCount = o->seederCount;
310    t->leecherCount = o->leecherCount;
311    t->downloadCount = o->downloadCount;
312    t->downloaderCount = o->downloaderCount;
313    t->id = o->id;
314    memcpy( t->key_param, o->key_param, sizeof( t->key_param ) );
315}
316
317static void
318generateKeyParam( char * msg, size_t msglen )
319{
320    size_t i;
321    const char * pool = "abcdefghijklmnopqrstuvwxyz0123456789";
322    const int poolSize = strlen( pool );
323
324    for( i=0; i<msglen; ++i )
325        *msg++ = pool[tr_cryptoRandInt( poolSize )];
326    *msg = '\0';
327}
328
329static tr_tracker_item*
330trackerNew( tr_announcer  * announcer,
331            const char    * announce,
332            const char    * scrape,
333            uint32_t        id )
334{
335    tr_tracker_item * tracker = tr_new0( tr_tracker_item, 1  );
336    tracker->host = getHost( announcer, announce );
337    tracker->announce = tr_strdup( announce );
338    tracker->scrape = tr_strdup( scrape );
339    tracker->id = id;
340    generateKeyParam( tracker->key_param, KEYLEN );
341    tracker->seederCount = -1;
342    tracker->leecherCount = -1;
343    tracker->downloadCount = -1;
344    return tracker;
345}
346
347static void
348trackerFree( void * vtracker )
349{
350    tr_tracker_item * tracker = vtracker;
351
352    tr_free( tracker->tracker_id );
353    tr_free( tracker->announce );
354    tr_free( tracker->scrape );
355    tr_free( tracker );
356}
357
358/***
359****
360***/
361
362struct tr_torrent_tiers;
363
364/** @brief A group of trackers in a single tier, as per the multitracker spec */
365typedef struct
366{
367    /* number of up/down/corrupt bytes since the last time we sent an
368     * "event=stopped" message that was acknowledged by the tracker */
369    uint64_t byteCounts[3];
370
371    tr_ptrArray trackers; /* tr_tracker_item */
372    tr_tracker_item * currentTracker;
373    int currentTrackerIndex;
374
375    tr_torrent * tor;
376
377    time_t scrapeAt;
378    time_t lastScrapeStartTime;
379    time_t lastScrapeTime;
380    tr_bool lastScrapeSucceeded;
381
382    time_t announceAt;
383    time_t manualAnnounceAllowedAt;
384    time_t lastAnnounceStartTime;
385    time_t lastAnnounceTime;
386    tr_bool lastAnnounceSucceeded;
387    tr_bool lastAnnounceTimedOut;
388
389    tr_ptrArray announceEvents; /* const char* */
390
391    /* unique lookup key */
392    int key;
393
394    int scrapeIntervalSec;
395    int announceIntervalSec;
396    int announceMinIntervalSec;
397
398    int lastAnnouncePeerCount;
399
400    tr_bool isRunning;
401    tr_bool isAnnouncing;
402    tr_bool isScraping;
403
404    char lastAnnounceStr[128];
405    char lastScrapeStr[128];
406}
407tr_tier;
408
409static tr_tier *
410tierNew( tr_torrent * tor )
411{
412    tr_tier * t;
413    static int nextKey = 1;
414    const time_t now = tr_time( );
415
416    t = tr_new0( tr_tier, 1 );
417    t->key = nextKey++;
418    t->announceEvents = TR_PTR_ARRAY_INIT;
419    t->trackers = TR_PTR_ARRAY_INIT;
420    t->currentTracker = NULL;
421    t->currentTrackerIndex = -1;
422    t->scrapeIntervalSec = DEFAULT_SCRAPE_INTERVAL_SEC;
423    t->announceIntervalSec = DEFAULT_ANNOUNCE_INTERVAL_SEC;
424    t->announceMinIntervalSec = DEFAULT_ANNOUNCE_MIN_INTERVAL_SEC;
425    t->scrapeAt = now + tr_cryptoWeakRandInt( 60*5 );
426    t->tor = tor;
427
428    return t;
429}
430
431static void
432tierFree( void * vtier )
433{
434    tr_tier * tier = vtier;
435    tr_ptrArrayDestruct( &tier->trackers, trackerFree );
436    tr_ptrArrayDestruct( &tier->announceEvents, NULL );
437    tr_free( tier );
438}
439
440static void
441tierCopyAttributes( tr_tier * t, const tr_tier * o )
442{
443    int i, n;
444    tr_tier bak;
445
446    assert( t != NULL );
447    assert( o != NULL );
448    assert( t != o );
449
450    bak = *t;
451    *t = *o;
452    t->tor = bak.tor;
453    t->trackers = bak.trackers;
454    t->announceEvents = bak.announceEvents;
455    t->currentTracker = bak.currentTracker;
456    t->currentTrackerIndex = bak.currentTrackerIndex;
457
458    tr_ptrArrayClear( &t->announceEvents );
459    for( i=0, n=tr_ptrArraySize(&o->announceEvents); i<n; ++i )
460        tr_ptrArrayAppend( &t->announceEvents, tr_ptrArrayNth((tr_ptrArray*)&o->announceEvents,i) );
461}
462
463static void
464tierIncrementTracker( tr_tier * tier )
465{
466    /* move our index to the next tracker in the tier */
467    const int i = ( tier->currentTrackerIndex + 1 )
468                        % tr_ptrArraySize( &tier->trackers );
469    tier->currentTracker = tr_ptrArrayNth( &tier->trackers, i );
470    tier->currentTrackerIndex = i;
471
472    /* reset some of the tier's fields */
473    tier->scrapeIntervalSec = DEFAULT_SCRAPE_INTERVAL_SEC;
474    tier->announceIntervalSec = DEFAULT_ANNOUNCE_INTERVAL_SEC;
475    tier->announceMinIntervalSec = DEFAULT_ANNOUNCE_MIN_INTERVAL_SEC;
476    tier->isAnnouncing = FALSE;
477    tier->isScraping = FALSE;
478    tier->lastAnnounceStartTime = 0;
479    tier->lastScrapeStartTime = 0;
480}
481
482static void
483tierAddTracker( tr_announcer * announcer,
484                tr_tier      * tier,
485                const char   * announce,
486                const char   * scrape,
487                uint32_t       id )
488{
489    tr_tracker_item * tracker = trackerNew( announcer, announce, scrape, id );
490
491    tr_ptrArrayAppend( &tier->trackers, tracker );
492    dbgmsg( tier, "adding tracker %s", announce );
493
494    if( !tier->currentTracker )
495        tierIncrementTracker( tier );
496}
497
498
499/***
500****
501***/
502
503/**
504 * @brief Opaque, per-torrent data structure for tracker announce information
505 *
506 * this opaque data structure can be found in tr_torrent.tiers
507 */
508typedef struct tr_torrent_tiers
509{
510    tr_ptrArray tiers;
511    tr_publisher publisher;
512}
513tr_torrent_tiers;
514
515static tr_torrent_tiers*
516tiersNew( void )
517{
518    tr_torrent_tiers * tiers = tr_new0( tr_torrent_tiers, 1 );
519    tiers->tiers = TR_PTR_ARRAY_INIT;
520    tiers->publisher = TR_PUBLISHER_INIT;
521    return tiers;
522}
523
524static void
525tiersFree( tr_torrent_tiers * tiers )
526{
527    tr_publisherDestruct( &tiers->publisher );
528    tr_ptrArrayDestruct( &tiers->tiers, tierFree );
529    tr_free( tiers );
530}
531
532static tr_tier*
533getTier( tr_announcer * announcer, int torrentId, int tierId )
534{
535    tr_tier * tier = NULL;
536
537    if( announcer )
538    {
539        tr_torrent * tor = tr_torrentFindFromId( announcer->session, torrentId );
540
541        if( tor && tor->tiers )
542        {
543            int i;
544            tr_ptrArray * tiers = &tor->tiers->tiers;
545            const int n = tr_ptrArraySize( tiers );
546            for( i=0; !tier && i<n; ++i )
547            {
548                tr_tier * tmp = tr_ptrArrayNth( tiers, i );
549                if( tmp->key == tierId )
550                    tier = tmp;
551            }
552        }
553    }
554
555    return tier;
556}
557
558/***
559****  PUBLISH
560***/
561
562static const tr_tracker_event emptyEvent = { 0, NULL, NULL, 0, 0 };
563
564static void
565publishMessage( tr_tier * tier, const char * msg, int type )
566{
567    if( tier && tier->tor && tier->tor->tiers )
568    {
569        tr_torrent_tiers * tiers = tier->tor->tiers;
570        tr_tracker_event event = emptyEvent;
571        event.messageType = type;
572        event.text = msg;
573        tr_publisherPublish( &tiers->publisher, tier, &event );
574    }
575}
576
577static void
578publishErrorClear( tr_tier * tier )
579{
580    publishMessage( tier, NULL, TR_TRACKER_ERROR_CLEAR );
581}
582
583static void
584publishErrorMessageAndStop( tr_tier * tier, const char * msg )
585{
586    tier->isRunning = FALSE;
587
588    publishMessage( tier, msg, TR_TRACKER_ERROR );
589}
590
591static void
592publishWarning( tr_tier * tier, const char * msg )
593{
594    publishMessage( tier, msg, TR_TRACKER_WARNING );
595}
596
597static int
598publishNewPeers( tr_tier * tier, tr_bool allAreSeeds,
599                 const void * compact, int compactLen )
600{
601    tr_tracker_event e = emptyEvent;
602
603    e.messageType = TR_TRACKER_PEERS;
604    e.allAreSeeds = allAreSeeds;
605    e.compact = compact;
606    e.compactLen = compactLen;
607
608    if( compactLen )
609        tr_publisherPublish( &tier->tor->tiers->publisher, tier, &e );
610
611    return compactLen / 6;
612}
613
614static int
615publishNewPeersCompact( tr_tier * tier, tr_bool allAreSeeds,
616                        const void * compact, int compactLen )
617{
618    int i;
619    const uint8_t *compactWalk;
620    uint8_t *array, *walk;
621    const int peerCount = compactLen / 6;
622    const int arrayLen = peerCount * ( sizeof( tr_address ) + 2 );
623    tr_address addr;
624    tr_port port;
625
626    addr.type = TR_AF_INET;
627    memset( &addr.addr, 0, sizeof( addr.addr ) );
628    array = tr_new( uint8_t, arrayLen );
629    for ( i=0, walk=array, compactWalk=compact ; i<peerCount ; ++i )
630    {
631        memcpy( &addr.addr.addr4, compactWalk, 4 );
632        memcpy( &port, compactWalk + 4, 2 );
633
634        memcpy( walk, &addr, sizeof( addr ) );
635        memcpy( walk + sizeof( addr ), &port, 2 );
636
637        walk += sizeof( tr_address ) + 2;
638        compactWalk += 6;
639    }
640
641    publishNewPeers( tier, allAreSeeds, array, arrayLen );
642
643    tr_free( array );
644
645    return peerCount;
646}
647
648static int
649publishNewPeersCompact6( tr_tier * tier, tr_bool allAreSeeds,
650                         const void * compact, int compactLen )
651{
652    int i;
653    const uint8_t *compactWalk;
654    uint8_t *array, *walk;
655    const int peerCount = compactLen / 18;
656    const int arrayLen = peerCount * ( sizeof( tr_address ) + 2 );
657    tr_address addr;
658    tr_port port;
659
660    addr.type = TR_AF_INET6;
661    memset( &addr.addr, 0, sizeof( addr.addr ) );
662    array = tr_new( uint8_t, arrayLen );
663    for ( i = 0, walk = array, compactWalk = compact ; i < peerCount ; ++i )
664    {
665        memcpy( &addr.addr.addr6, compactWalk, 16 );
666        memcpy( &port, compactWalk + 16, 2 );
667        compactWalk += 18;
668
669        memcpy( walk, &addr, sizeof( addr ) );
670        memcpy( walk + sizeof( addr ), &port, 2 );
671        walk += sizeof( tr_address ) + 2;
672    }
673    publishNewPeers( tier, allAreSeeds, array, arrayLen );
674    tr_free( array );
675
676    return peerCount;
677}
678
679static char*
680createAnnounceURL( const tr_announcer     * announcer,
681                   const tr_torrent       * torrent,
682                   const tr_tier          * tier,
683                   const char             * eventName )
684{
685    const int isStopping = !strcmp( eventName, "stopped" );
686    const int numwant = isStopping ? 0 : NUMWANT;
687    const tr_tracker_item  * tracker = tier->currentTracker;
688    const char * ann = tracker->announce;
689    struct evbuffer * buf = evbuffer_new( );
690    char * ret;
691    const char * str;
692    const unsigned char * ipv6;
693
694    evbuffer_expand( buf, 2048 );
695
696    evbuffer_add_printf( buf, "%s"
697                              "%c"
698                              "info_hash=%s"
699                              "&peer_id=%s"
700                              "&port=%d"
701                              "&uploaded=%" PRIu64
702                              "&downloaded=%" PRIu64
703                              "&left=%" PRIu64
704                              "&numwant=%d"
705                              "&key=%s"
706                              "&compact=1"
707                              "&supportcrypto=1",
708                              ann,
709                              strchr( ann, '?' ) ? '&' : '?',
710                              torrent->info.hashEscaped,
711                              torrent->peer_id,
712                              (int)tr_sessionGetPeerPort( announcer->session ),
713                              tier->byteCounts[TR_ANN_UP],
714                              tier->byteCounts[TR_ANN_DOWN],
715                              tr_cpLeftUntilComplete( &torrent->completion ),
716                              numwant,
717                              tracker->key_param );
718
719    if( announcer->session->encryptionMode == TR_ENCRYPTION_REQUIRED )
720        evbuffer_add_printf( buf, "&requirecrypto=1" );
721
722    if( tier->byteCounts[TR_ANN_CORRUPT] )
723        evbuffer_add_printf( buf, "&corrupt=%" PRIu64, tier->byteCounts[TR_ANN_CORRUPT] );
724
725    str = eventName;
726    if( str && *str )
727        evbuffer_add_printf( buf, "&event=%s", str );
728
729    str = tracker->tracker_id;
730    if( str && *str )
731        evbuffer_add_printf( buf, "&trackerid=%s", str );
732
733    /* There are two incompatible techniques for announcing an IPv6 address.
734       BEP-7 suggests adding an "ipv6=" parameter to the announce URL,
735       while OpenTracker requires that peers announce twice, once over IPv4
736       and once over IPv6.
737
738       To be safe, we should do both: add the "ipv6=" parameter and
739       announce twice.  At any rate, we're already computing our IPv6
740       address (for the LTEP handshake), so this comes for free. */
741
742    ipv6 = tr_globalIPv6( );
743    if( ipv6 ) {
744        char ipv6_readable[INET6_ADDRSTRLEN];
745        inet_ntop( AF_INET6, ipv6, ipv6_readable, INET6_ADDRSTRLEN );
746        evbuffer_add_printf( buf, "&ipv6=");
747        tr_http_escape( buf, ipv6_readable, strlen(ipv6_readable), TRUE );
748    }
749
750    ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
751    dbgmsg( tier, "announce URL is \"%s\"", ret );
752    evbuffer_free( buf );
753    return ret;
754}
755
756
757/***
758****
759***/
760
761static tr_bool
762announceURLIsSupported( const char * announce )
763{
764    return ( announce != NULL )
765        && ( strstr( announce, "tracker.thepiratebay.org" ) == NULL ) /* dead */
766        && ( ( strstr( announce, "http://" ) == announce ) ||
767             ( strstr( announce, "https://" ) == announce ) );
768}
769
770static void
771addTorrentToTier( tr_announcer * announcer, tr_torrent_tiers * tiers, tr_torrent * tor )
772{
773    int i, n;
774    const tr_tracker_info ** infos;
775    const int trackerCount = tor->info.trackerCount;
776    const tr_tracker_info  * trackers = tor->info.trackers;
777
778    /* get the trackers that we support... */
779    infos = tr_new0( const tr_tracker_info*, trackerCount );
780    for( i=n=0; i<trackerCount; ++i )
781        if( announceURLIsSupported( trackers[i].announce ) )
782            infos[n++] = &trackers[i];
783
784    /* build our private table of tiers... */
785    if( n > 0 )
786    {
787        int tierIndex = -1;
788        tr_tier * tier = NULL;
789
790        for( i=0; i<n; ++i )
791        {
792            const tr_tracker_info * info = infos[i];
793
794            if( info->tier != tierIndex )
795                tier = NULL;
796
797            tierIndex = info->tier;
798
799            if( tier == NULL ) {
800                tier = tierNew( tor );
801                dbgmsg( tier, "adding tier" );
802                tr_ptrArrayAppend( &tiers->tiers, tier );
803            }
804
805            tierAddTracker( announcer, tier, info->announce, info->scrape, info->id );
806        }
807    }
808
809    tr_free( infos );
810}
811
812tr_torrent_tiers *
813tr_announcerAddTorrent( tr_announcer * announcer, tr_torrent * tor )
814{
815    tr_torrent_tiers * tiers;
816
817    assert( announcer != NULL );
818    assert( tr_isTorrent( tor ) );
819
820    tiers = tiersNew( );
821
822    addTorrentToTier( announcer, tiers, tor );
823
824    return tiers;
825}
826
827static void
828tierAddAnnounce( tr_tier * tier, const char * announceEvent, time_t announceAt );
829
830void
831tr_announcerResetTorrent( tr_announcer * announcer, tr_torrent * tor )
832{
833    tr_ptrArray oldTiers = TR_PTR_ARRAY_INIT;
834
835    /* if we had tiers already, make a backup of them */
836    if( tor->tiers != NULL )
837    {
838        oldTiers = tor->tiers->tiers;
839        tor->tiers->tiers = TR_PTR_ARRAY_INIT;
840    }
841
842    /* create the new tier/tracker structs */
843    addTorrentToTier( announcer, tor->tiers, tor );
844
845    /* if we had tiers already, merge their state into the new structs */
846    if( !tr_ptrArrayEmpty( &oldTiers ) )
847    {
848        int i, in;
849        for( i=0, in=tr_ptrArraySize(&oldTiers); i<in; ++i )
850        {
851            int j, jn;
852            const tr_tier * o = tr_ptrArrayNth( &oldTiers, i );
853
854            if( o->currentTracker == NULL )
855                continue;
856
857            for( j=0, jn=tr_ptrArraySize(&tor->tiers->tiers); j<jn; ++j )
858            {
859                int k, kn;
860                tr_tier * t = tr_ptrArrayNth(&tor->tiers->tiers,j);
861
862                for( k=0, kn=tr_ptrArraySize(&t->trackers); k<kn; ++k )
863                {
864                    tr_tracker_item * item = tr_ptrArrayNth(&t->trackers,k);
865                    if( strcmp( o->currentTracker->announce, item->announce ) )
866                        continue;
867                    tierCopyAttributes( t, o );
868                    t->currentTracker = item;
869                    t->currentTrackerIndex = k;
870                    trackerItemCopyAttributes( item, o->currentTracker );
871                    dbgmsg( t, "attributes copied to tier %d, tracker %d"
872                                               "from tier %d, tracker %d",
873                            i, o->currentTrackerIndex, j, k );
874
875                }
876            }
877        }
878    }
879
880    /* kickstart any tiers that didn't get started */
881    if( tor->isRunning )
882    {
883        int i, n;
884        const time_t now = tr_time( );
885        tr_tier ** tiers = (tr_tier**) tr_ptrArrayPeek( &tor->tiers->tiers, &n );
886        for( i=0; i<n; ++i ) {
887            tr_tier * tier = tiers[i];
888            if( !tier->isRunning )   
889                tierAddAnnounce( tier, STARTED, now );
890        }
891    }
892
893    /* cleanup */
894    tr_ptrArrayDestruct( &oldTiers, tierFree );
895}
896
897tr_publisher_tag
898tr_announcerSubscribe( struct tr_torrent_tiers   * tiers,
899                       tr_delivery_func            func,
900                       void                      * userData )
901{
902    return tr_publisherSubscribe( &tiers->publisher, func, userData );
903}
904
905void
906tr_announcerUnsubscribe( struct tr_torrent_tiers  * tiers,
907                         tr_publisher_tag           tag )
908{
909    if( tiers )
910        tr_publisherUnsubscribe( &tiers->publisher, tag );
911}
912
913static tr_bool
914tierCanManualAnnounce( const tr_tier * tier )
915{
916    return tier->isRunning
917        && tier->manualAnnounceAllowedAt <= tr_time( );
918}
919
920tr_bool
921tr_announcerCanManualAnnounce( const tr_torrent * tor )
922{
923    int i;
924    int n;
925    const tr_tier ** tiers;
926
927    assert( tr_isTorrent( tor ) );
928    assert( tor->tiers != NULL );
929
930    n = tr_ptrArraySize( &tor->tiers->tiers );
931    tiers = (const tr_tier**) tr_ptrArrayBase( &tor->tiers->tiers );
932    for( i=0; i<n; ++i )
933        if( tierCanManualAnnounce( tiers[i] ) )
934            return TRUE;
935
936    return FALSE;
937}
938
939time_t
940tr_announcerNextManualAnnounce( const tr_torrent * tor )
941{
942    int i;
943    int n;
944    const tr_torrent_tiers * tiers;
945    time_t ret = ~(time_t)0;
946
947    assert( tr_isTorrent( tor  ) );
948
949    tiers = tor->tiers;
950    n = tr_ptrArraySize( &tiers->tiers );
951    for( i=0; i<n; ++i ) {
952        tr_tier * tier = tr_ptrArrayNth( (tr_ptrArray*)&tiers->tiers, i );
953        if( tier->isRunning )
954            ret = MIN( ret, tier->manualAnnounceAllowedAt );
955    }
956
957    return ret;
958}
959
960static void
961tierAddAnnounce( tr_tier * tier, const char * announceEvent, time_t announceAt )
962{
963    assert( tier != NULL );
964    assert( announceEvent != NULL );
965
966    tr_ptrArrayAppend( &tier->announceEvents, (void*)announceEvent );
967    tier->announceAt = announceAt;
968
969    dbgmsg( tier, "appended event \"%s\"; announcing in %d seconds\n", announceEvent, (int)difftime(announceAt,time(NULL)) );
970}
971
972static void
973torrentAddAnnounce( tr_torrent * tor, const char * announceEvent, time_t announceAt )
974{
975    int i;
976    int n;
977    tr_torrent_tiers * tiers;
978
979    assert( tr_isTorrent( tor ) );
980
981    tiers = tor->tiers;
982    n = tr_ptrArraySize( &tiers->tiers );
983    for( i=0; i<n; ++i )
984        tierAddAnnounce( tr_ptrArrayNth( &tiers->tiers, i ), announceEvent, announceAt );
985}
986
987void
988tr_announcerTorrentStarted( tr_torrent * tor )
989{
990    torrentAddAnnounce( tor, STARTED, tr_time( ) );
991}
992void
993tr_announcerManualAnnounce( tr_torrent * tor )
994{
995    torrentAddAnnounce( tor, "", tr_time( ) );
996}
997void
998tr_announcerTorrentStopped( tr_torrent * tor )
999{
1000    torrentAddAnnounce( tor, "stopped", tr_time( ) );
1001}
1002void
1003tr_announcerTorrentCompleted( tr_torrent * tor )
1004{
1005    torrentAddAnnounce( tor, "completed", tr_time( ) );
1006}
1007void
1008tr_announcerChangeMyPort( tr_torrent * tor )
1009{
1010    tr_announcerTorrentStarted( tor );
1011}
1012
1013/***
1014****
1015***/
1016
1017void
1018tr_announcerAddBytes( tr_torrent * tor, int type, uint32_t byteCount )
1019{
1020    int i, n;
1021    tr_torrent_tiers * tiers;
1022
1023    assert( tr_isTorrent( tor ) );
1024    assert( type==TR_ANN_UP || type==TR_ANN_DOWN || type==TR_ANN_CORRUPT );
1025
1026    tiers = tor->tiers;
1027    n = tr_ptrArraySize( &tiers->tiers );
1028    for( i=0; i<n; ++i )
1029    {
1030        tr_tier * tier = tr_ptrArrayNth( &tiers->tiers, i );
1031        tier->byteCounts[ type ] += byteCount;
1032    }
1033}
1034
1035void
1036tr_announcerSubtractBytes( tr_torrent * tor, int type, uint32_t byteCount )
1037{
1038    int i, n;
1039    tr_torrent_tiers * tiers;
1040
1041    assert( tr_isTorrent( tor ) );
1042    assert( type==TR_ANN_UP || type==TR_ANN_DOWN || type==TR_ANN_CORRUPT );
1043
1044    tiers = tor->tiers;
1045    n = tr_ptrArraySize( &tiers->tiers );
1046    for( i=0; i<n; ++i )
1047    {
1048        tr_tier * tier = tr_ptrArrayNth( &tiers->tiers, i );
1049        uint64_t * setme = &tier->byteCounts[type];
1050        *setme -= MIN( *setme, byteCount );
1051    }
1052}
1053
1054/***
1055****
1056***/
1057
1058void
1059tr_announcerRemoveTorrent( tr_announcer * announcer, tr_torrent * tor )
1060{
1061    assert( tr_isTorrent( tor ) );
1062
1063    if( tor->tiers )
1064    {
1065        int i;
1066        const int n = tr_ptrArraySize( &tor->tiers->tiers );
1067        for( i=0; i<n; ++i )
1068        {
1069            tr_tier * tier = tr_ptrArrayNth( &tor->tiers->tiers, i );
1070
1071            if( tier->isRunning )
1072            {
1073                struct stop_message * s = tr_new0( struct stop_message, 1 );
1074                s->up = tier->byteCounts[TR_ANN_UP];
1075                s->down = tier->byteCounts[TR_ANN_DOWN];
1076                s->url = createAnnounceURL( announcer, tor, tier, "stopped" );
1077                s->host = tier->currentTracker->host;
1078                tr_ptrArrayInsertSorted( &announcer->stops, s, compareStops );
1079            }
1080        }
1081
1082        tiersFree( tor->tiers );
1083        tor->tiers = NULL;
1084    }
1085}
1086
1087/* return true if (1) we've tried it recently AND (2) it didn't respond... */
1088static tr_bool
1089hostIsNotResponding( const tr_host * host, const time_t now )
1090{
1091    tr_bool b = ( host->lastRequestTime )
1092             && ( host->lastRequestTime >= ( now - SLOW_HOST_PENALTY_SECS ) )
1093             && ( host->lastResponseInterval > MAX_TRACKER_RESPONSE_TIME_SECS );
1094    return b;
1095}
1096
1097static tr_bool
1098tierIsNotResponding( const tr_tier * tier, const time_t now )
1099{
1100    return !tier->currentTracker
1101        || hostIsNotResponding( tier->currentTracker->host, now );
1102}
1103
1104static int
1105getRetryInterval( const tr_host * host )
1106{
1107    int interval;
1108    const int jitter = tr_cryptoWeakRandInt( 120 );
1109    const time_t timeSinceLastSuccess = tr_time() - host->lastSuccessfulRequest;
1110         if( timeSinceLastSuccess < 15*60 ) interval = 0;
1111    else if( timeSinceLastSuccess < 30*60 ) interval = 60*4;
1112    else if( timeSinceLastSuccess < 45*60 ) interval = 60*8;
1113    else if( timeSinceLastSuccess < 60*60 ) interval = 60*16;
1114    else                                    interval = 60*32;
1115    return interval + jitter;
1116}
1117
1118static int
1119compareTiers( const void * va, const void * vb )
1120{
1121    int ret = 0;
1122    tr_bool af, bf;
1123    const tr_tier * a = *(const tr_tier**)va;
1124    const tr_tier * b = *(const tr_tier**)vb;
1125
1126    /* working domains come before non-working */
1127    if( !ret ) {
1128        const time_t now = tr_time( );
1129        af = tierIsNotResponding( a, now );
1130        bf = tierIsNotResponding( b, now );
1131        if( af != bf )
1132            ret = !af ? -1 : 1;
1133    }
1134
1135    /* stops come before starts */
1136    if( !ret ) {
1137        af = a->tor->isRunning;
1138        bf = b->tor->isRunning;
1139        if( af != bf )
1140            ret = af ? 1 : -1;
1141    }
1142
1143    /* upload comes before download */
1144    if( !ret )
1145        ret = compareTransfer( a->byteCounts[TR_ANN_UP], a->byteCounts[TR_ANN_DOWN],
1146                               b->byteCounts[TR_ANN_UP], b->byteCounts[TR_ANN_DOWN] );
1147
1148    /* incomplete comes before complete */
1149    if( !ret ) {
1150        af = a->tor->completeness == TR_LEECH;
1151        bf = b->tor->completeness == TR_LEECH;
1152        if( af != bf )
1153            return af ? -1 : 1;
1154    }
1155
1156    /* private before public */
1157    if( !ret ) {
1158        af = tr_torrentIsPrivate( a->tor );
1159        bf = tr_torrentIsPrivate( b->tor );
1160        if( af != bf )
1161            ret = af ? -1 : 1;
1162    }
1163
1164    return ret;
1165}
1166
1167static uint8_t *
1168parseOldPeers( tr_benc * bePeers, size_t *  byteCount )
1169{
1170    int       i;
1171    uint8_t * array, *walk;
1172    const int peerCount = bePeers->val.l.count;
1173
1174    assert( tr_bencIsList( bePeers ) );
1175
1176    array = tr_new( uint8_t, peerCount * ( sizeof( tr_address ) + 2 ) );
1177
1178    for( i = 0, walk = array; i < peerCount; ++i )
1179    {
1180        const char * s;
1181        int64_t      itmp;
1182        tr_address   addr;
1183        tr_port      port;
1184        tr_benc    * peer = &bePeers->val.l.vals[i];
1185
1186        if( tr_bencDictFindStr( peer, "ip", &s ) )
1187            if( tr_pton( s, &addr ) == NULL )
1188                continue;
1189
1190        if( !tr_bencDictFindInt( peer, "port", &itmp )
1191                || itmp < 0
1192                || itmp > USHRT_MAX )
1193            continue;
1194
1195        memcpy( walk, &addr, sizeof( tr_address ) );
1196        port = htons( itmp );
1197        memcpy( walk + sizeof( tr_address ), &port, 2 );
1198        walk += sizeof( tr_address ) + 2;
1199    }
1200
1201    *byteCount = peerCount * sizeof( tr_address ) + 2;
1202    return array;
1203}
1204
1205static tr_bool
1206parseAnnounceResponse( tr_tier     * tier,
1207                       const char  * response,
1208                       size_t        responseLen,
1209                       tr_bool     * gotScrape )
1210{
1211    tr_benc benc;
1212    tr_bool success = FALSE;
1213    int scrapeFields = 0;
1214    const int bencLoaded = !tr_bencLoad( response, responseLen, &benc, NULL );
1215
1216    dbgmsg( tier, "response len: %d, isBenc: %d", (int)responseLen, (int)bencLoaded );
1217    publishErrorClear( tier );
1218    if( bencLoaded && tr_bencIsDict( &benc ) )
1219    {
1220        int peerCount = 0;
1221        int incomplete = -1;
1222        size_t rawlen;
1223        int64_t i;
1224        tr_benc * tmp;
1225        const char * str;
1226        const uint8_t * raw;
1227        tr_bool gotPeers = FALSE;
1228
1229        success = TRUE;
1230
1231        if( tr_bencDictFindStr( &benc, "failure reason", &str ) )
1232        {
1233            tr_strlcpy( tier->lastAnnounceStr, str,
1234                        sizeof( tier->lastAnnounceStr ) );
1235            dbgmsg( tier, "tracker gave \"%s\"", str );
1236            publishMessage( tier, str, TR_TRACKER_ERROR );
1237            success = FALSE;
1238        }
1239
1240        if( tr_bencDictFindStr( &benc, "warning message", &str ) )
1241        {
1242            tr_strlcpy( tier->lastAnnounceStr, str,
1243                        sizeof( tier->lastAnnounceStr ) );
1244            dbgmsg( tier, "tracker gave \"%s\"", str );
1245            publishWarning( tier, str );
1246        }
1247
1248        if( tr_bencDictFindInt( &benc, "interval", &i ) )
1249        {
1250            dbgmsg( tier, "setting interval to %d", (int)i );
1251            tier->announceIntervalSec = i;
1252        }
1253
1254        if( tr_bencDictFindInt( &benc, "min interval", &i ) )
1255        {
1256            dbgmsg( tier, "setting min interval to %d", (int)i );
1257            tier->announceMinIntervalSec = i;
1258        }
1259
1260        if( tr_bencDictFindStr( &benc, "tracker id", &str ) )
1261        {
1262            tier->currentTracker->tracker_id = tr_strdup( str );
1263        }
1264
1265        if( tr_bencDictFindInt( &benc, "complete", &i ) )
1266        {
1267            ++scrapeFields;
1268            tier->currentTracker->seederCount = i;
1269        }
1270
1271        if( tr_bencDictFindInt( &benc, "incomplete", &i ) )
1272        {
1273            ++scrapeFields;
1274            tier->currentTracker->leecherCount = incomplete = i;
1275        }
1276
1277        if( tr_bencDictFindInt( &benc, "downloaded", &i ) )
1278        {
1279            ++scrapeFields;
1280            tier->currentTracker->downloadCount = i;
1281        }
1282
1283        if( tr_bencDictFindRaw( &benc, "peers", &raw, &rawlen ) )
1284        {
1285            /* "compact" extension */
1286            const int allAreSeeds = incomplete == 0;
1287            peerCount += publishNewPeersCompact( tier, allAreSeeds, raw, rawlen );
1288            gotPeers = TRUE;
1289        }
1290        else if( tr_bencDictFindList( &benc, "peers", &tmp ) )
1291        {
1292            /* original version of peers */
1293            const tr_bool allAreSeeds = incomplete == 0;
1294            size_t byteCount = 0;
1295            uint8_t * array = parseOldPeers( tmp, &byteCount );
1296            peerCount += publishNewPeers( tier, allAreSeeds, array, byteCount );
1297            gotPeers = TRUE;
1298            tr_free( array );
1299        }
1300
1301        if( tr_bencDictFindRaw( &benc, "peers6", &raw, &rawlen ) )
1302        {
1303            /* "compact" extension */
1304            const tr_bool allAreSeeds = incomplete == 0;
1305            peerCount += publishNewPeersCompact6( tier, allAreSeeds, raw, rawlen );
1306            gotPeers = TRUE;
1307        }
1308
1309        if( tier->lastAnnounceStr[0] == '\0' )
1310            tr_strlcpy( tier->lastAnnounceStr, _( "Success" ),
1311                        sizeof( tier->lastAnnounceStr ) );
1312
1313        if( gotPeers )
1314            tier->lastAnnouncePeerCount = peerCount;
1315    }
1316
1317    if( bencLoaded )
1318        tr_bencFree( &benc );
1319
1320    *gotScrape = scrapeFields >= 2;
1321
1322    return success;
1323}
1324
1325struct announce_data
1326{
1327    int torrentId;
1328    int tierId;
1329    time_t timeSent;
1330    const char * event;
1331
1332    /** If the request succeeds, the value for tier's "isRunning" flag */
1333    tr_bool isRunningOnSuccess;
1334};
1335
1336static void
1337onAnnounceDone( tr_session   * session,
1338                long           responseCode,
1339                const void   * response,
1340                size_t         responseLen,
1341                void         * vdata )
1342{
1343    tr_announcer * announcer = session->announcer;
1344    struct announce_data * data = vdata;
1345    tr_tier * tier = getTier( announcer, data->torrentId, data->tierId );
1346    tr_bool gotScrape = FALSE;
1347    tr_bool success = FALSE;
1348    const time_t now = time ( NULL );
1349    const char * announceEvent = data->event;
1350    const tr_bool isStopped = !strcmp( announceEvent, "stopped" );
1351
1352    if( announcer && tier )
1353    {
1354        if( tier->currentTracker->host )
1355        {
1356            tr_host * host = tier->currentTracker->host;
1357            host->lastRequestTime = data->timeSent;
1358            host->lastResponseInterval = now - data->timeSent;
1359        }
1360
1361        tier->lastAnnounceTime = now;
1362
1363        if( responseCode == HTTP_OK )
1364        {
1365            success = parseAnnounceResponse( tier, response, responseLen, &gotScrape );
1366            dbgmsg( tier, "success is %d", success );
1367
1368            if( isStopped )
1369            {
1370                /* now that we've successfully stopped the torrent,
1371                 * we can reset the up/down/corrupt count we've kept
1372                 * for this tracker */
1373                tier->byteCounts[ TR_ANN_UP ] = 0;
1374                tier->byteCounts[ TR_ANN_DOWN ] = 0;
1375                tier->byteCounts[ TR_ANN_CORRUPT ] = 0;
1376            }
1377        }
1378        else if( responseCode )
1379        {
1380            /* %1$ld - http status code, such as 404
1381             * %2$s - human-readable explanation of the http status code */
1382            char * buf = tr_strdup_printf(
1383                _( "tracker gave HTTP Response Code %1$ld (%2$s)" ),
1384                responseCode,
1385                tr_webGetResponseStr( responseCode ) );
1386
1387            tr_strlcpy( tier->lastAnnounceStr, buf,
1388                        sizeof( tier->lastAnnounceStr ) );
1389
1390            /* if the response is serious, *and* if the response may require
1391             * human intervention, then notify the user... otherwise just log it */
1392            if( responseCode >= 400 )
1393                if( tr_torrentIsPrivate( tier->tor ) || ( tier->tor->info.trackerCount < 2 ) )
1394                    publishWarning( tier, buf );
1395            tr_torinf( tier->tor, "%s", buf );
1396            dbgmsg( tier, "%s", buf );
1397
1398            tr_free( buf );
1399        }
1400        else
1401        {
1402            tr_strlcpy( tier->lastAnnounceStr,
1403                        _( "tracker did not respond" ),
1404                        sizeof( tier->lastAnnounceStr ) );
1405            dbgmsg( tier, "%s", tier->lastAnnounceStr );
1406        }
1407    }
1408
1409    if( tier )
1410    {
1411        tier->isAnnouncing = FALSE;
1412
1413        if( responseCode == 0 )
1414        {
1415            const int interval = getRetryInterval( tier->currentTracker->host );
1416            dbgmsg( tier, "No response from tracker... retrying in %d seconds.", interval );
1417            tier->manualAnnounceAllowedAt = ~(time_t)0;
1418            tierAddAnnounce( tier, announceEvent, now + interval );
1419        }
1420        else if( 200 <= responseCode && responseCode <= 299 )
1421        {
1422            const int interval = tier->announceIntervalSec;
1423            dbgmsg( tier, "request succeeded. reannouncing in %d seconds", interval );
1424
1425            if( gotScrape )
1426            {
1427                tier->lastScrapeTime = now;
1428                tier->lastScrapeSucceeded = 1;
1429                tier->scrapeAt = now + tier->scrapeIntervalSec;
1430            }
1431
1432            tier->manualAnnounceAllowedAt = now + tier->announceMinIntervalSec;
1433
1434            /* if we're running and the queue is empty, add the next update */
1435            if( !isStopped && !tr_ptrArraySize( &tier->announceEvents ) )
1436            {
1437                tierAddAnnounce( tier, "", now + interval );
1438            }
1439        }
1440        else if( 300 <= responseCode && responseCode <= 399 )
1441        {
1442            /* how did this get here?  libcurl handles this */
1443            const int interval = 5;
1444            dbgmsg( tier, "got a redirect. retrying in %d seconds", interval );
1445            tierAddAnnounce( tier, announceEvent, now + interval );
1446            tier->manualAnnounceAllowedAt = now + tier->announceMinIntervalSec;
1447        }
1448        else if( 400 <= responseCode && responseCode <= 499 )
1449        {
1450            /* The request could not be understood by the server due to
1451             * malformed syntax. The client SHOULD NOT repeat the
1452             * request without modifications. */
1453            if( tr_torrentIsPrivate( tier->tor ) || ( tier->tor->info.trackerCount < 2 ) )
1454                publishErrorMessageAndStop( tier, _( "Tracker returned a 4xx message" ) );
1455            tier->announceAt = ~(time_t)0;
1456            tier->manualAnnounceAllowedAt = ~(time_t)0;
1457        }
1458        else if( 500 <= responseCode && responseCode <= 599 )
1459        {
1460            /* Response status codes beginning with the digit "5" indicate
1461             * cases in which the server is aware that it has erred or is
1462             * incapable of performing the request.  So we pause a bit and
1463             * try again. */
1464            const int interval = getRetryInterval( tier->currentTracker->host );
1465            tier->manualAnnounceAllowedAt = ~(time_t)0;
1466            tierAddAnnounce( tier, announceEvent, now + interval );
1467        }
1468        else
1469        {
1470            /* WTF did we get?? */
1471            const int interval = 120;
1472            dbgmsg( tier, "Invalid response from tracker... retrying in two minutes." );
1473            tier->manualAnnounceAllowedAt = ~(time_t)0;
1474            tierAddAnnounce( tier, announceEvent, now + interval );
1475        }
1476
1477        tier->lastAnnounceSucceeded = success;
1478        tier->lastAnnounceTimedOut = responseCode == 0;
1479
1480        if( success )
1481        {
1482            tier->isRunning = data->isRunningOnSuccess;
1483
1484            if( tier->currentTracker->host )
1485                tier->currentTracker->host->lastSuccessfulRequest = now;
1486        }
1487        else if( responseCode != HTTP_OK )
1488        {
1489            tierIncrementTracker( tier );
1490
1491            tr_ptrArrayInsert( &tier->announceEvents, (void*)announceEvent, 0 );
1492        }
1493    }
1494
1495    if( announcer != NULL )
1496    {
1497        ++announcer->slotsAvailable;
1498    }
1499
1500    tr_free( data );
1501}
1502
1503static const char*
1504getNextAnnounceEvent( tr_tier * tier )
1505{
1506    int i, n;
1507    int pos = -1;
1508    tr_ptrArray tmp;
1509    char ** events;
1510    const char * str = NULL;
1511
1512    assert( tier != NULL );
1513    assert( tr_isTorrent( tier->tor ) );
1514
1515    /* rule #1: if "stopped" is in the queue, ignore everything before it */
1516    events = (char**) tr_ptrArrayPeek( &tier->announceEvents, &n );
1517    for( i=0; pos<0 && i<n; ++i )
1518        if( !strcmp( events[i], "stopped" ) )
1519            pos = i;
1520
1521    /* rule #2: if the next two events are the same, ignore the first one */
1522    for( i=0; pos<0 && i<=n-2; ++i )
1523        if( strcmp( events[i], events[i+1] ) )
1524            pos = i;
1525
1526    /* otherwise use the next announce event in line */
1527    if( ( pos < 0 ) && ( n > 0 ) )
1528        pos = 0;
1529
1530    /* rule #3: BEP 21: "In order to tell the tracker that a peer is a
1531     * partial seed, it MUST send an event=paused parameter in every
1532     * announce while it is a partial seed." */
1533    str = pos>=0 ? events[pos] : NULL;
1534    if( tr_cpGetStatus( &tier->tor->completion ) == TR_PARTIAL_SEED )
1535        if( !str || !strcmp( str, "stopped" ) )
1536            str = "paused";
1537
1538    /* announceEvents array upkeep */
1539    tmp = TR_PTR_ARRAY_INIT;
1540    for( i=pos+1; i<n; ++i )
1541        tr_ptrArrayAppend( &tmp, events[i] );
1542    tr_ptrArrayDestruct( &tier->announceEvents, NULL );
1543    tier->announceEvents = tmp;
1544
1545    return str;
1546}
1547
1548static void
1549tierAnnounce( tr_announcer * announcer, tr_tier * tier )
1550{
1551    const char * announceEvent = getNextAnnounceEvent( tier );
1552
1553    assert( !tier->isAnnouncing );
1554
1555    if( announceEvent != NULL )
1556    {
1557        char * url;
1558        struct announce_data * data;
1559        const tr_torrent * tor = tier->tor;
1560        const time_t now = tr_time( );
1561
1562        data = tr_new0( struct announce_data, 1 );
1563        data->torrentId = tr_torrentId( tor );
1564        data->tierId = tier->key;
1565        data->isRunningOnSuccess = tor->isRunning;
1566        data->timeSent = now;
1567        data->event = announceEvent;
1568        url = createAnnounceURL( announcer, tor, tier, data->event );
1569
1570        tier->isAnnouncing = TRUE;
1571        tier->lastAnnounceStartTime = now;
1572        --announcer->slotsAvailable;
1573        tr_webRun( announcer->session, url, NULL, onAnnounceDone, data );
1574
1575        tr_free( url );
1576    }
1577}
1578
1579static tr_bool
1580parseScrapeResponse( tr_tier     * tier,
1581                     const char  * response,
1582                     size_t        responseLen,
1583                     char        * result,
1584                     size_t        resultlen )
1585{
1586    tr_bool success = FALSE;
1587    tr_benc benc, *files;
1588    const int bencLoaded = !tr_bencLoad( response, responseLen, &benc, NULL );
1589    if( bencLoaded && tr_bencDictFindDict( &benc, "files", &files ) )
1590    {
1591        const char * key;
1592        tr_benc * val;
1593        int i = 0;
1594        while( tr_bencDictChild( files, i++, &key, &val ))
1595        {
1596            int64_t intVal;
1597            tr_benc * flags;
1598
1599            if( memcmp( tier->tor->info.hash, key, SHA_DIGEST_LENGTH ) )
1600                continue;
1601
1602            success = TRUE;
1603            publishErrorClear( tier );
1604
1605            if( ( tr_bencDictFindInt( val, "complete", &intVal ) ) )
1606                tier->currentTracker->seederCount = intVal;
1607
1608            if( ( tr_bencDictFindInt( val, "incomplete", &intVal ) ) )
1609                tier->currentTracker->leecherCount = intVal;
1610
1611            if( ( tr_bencDictFindInt( val, "downloaded", &intVal ) ) )
1612                tier->currentTracker->downloadCount = intVal;
1613
1614            if( ( tr_bencDictFindInt( val, "downloaders", &intVal ) ) )
1615                tier->currentTracker->downloaderCount = intVal;
1616
1617            if( tr_bencDictFindDict( val, "flags", &flags ) )
1618                if( ( tr_bencDictFindInt( flags, "min_request_interval", &intVal ) ) )
1619                    tier->scrapeIntervalSec = MAX( DEFAULT_SCRAPE_INTERVAL_SEC, (int)intVal );
1620
1621            tr_tordbg( tier->tor,
1622                       "Scrape successful. Rescraping in %d seconds.",
1623                       tier->scrapeIntervalSec );
1624        }
1625    }
1626
1627    if( bencLoaded )
1628        tr_bencFree( &benc );
1629
1630    if( success )
1631        tr_strlcpy( result, _( "Success" ), resultlen );
1632    else
1633        tr_strlcpy( result, _( "Error parsing response" ), resultlen );
1634
1635    return success;
1636}
1637
1638static void
1639onScrapeDone( tr_session   * session,
1640              long           responseCode,
1641              const void   * response,
1642              size_t         responseLen,
1643              void         * vdata )
1644{
1645    tr_bool success = FALSE;
1646    tr_announcer * announcer = session->announcer;
1647    struct announce_data * data = vdata;
1648    tr_tier * tier = getTier( announcer, data->torrentId, data->tierId );
1649    const time_t now = tr_time( );
1650
1651    if( announcer )
1652        ++announcer->slotsAvailable;
1653
1654    if( announcer && tier )
1655    {
1656        tier->isScraping = FALSE;
1657        tier->lastScrapeTime = now;
1658
1659        if( tier->currentTracker->host )
1660        {
1661            tr_host * host = tier->currentTracker->host;
1662            host->lastRequestTime = data->timeSent;
1663            host->lastResponseInterval = now - data->timeSent;
1664        }
1665
1666        if( 200 <= responseCode && responseCode <= 299 )
1667        {
1668            const int interval = tier->scrapeIntervalSec;
1669            tier->scrapeAt = now + interval;
1670
1671            if( responseCode == HTTP_OK )
1672                success = parseScrapeResponse( tier, response, responseLen,
1673                                               tier->lastScrapeStr, sizeof( tier->lastScrapeStr ) );
1674            else
1675                tr_snprintf( tier->lastScrapeStr, sizeof( tier->lastScrapeStr ),
1676                             _( "tracker gave HTTP Response Code %1$ld (%2$s)" ),
1677                             responseCode, tr_webGetResponseStr( responseCode ) );
1678            tr_tordbg( tier->tor, "%s", tier->lastScrapeStr );
1679        }
1680        else if( 300 <= responseCode && responseCode <= 399 )
1681        {
1682            /* this shouldn't happen; libcurl should handle this */
1683            const int interval = 5;
1684            tier->scrapeAt = now + interval;
1685            tr_snprintf( tier->lastScrapeStr, sizeof( tier->lastScrapeStr ),
1686                         "Got a redirect. Retrying in %d seconds", interval );
1687            tr_tordbg( tier->tor, "%s", tier->lastScrapeStr );
1688        }
1689        else
1690        {
1691            const int interval = getRetryInterval( tier->currentTracker->host );
1692
1693            /* Don't retry on a 4xx.
1694             * Retry at growing intervals on a 5xx */
1695            if( 400 <= responseCode && responseCode <= 499 )
1696                tier->scrapeAt = 0;
1697            else
1698                tier->scrapeAt = now + interval;
1699
1700            /* %1$ld - http status code, such as 404
1701             * %2$s - human-readable explanation of the http status code */
1702            if( !responseCode )
1703                tr_strlcpy( tier->lastScrapeStr, _( "tracker did not respond" ),
1704                            sizeof( tier->lastScrapeStr ) );
1705            else
1706                tr_snprintf( tier->lastScrapeStr, sizeof( tier->lastScrapeStr ),
1707                             _( "tracker gave HTTP Response Code %1$ld (%2$s)" ),
1708                             responseCode, tr_webGetResponseStr( responseCode ) );
1709        }
1710
1711        tier->lastScrapeSucceeded = success;
1712
1713        if( success && tier->currentTracker->host )
1714            tier->currentTracker->host->lastSuccessfulRequest = now;
1715    }
1716
1717    tr_free( data );
1718}
1719
1720static void
1721tierScrape( tr_announcer * announcer, tr_tier * tier )
1722{
1723    char * url;
1724    const char * scrape;
1725    struct announce_data * data;
1726    const time_t now = tr_time( );
1727
1728    assert( tier );
1729    assert( !tier->isScraping );
1730    assert( tier->currentTracker != NULL );
1731    assert( tr_isTorrent( tier->tor ) );
1732
1733    data = tr_new0( struct announce_data, 1 );
1734    data->torrentId = tr_torrentId( tier->tor );
1735    data->tierId = tier->key;
1736
1737    scrape = tier->currentTracker->scrape;
1738
1739    url = tr_strdup_printf( "%s%cinfo_hash=%s",
1740                            scrape,
1741                            strchr( scrape, '?' ) ? '&' : '?',
1742                            tier->tor->info.hashEscaped );
1743
1744    tier->isScraping = TRUE;
1745    tier->lastScrapeStartTime = now;
1746    --announcer->slotsAvailable;
1747    dbgmsg( tier, "scraping \"%s\"", url );
1748    tr_webRun( announcer->session, url, NULL, onScrapeDone, data );
1749
1750    tr_free( url );
1751}
1752
1753static void
1754flushCloseMessages( tr_announcer * announcer )
1755{
1756    int i;
1757    const int n = tr_ptrArraySize( &announcer->stops );
1758
1759    for( i=0; i<n; ++i )
1760    {
1761        struct stop_message * stop = tr_ptrArrayNth( &announcer->stops, i );
1762        tr_webRun( announcer->session, stop->url, NULL, NULL, NULL );
1763        stopFree( stop );
1764    }
1765
1766    tr_ptrArrayClear( &announcer->stops );
1767}
1768
1769static tr_bool
1770tierNeedsToAnnounce( const tr_tier * tier, const time_t now )
1771{
1772    return !tier->isAnnouncing
1773        && !tier->isScraping
1774        && ( tier->announceAt <= now )
1775        && ( tr_ptrArraySize( &tier->announceEvents ) != 0 );
1776}
1777
1778static tr_bool
1779tierNeedsToScrape( const tr_tier * tier, const time_t now )
1780{
1781    return ( !tier->isScraping )
1782        && ( tier->scrapeAt != 0 )
1783        && ( tier->scrapeAt <= now )
1784        && ( tier->currentTracker != NULL )
1785        && ( tier->currentTracker->scrape != NULL );
1786}
1787
1788static void
1789announceMore( tr_announcer * announcer )
1790{
1791    tr_torrent * tor = NULL;
1792    const time_t now = tr_time( );
1793
1794    if( announcer->slotsAvailable > 0 )
1795    {
1796        int i;
1797        int n;
1798        tr_ptrArray announceMe = TR_PTR_ARRAY_INIT;
1799        tr_ptrArray scrapeMe = TR_PTR_ARRAY_INIT;
1800
1801        /* build a list of tiers that need to be announced */
1802        while(( tor = tr_torrentNext( announcer->session, tor ))) {
1803            if( tor->tiers ) {
1804                n = tr_ptrArraySize( &tor->tiers->tiers );
1805                for( i=0; i<n; ++i ) {
1806                    tr_tier * tier = tr_ptrArrayNth( &tor->tiers->tiers, i );
1807                    if( tierNeedsToAnnounce( tier, now ) )
1808                        tr_ptrArrayAppend( &announceMe, tier );
1809                    else if( tierNeedsToScrape( tier, now ) )
1810                        tr_ptrArrayAppend( &scrapeMe, tier );
1811                }
1812            }
1813        }
1814
1815        /* if there are more tiers than slots available, prioritize */
1816        n = tr_ptrArraySize( &announceMe );
1817        if( n > announcer->slotsAvailable )
1818            qsort( tr_ptrArrayBase( &announceMe ), n, sizeof( tr_tier * ), compareTiers );
1819
1820        /* announce some */
1821        n = MIN( tr_ptrArraySize( &announceMe ), announcer->slotsAvailable );
1822        for( i=0; i<n; ++i ) {
1823            tr_tier * tier = tr_ptrArrayNth( &announceMe, i );
1824            dbgmsg( tier, "announcing tier %d of %d", i, n );
1825            tierAnnounce( announcer, tier );
1826        }
1827
1828        /* scrape some */
1829        n = MIN( tr_ptrArraySize( &scrapeMe ), announcer->slotsAvailable );
1830        for( i=0; i<n; ++i ) {
1831            tr_tier * tier = tr_ptrArrayNth( &scrapeMe, i );
1832            dbgmsg( tier, "scraping tier %d of %d", (i+1), n );
1833            tierScrape( announcer, tier );
1834        }
1835
1836#if 0
1837char timebuf[64];
1838tr_getLogTimeStr( timebuf, 64 );
1839fprintf( stderr, "[%s] announce.c has %d requests ready to send (announce: %d, scrape: %d)\n", timebuf, (int)(tr_ptrArraySize(&announceMe)+tr_ptrArraySize(&scrapeMe)), (int)tr_ptrArraySize(&announceMe), (int)tr_ptrArraySize(&scrapeMe) );
1840#endif
1841
1842        /* cleanup */
1843        tr_ptrArrayDestruct( &scrapeMe, NULL );
1844        tr_ptrArrayDestruct( &announceMe, NULL );
1845    }
1846
1847    tor = NULL;
1848    while(( tor = tr_torrentNext( announcer->session, tor ))) {
1849        if( tor->dhtAnnounceAt <= now ) {
1850            if( tor->isRunning && tr_torrentAllowsDHT(tor) ) {
1851                int rc;
1852                rc = tr_dhtAnnounce(tor, AF_INET, 1);
1853                if(rc == 0)
1854                    /* The DHT is not ready yet.  Try again soon. */
1855                    tor->dhtAnnounceAt = now + 5 + tr_cryptoWeakRandInt( 5 );
1856                else
1857                    /* We should announce at least once every 30 minutes. */
1858                    tor->dhtAnnounceAt =
1859                        now + 25 * 60 + tr_cryptoWeakRandInt( 3 * 60 );
1860            }
1861        }
1862
1863        if( tor->dhtAnnounce6At <= now ) {
1864            if( tor->isRunning && tr_torrentAllowsDHT(tor) ) {
1865                int rc;
1866                rc = tr_dhtAnnounce(tor, AF_INET6, 1);
1867                if(rc == 0)
1868                    tor->dhtAnnounce6At = now + 5 + tr_cryptoWeakRandInt( 5 );
1869                else
1870                    tor->dhtAnnounce6At =
1871                        now + 25 * 60 + tr_cryptoWeakRandInt( 3 * 60 );
1872            }
1873        }
1874    }
1875}
1876
1877static void
1878onUpkeepTimer( int foo UNUSED, short bar UNUSED, void * vannouncer )
1879{
1880    tr_announcer * announcer = vannouncer;
1881    tr_sessionLock( announcer->session );
1882
1883    /* maybe send out some "stopped" messages for closed torrents */
1884    flushCloseMessages( announcer );
1885
1886    /* maybe send out some announcements to trackers */
1887    announceMore( announcer );
1888
1889    /* set up the next timer */
1890    tr_timerAdd( announcer->upkeepTimer, UPKEEP_INTERVAL_SECS, 0 );
1891
1892    tr_sessionUnlock( announcer->session );
1893}
1894
1895/***
1896****
1897***/
1898
1899tr_tracker_stat *
1900tr_announcerStats( const tr_torrent * torrent,
1901                   int              * setmeTrackerCount )
1902{
1903    int i;
1904    int n;
1905    int out = 0;
1906    int tierCount;
1907    tr_tracker_stat * ret;
1908    const time_t now = tr_time( );
1909
1910    assert( tr_isTorrent( torrent ) );
1911
1912    /* count the trackers... */
1913    for( i=n=0, tierCount=tr_ptrArraySize( &torrent->tiers->tiers ); i<tierCount; ++i ) {
1914        const tr_tier * tier = tr_ptrArrayNth( &torrent->tiers->tiers, i );
1915        n += tr_ptrArraySize( &tier->trackers );
1916    }
1917
1918    /* alloc the stats */
1919    *setmeTrackerCount = n;
1920    ret = tr_new0( tr_tracker_stat, n );
1921
1922    /* populate the stats */
1923    for( i=0, tierCount=tr_ptrArraySize( &torrent->tiers->tiers ); i<tierCount; ++i )
1924    {
1925        int j;
1926        const tr_tier * tier = tr_ptrArrayNth( &torrent->tiers->tiers, i );
1927        n = tr_ptrArraySize( &tier->trackers );
1928        for( j=0; j<n; ++j )
1929        {
1930            const tr_tracker_item * tracker = tr_ptrArrayNth( (tr_ptrArray*)&tier->trackers, j );
1931            tr_tracker_stat * st = ret + out++;
1932
1933            st->id = tracker->id;
1934            tr_strlcpy( st->host, tracker->host->name, sizeof( st->host ) );
1935            tr_strlcpy( st->announce, tracker->announce, sizeof( st->announce ) );
1936            st->tier = i + 1;
1937            st->isBackup = tracker != tier->currentTracker;
1938            st->lastScrapeStartTime = tier->lastScrapeStartTime;
1939
1940            st->seederCount = tracker->seederCount;
1941            st->leecherCount = tracker->leecherCount;
1942            st->downloadCount = tracker->downloadCount;
1943
1944            if( st->isBackup )
1945            {
1946                st->scrapeState = TR_TRACKER_INACTIVE;
1947                st->announceState = TR_TRACKER_INACTIVE;
1948                st->nextScrapeTime = 0;
1949                st->nextAnnounceTime = 0;
1950            }
1951            else
1952            {
1953                if(( st->hasScraped = tier->lastScrapeTime != 0 )) {
1954                    st->lastScrapeTime = tier->lastScrapeTime;
1955                    st->lastScrapeSucceeded = tier->lastScrapeSucceeded;
1956                    tr_strlcpy( st->lastScrapeResult, tier->lastScrapeStr, sizeof( st->lastScrapeResult ) );
1957                }
1958
1959                if( tier->isScraping )
1960                    st->scrapeState = TR_TRACKER_ACTIVE;
1961                else if( !tier->scrapeAt )
1962                    st->scrapeState = TR_TRACKER_INACTIVE;
1963                else if( tier->scrapeAt > now )
1964                {
1965                    st->scrapeState = TR_TRACKER_WAITING;
1966                    st->nextScrapeTime = tier->scrapeAt;
1967                }
1968                else
1969                    st->scrapeState = TR_TRACKER_QUEUED;
1970
1971                st->lastAnnounceStartTime = tier->lastAnnounceStartTime;
1972
1973                if(( st->hasAnnounced = tier->lastAnnounceTime != 0 )) {
1974                    st->lastAnnounceTime = tier->lastAnnounceTime;
1975                    tr_strlcpy( st->lastAnnounceResult, tier->lastAnnounceStr, sizeof( st->lastAnnounceResult ) );
1976                    st->lastAnnounceSucceeded = tier->lastAnnounceSucceeded;
1977                    st->lastAnnounceTimedOut = tier->lastAnnounceTimedOut;
1978                    st->lastAnnouncePeerCount = tier->lastAnnouncePeerCount;
1979                }
1980
1981                if( tier->isAnnouncing )
1982                    st->announceState = TR_TRACKER_ACTIVE;
1983                else if( !torrent->isRunning || !tier->announceAt )
1984                    st->announceState = TR_TRACKER_INACTIVE;
1985                else if( tier->announceAt > now )
1986                {
1987                    st->announceState = TR_TRACKER_WAITING;
1988                    st->nextAnnounceTime = tier->announceAt;
1989                }
1990                else
1991                    st->announceState = TR_TRACKER_QUEUED;
1992            }
1993        }
1994    }
1995
1996    return ret;
1997}
1998
1999void
2000tr_announcerStatsFree( tr_tracker_stat * trackers,
2001                       int trackerCount UNUSED )
2002{
2003    tr_free( trackers );
2004}
Note: See TracBrowser for help on using the repository browser.