source: branches/simple_http_parsing/libtransmission/tracker.c @ 222

Last change on this file since 222 was 222, checked in by titer, 16 years ago

Merge 84:221 from trunk

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