source: trunk/libtransmission/tracker.c @ 854

Last change on this file since 854 was 854, checked in by joshe, 15 years ago

Add an assertion.

  • Property svn:keywords set to Date Rev Author Id
File size: 18.6 KB
Line 
1/******************************************************************************
2 * $Id: tracker.c 854 2006-09-08 23:19:15Z joshe $
3 *
4 * Copyright (c) 2005-2006 Transmission authors and contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *****************************************************************************/
24
25#include "transmission.h"
26
27struct tr_tracker_s
28{
29    tr_torrent_t * tor;
30
31    char         * id;
32
33    char           started;
34    char           completed;
35    char           stopped;
36
37    int            interval;
38    int            seeders;
39    int            leechers;
40    int            hasManyPeers;
41
42    uint64_t       dateTry;
43    uint64_t       dateOk;
44
45#define TC_STATUS_IDLE    1
46#define TC_STATUS_RESOLVE 2
47#define TC_STATUS_CONNECT 4
48#define TC_STATUS_RECV    8
49    char           status;
50
51#define TC_ATTEMPT_NOREACH 1
52#define TC_ATTEMPT_ERROR   2
53#define TC_ATTEMPT_OK      4
54    char           lastAttempt;
55
56    tr_resolve_t * resolve;
57    int            socket;
58    uint8_t      * buf;
59    int            size;
60    int            pos;
61
62    int            bindPort;
63    int            newPort;
64
65    uint64_t       download;
66    uint64_t       upload;
67};
68
69static void sendQuery  ( tr_tracker_t * tc );
70static void recvAnswer ( tr_tracker_t * tc );
71
72tr_tracker_t * tr_trackerInit( tr_torrent_t * tor )
73{
74    tr_tracker_t * tc;
75
76    tc           = calloc( 1, sizeof( tr_tracker_t ) );
77    tc->tor      = tor;
78    tc->id       = tor->id;
79
80    tc->started  = 1;
81
82    tc->interval = 300;
83    tc->seeders  = -1;
84    tc->leechers = -1;
85
86    tc->status   = TC_STATUS_IDLE;
87    tc->lastAttempt = TC_ATTEMPT_NOREACH;
88    tc->size     = 1024;
89    tc->buf      = malloc( tc->size );
90
91    tc->bindPort = *(tor->bindPort);
92    tc->newPort  = -1;
93
94    tc->download = tor->downloaded;
95    tc->upload   = tor->uploaded;
96
97    return tc;
98}
99
100static int shouldConnect( tr_tracker_t * tc )
101{
102    uint64_t now = tr_date();
103
104    /* Unreachable tracker, try 10 seconds before trying again */
105    if( tc->lastAttempt == TC_ATTEMPT_NOREACH &&
106        now < tc->dateTry + 10000 )
107    {
108        return 0;
109    }
110
111    /* The tracker rejected us (like 4XX code, unauthorized IP...),
112       don't hammer it - we'll probably get the same answer next time
113       anyway */
114    if( tc->lastAttempt == TC_ATTEMPT_ERROR &&
115        now < tc->dateTry + 1000 * tc->interval )
116    {
117        return 0;
118    }
119
120    /* Do we need to send an event? */
121    if( tc->started || tc->completed || tc->stopped || 0 < tc->newPort )
122    {
123        return 1;
124    }
125
126    /* Should we try and get more peers? */
127    if( now > tc->dateOk + 1000 * tc->interval )
128    {
129        return 1;
130    }
131
132    /* If there is quite a lot of people on this torrent, stress
133       the tracker a bit until we get a decent number of peers */
134    if( tc->hasManyPeers )
135    {
136        if( tc->tor->peerCount < 5 && now > tc->dateOk + 10000 )
137        {
138            return 1;
139        }
140        if( tc->tor->peerCount < 10 && now > tc->dateOk + 20000 )
141        {
142            return 1;
143        }
144        if( tc->tor->peerCount < 15 && now > tc->dateOk + 30000 )
145        {
146            return 1;
147        }
148    }
149
150    return 0;
151}
152
153void tr_trackerChangePort( tr_tracker_t * tc, int port )
154{
155    tc->newPort = port;
156}
157
158int tr_trackerPulse( tr_tracker_t * tc )
159{
160    tr_torrent_t * tor = tc->tor;
161    tr_info_t    * inf = &tor->info;
162    uint64_t       now = tr_date();
163
164    if( ( tc->status & TC_STATUS_IDLE ) && shouldConnect( tc ) )
165    {
166        tc->resolve = tr_netResolveInit( inf->trackerAddress );
167
168        tr_inf( "Tracker: connecting to %s:%d (%s)",
169                inf->trackerAddress, inf->trackerPort,
170                tc->started ? "sending 'started'" :
171                ( tc->completed ? "sending 'completed'" :
172                  ( tc->stopped ? "sending 'stopped'" :
173                    ( 0 < tc->newPort ? "sending 'stopped' to change port" :
174                      "getting peers" ) ) ) );
175
176        tc->status  = TC_STATUS_RESOLVE;
177        tc->dateTry = tr_date();
178    }
179
180    if( tc->status & TC_STATUS_RESOLVE )
181    {
182        int ret;
183        struct in_addr addr;
184
185        ret = tr_netResolvePulse( tc->resolve, &addr );
186        if( ret == TR_RESOLVE_WAIT )
187        {
188            return 0;
189        }
190        else
191        {
192            tr_netResolveClose( tc->resolve );
193        }
194       
195        if( ret == TR_RESOLVE_ERROR )
196        {
197            tc->status = TC_STATUS_IDLE;
198            return 0;
199        }
200
201        if( tr_fdSocketWillCreate( tor->fdlimit, 1 ) )
202        {
203            tc->status = TC_STATUS_IDLE;
204            return 0;
205        }
206
207        tc->socket = tr_netOpen( addr, htons( inf->trackerPort ) );
208        if( tc->socket < 0 )
209        {
210            tr_fdSocketClosed( tor->fdlimit, 1 );
211            tc->status = TC_STATUS_IDLE;
212            return 0;
213        }
214
215        tc->status = TC_STATUS_CONNECT;
216    }
217
218    if( tc->status & TC_STATUS_CONNECT )
219    {
220        /* We are connecting to the tracker. Try to send the query */
221        sendQuery( tc );
222    }
223
224    if( tc->status & TC_STATUS_RECV )
225    {
226        /* Try to get something */
227        recvAnswer( tc );
228    }
229
230    if( tc->status > TC_STATUS_IDLE && now > tc->dateTry + 60000 )
231    {
232        /* Give up if the request wasn't successful within 60 seconds */
233        tr_inf( "Tracker: timeout reached (60 s)" );
234
235        tr_netClose( tc->socket );
236        tr_fdSocketClosed( tor->fdlimit, 1 );
237
238        tc->status  = TC_STATUS_IDLE;
239        tc->dateTry = tr_date();
240    }
241
242    return 0;
243}
244
245void tr_trackerCompleted( tr_tracker_t * tc )
246{
247    tc->started   = 0;
248    tc->completed = 1;
249    tc->stopped   = 0;
250}
251
252void tr_trackerStopped( tr_tracker_t * tc )
253{
254    tr_torrent_t * tor = tc->tor;
255
256    if( tc->status > TC_STATUS_CONNECT )
257    {
258        /* If we are already sendy a query at the moment, we need to
259           reconnect */
260        tr_netClose( tc->socket );
261        tr_fdSocketClosed( tor->fdlimit, 1 );
262        tc->status = TC_STATUS_IDLE;
263    }
264
265    tc->started   = 0;
266    tc->completed = 0;
267    tc->stopped   = 1;
268
269    /* Even if we have connected recently, reconnect right now */
270    if( tc->status & TC_STATUS_IDLE )
271    {
272        tc->dateTry = 0;
273    }
274}
275
276void tr_trackerClose( tr_tracker_t * tc )
277{
278    tr_torrent_t * tor = tc->tor;
279
280    if( tc->status == TC_STATUS_RESOLVE )
281    {
282        tr_netResolveClose( tc->resolve );
283    }
284    else if( tc->status > TC_STATUS_RESOLVE )
285    {
286        tr_netClose( tc->socket );
287        tr_fdSocketClosed( tor->fdlimit, 1 );
288    }
289    free( tc->buf );
290    free( tc );
291}
292
293static void sendQuery( tr_tracker_t * tc )
294{
295    tr_torrent_t * tor = tc->tor;
296    tr_info_t    * inf = &tor->info;
297
298    char     * event;
299    uint64_t   left;
300    int        ret;
301    uint64_t   down;
302    uint64_t   up;
303
304    assert( tor->downloaded >= tc->download && tor->uploaded >= tc->upload );
305    down = tor->downloaded - tc->download;
306    up = tor->uploaded - tc->upload;
307    if( tc->started )
308    {
309        event = "&event=started";
310        down = up = 0;
311       
312        if( 0 < tc->newPort )
313        {
314            tc->bindPort = tc->newPort;
315            tc->newPort = -1;
316        }
317    }
318    else if( tc->completed )
319    {
320        event = "&event=completed";
321    }
322    else if( tc->stopped || 0 < tc->newPort )
323    {
324        event = "&event=stopped";
325    }
326    else
327    {
328        event = "";
329    }
330
331    left = tr_cpLeftBytes( tor->completion );
332
333    ret = snprintf( (char *) tc->buf, tc->size,
334            "GET %s?"
335            "info_hash=%s&"
336            "peer_id=%s&"
337            "port=%d&"
338            "uploaded=%"PRIu64"&"
339            "downloaded=%"PRIu64"&"
340            "left=%"PRIu64"&"
341            "compact=1&"
342            "numwant=50&"
343            "key=%s"
344            "%s "
345            "HTTP/1.1\r\n"
346            "Host: %s\r\n"
347            "User-Agent: Transmission/%d.%d\r\n"
348            "Connection: close\r\n\r\n",
349            inf->trackerAnnounce, tor->hashString, tc->id,
350            tc->bindPort, up, down,
351            left, tor->key, event, inf->trackerAddress,
352            VERSION_MAJOR, VERSION_MINOR );
353
354    ret = tr_netSend( tc->socket, tc->buf, ret );
355    if( ret & TR_NET_CLOSE )
356    {
357        tr_inf( "Tracker: connection failed" );
358        tr_netClose( tc->socket );
359        tr_fdSocketClosed( tor->fdlimit, 1 );
360        tc->status  = TC_STATUS_IDLE;
361        tc->dateTry = tr_date();
362    }
363    else if( !( ret & TR_NET_BLOCK ) )
364    {
365        // printf( "Tracker: sent %s", tc->buf );
366        tc->status = TC_STATUS_RECV;
367        tc->pos    = 0;
368    }
369}
370
371static void recvAnswer( tr_tracker_t * tc )
372{
373    tr_torrent_t * tor = tc->tor;
374    int ret;
375    int i;
376    benc_val_t   beAll;
377    benc_val_t * bePeers, * beFoo;
378    uint8_t * body;
379    int bodylen;
380    int shouldfree;
381
382    if( tc->pos == tc->size )
383    {
384        tc->size *= 2;
385        tc->buf   = realloc( tc->buf, tc->size );
386    }
387   
388    ret = tr_netRecv( tc->socket, &tc->buf[tc->pos],
389                    tc->size - tc->pos );
390
391    if( ret & TR_NET_BLOCK )
392    {
393        return;
394    }
395    if( !( ret & TR_NET_CLOSE ) )
396    {
397        // printf( "got %d bytes\n", ret );
398        tc->pos += ret;
399        return;
400    }
401
402    tr_netClose( tc->socket );
403    tr_fdSocketClosed( tor->fdlimit, 1 );
404    // printf( "connection closed, got total %d bytes\n", tc->pos );
405
406    tc->status  = TC_STATUS_IDLE;
407    tc->dateTry = tr_date();
408
409    if( tc->pos < 12 || ( 0 != memcmp( tc->buf, "HTTP/1.0 ", 9 ) &&
410                          0 != memcmp( tc->buf, "HTTP/1.1 ", 9 ) ) )
411    {
412        /* We don't have a complete HTTP status line */
413        tr_inf( "Tracker: incomplete HTTP status line" );
414        tc->lastAttempt = TC_ATTEMPT_NOREACH;
415        return;
416    }
417
418    if( '2' != tc->buf[9] )
419    {
420        /* we didn't get a 2xx status code */
421        tr_err( "Tracker: invalid HTTP status code: %c%c%c",
422                tc->buf[9], tc->buf[10], tc->buf[11] );
423        tc->lastAttempt = TC_ATTEMPT_ERROR;
424        return;
425    }
426
427    /* find the end of the http headers */
428    body = tr_memmem( tc->buf, tc->pos, "\015\012\015\012", 4 );
429    if( NULL != body )
430    {
431        body += 4;
432    }
433    /* hooray for trackers that violate the HTTP spec */
434    else if( NULL != ( body = tr_memmem( tc->buf, tc->pos, "\015\015", 2 ) ) ||
435             NULL != ( body = tr_memmem( tc->buf, tc->pos, "\012\012", 2 ) ) )
436    {
437        body += 2;
438    }
439    else
440    {
441        tr_err( "Tracker: could not find end of HTTP headers" );
442        tc->lastAttempt = TC_ATTEMPT_NOREACH;
443        return;
444    }
445    bodylen = tc->pos - (body - tc->buf);
446
447    /* Find and load the dictionary */
448    shouldfree = 0;
449    for( i = 0; i < bodylen; i++ )
450    {
451        if( !tr_bencLoad( &body[i], bodylen - i, &beAll, NULL ) )
452        {
453            shouldfree = 1;
454            break;
455        }
456    }
457
458    if( i >= bodylen )
459    {
460        if( tc->stopped || 0 < tc->newPort )
461        {
462            tc->lastAttempt = TC_ATTEMPT_OK;
463            goto nodict;
464        }
465        tr_err( "Tracker: no valid dictionary found in answer" );
466        tc->lastAttempt = TC_ATTEMPT_ERROR;
467        return;
468    }
469
470    // tr_bencPrint( &beAll );
471
472    if( ( bePeers = tr_bencDictFind( &beAll, "failure reason" ) ) )
473    {
474        tr_err( "Tracker: %s", bePeers->val.s.s );
475        tor->error |= TR_ETRACKER;
476        snprintf( tor->trackerError, sizeof( tor->trackerError ),
477                  "%s", bePeers->val.s.s );
478        tc->lastAttempt = TC_ATTEMPT_ERROR;
479        goto cleanup;
480    }
481
482    tor->error &= ~TR_ETRACKER;
483    tc->lastAttempt = TC_ATTEMPT_OK;
484
485    if( !tc->interval )
486    {
487        /* Get the tracker interval, ignore it if it is not between
488           10 sec and 5 mins */
489        if( !( beFoo = tr_bencDictFind( &beAll, "interval" ) ) ||
490            !( beFoo->type & TYPE_INT ) )
491        {
492            tr_err( "Tracker: no 'interval' field" );
493            goto cleanup;
494        }
495
496        tc->interval = beFoo->val.i;
497        tc->interval = MIN( tc->interval, 300 );
498        tc->interval = MAX( 10, tc->interval );
499
500        tr_inf( "Tracker: interval = %d seconds", tc->interval );
501    }
502
503    if( ( beFoo = tr_bencDictFind( &beAll, "complete" ) ) &&
504        ( beFoo->type & TYPE_INT ) )
505    {
506        tc->seeders = beFoo->val.i;
507    }
508    if( ( beFoo = tr_bencDictFind( &beAll, "incomplete" ) ) &&
509        ( beFoo->type & TYPE_INT ) )
510    {
511        tc->leechers = beFoo->val.i;
512    }
513    if( tc->seeders + tc->leechers >= 50 )
514    {
515        tc->hasManyPeers = 1;
516    }
517
518    if( !( bePeers = tr_bencDictFind( &beAll, "peers" ) ) )
519    {
520        if( tc->stopped || 0 < tc->newPort )
521        {
522            goto nodict;
523        }
524        tr_err( "Tracker: no \"peers\" field" );
525        goto cleanup;
526    }
527
528    if( bePeers->type & TYPE_LIST )
529    {
530        char * ip;
531        int    port;
532
533        /* Original protocol */
534        tr_inf( "Tracker: got %d peers", bePeers->val.l.count );
535
536        for( i = 0; i < bePeers->val.l.count; i++ )
537        {
538            beFoo = tr_bencDictFind( &bePeers->val.l.vals[i], "ip" );
539            if( !beFoo )
540                continue;
541            ip = beFoo->val.s.s;
542            beFoo = tr_bencDictFind( &bePeers->val.l.vals[i], "port" );
543            if( !beFoo )
544                continue;
545            port = beFoo->val.i;
546
547            tr_peerAddOld( tor, ip, port );
548        }
549
550        if( bePeers->val.l.count >= 50 )
551        {
552            tc->hasManyPeers = 1;
553        }
554    }
555    else if( bePeers->type & TYPE_STR )
556    {
557        struct in_addr addr;
558        in_port_t      port;
559
560        /* "Compact" extension */
561        if( bePeers->val.s.i % 6 )
562        {
563            tr_err( "Tracker: \"peers\" of size %d",
564                    bePeers->val.s.i );
565            tr_lockUnlock( &tor->lock );
566            goto cleanup;
567        }
568
569        tr_inf( "Tracker: got %d peers", bePeers->val.s.i / 6 );
570        for( i = 0; i < bePeers->val.s.i / 6; i++ )
571        {
572            memcpy( &addr, &bePeers->val.s.s[6*i],   4 );
573            memcpy( &port, &bePeers->val.s.s[6*i+4], 2 );
574
575            tr_peerAddCompact( tor, addr, port );
576        }
577
578        if( bePeers->val.s.i / 6 >= 50 )
579        {
580            tc->hasManyPeers = 1;
581        }
582    }
583
584nodict:
585    /* Success */
586    tc->started   = 0;
587    tc->completed = 0;
588    tc->dateOk    = tr_date();
589
590    if( tc->stopped )
591    {
592        tor->status = TR_STATUS_STOPPED;
593        tc->stopped = 0;
594    }
595    else if( 0 < tc->newPort )
596    {
597        tc->started  = 1;
598        tc->download = tor->downloaded;
599        tc->upload   = tor->uploaded;
600    }
601
602cleanup:
603    if( shouldfree )
604    {
605        tr_bencFree( &beAll );
606    }
607}
608
609int tr_trackerScrape( tr_torrent_t * tor, int * seeders, int * leechers )
610{
611    tr_info_t * inf = &tor->info;
612
613    int s, i, ret;
614    uint8_t buf[1024];
615    benc_val_t scrape, * val1, * val2;
616    struct in_addr addr;
617    uint64_t date;
618    int pos, len;
619    tr_resolve_t * resolve;
620
621    if( !tor->scrape[0] )
622    {
623        /* scrape not supported */
624        return 1;
625    }
626
627    resolve = tr_netResolveInit( inf->trackerAddress );
628    for( date = tr_date();; )
629    {
630        ret = tr_netResolvePulse( resolve, &addr );
631        if( ret == TR_RESOLVE_OK )
632        {
633            tr_netResolveClose( resolve );
634            break;
635        }
636        if( ret == TR_RESOLVE_ERROR ||
637            ( ret == TR_RESOLVE_WAIT && tr_date() > date + 10000 ) )
638        {
639            tr_err( "Could not resolve %s", inf->trackerAddress );
640            tr_netResolveClose( resolve );
641            return 1;
642        }
643        tr_wait( 10 );
644    }
645
646    s = tr_netOpen( addr, htons( inf->trackerPort ) );
647    if( s < 0 )
648    {
649        return 1;
650    }
651
652    len = snprintf( (char *) buf, sizeof( buf ),
653              "GET %s?info_hash=%s HTTP/1.1\r\n"
654              "Host: %s\r\n"
655              "Connection: close\r\n\r\n",
656              tor->scrape, tor->hashString,
657              inf->trackerAddress );
658
659    for( date = tr_date();; )
660    {
661        ret = tr_netSend( s, buf, len );
662        if( ret & TR_NET_CLOSE )
663        {
664            tr_err( "Could not connect to tracker" );
665            tr_netClose( s );
666            return 1;
667        }
668        else if( ret & TR_NET_BLOCK )
669        {
670            if( tr_date() > date + 10000 )
671            {
672                tr_err( "Could not connect to tracker" );
673                tr_netClose( s );
674                return 1;
675            }
676        }
677        else
678        {
679            break;
680        }
681        tr_wait( 10 );
682    }
683
684    pos = 0;
685    for( date = tr_date();; )
686    {
687        ret = tr_netRecv( s, &buf[pos], sizeof( buf ) - pos );
688        if( ret & TR_NET_CLOSE )
689        {
690            break;
691        }
692        else if( ret & TR_NET_BLOCK )
693        {
694            if( tr_date() > date + 10000 )
695            {
696                tr_err( "Could not read from tracker" );
697                tr_netClose( s );
698                return 1;
699            }
700        }
701        else
702        {
703            pos += ret;
704        }
705        tr_wait( 10 );
706    }
707
708    if( pos < 1 )
709    {
710        tr_err( "Could not read from tracker" );
711        tr_netClose( s );
712        return 1;
713    }
714
715    for( i = 0; i < pos - 8; i++ )
716    {
717        if( !memcmp( &buf[i], "d5:files", 8 ) )
718        {
719            break;
720        }
721    }
722    if( i >= pos - 8 )
723    {
724        return 1;
725    }
726    if( tr_bencLoad( &buf[i], pos - i, &scrape, NULL ) )
727    {
728        return 1;
729    }
730
731    val1 = tr_bencDictFind( &scrape, "files" );
732    if( !val1 )
733    {
734        return 1;
735    }
736    val1 = &val1->val.l.vals[1];
737    if( !val1 )
738    {
739        return 1;
740    }
741    val2 = tr_bencDictFind( val1, "complete" );
742    if( !val2 )
743    {
744        return 1;
745    }
746    *seeders = val2->val.i;
747    val2 = tr_bencDictFind( val1, "incomplete" );
748    if( !val2 )
749    {
750        return 1;
751    }
752    *leechers = val2->val.i;
753    tr_bencFree( &scrape );
754
755    return 0;
756}
757
758int tr_trackerSeeders( tr_tracker_t * tc )
759{
760    if( !tc )
761    {
762        return -1;
763    }
764    return tc->seeders;
765}
766
767int tr_trackerLeechers( tr_tracker_t * tc )
768{
769    if( !tc )
770    {
771        return -1;
772    }
773    return tc->leechers;
774}
Note: See TracBrowser for help on using the repository browser.