source: branches/1.7x/libtransmission/web.c @ 9058

Last change on this file since 9058 was 9058, checked in by charles, 13 years ago

(1.7x libT) lower the time we'll wait on a nonresponsive tracker during an announce or scrape before giving the next announce a turn

  • Property svn:keywords set to Date Rev Author Id
File size: 18.5 KB
Line 
1/*
2 * This file Copyright (C) 2008-2009 Charles Kerr <charles@transmissionbt.com>
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: web.c 9058 2009-09-07 21:51:23Z charles $
11 */
12
13#include <assert.h>
14#include <stdlib.h> /* bsearch */
15
16#include <event.h>
17
18#define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
19#include <curl/curl.h>
20
21#include "transmission.h"
22#include "list.h"
23#include "net.h" /* socklen_t */
24#include "session.h"
25#include "trevent.h"
26#include "utils.h"
27#include "version.h"
28#include "web.h"
29
30/* Use curl_multi_socket_action() instead of curl_multi_perform()
31   if libcurl >= 7.18.2.  See http://trac.transmissionbt.com/ticket/1844 */
32#if LIBCURL_VERSION_NUM >= 0x071202
33    #define USE_CURL_MULTI_SOCKET_ACTION
34#endif
35
36
37enum
38{
39    /* arbitrary number */
40    MAX_CONCURRENT_TASKS = 256,
41
42    /* arbitrary number */
43    DEFAULT_TIMER_MSEC = 2500
44};
45
46#if 0
47#define dbgmsg(...) \
48    do { \
49        fprintf( stderr, __VA_ARGS__ ); \
50        fprintf( stderr, "\n" ); \
51    } while( 0 )
52#else
53#define dbgmsg( ... ) \
54    do { \
55        if( tr_deepLoggingIsActive( ) ) \
56            tr_deepLog( __FILE__, __LINE__, "web", __VA_ARGS__ ); \
57    } while( 0 )
58#endif
59
60struct tr_web_sockinfo
61{
62    int fd;
63    tr_bool evset;
64    struct event ev;
65};
66
67struct tr_web
68{
69    tr_bool closing;
70    int prev_running;
71    int still_running;
72    long timer_ms;
73    CURLM * multi;
74    tr_session * session;
75    struct event timer_event;
76    tr_list * easy_queue;
77    tr_list * fds;
78};
79
80/***
81****
82***/
83
84static struct tr_web_sockinfo *
85getSockinfo( tr_web * web, int fd, tr_bool createIfMissing )
86{
87    tr_list * l;
88
89    for( l=web->fds; l!=NULL; l=l->next ) {
90        struct tr_web_sockinfo * s =  l->data;
91        if( s->fd == fd ) {
92            dbgmsg( "looked up sockinfo %p for fd %d", s, fd );
93            return s;
94        }
95    }
96
97    if( createIfMissing ) {
98        struct tr_web_sockinfo * s =  tr_new0( struct tr_web_sockinfo, 1 );
99        s->fd = fd;
100        tr_list_prepend( &web->fds, s );
101        dbgmsg( "created sockinfo %p for fd %d... we now have %d sockinfos", s, fd, tr_list_size(web->fds) );
102        return s;
103    }
104
105    return NULL;
106}
107
108static void
109clearSockinfoEvent( struct tr_web_sockinfo * s )
110{
111    if( s && s->evset )
112    {
113        dbgmsg( "clearing libevent polling for sockinfo %p, fd %d", s, s->fd );
114        event_del( &s->ev );
115        s->evset = FALSE;
116    }
117}
118
119static void
120purgeSockinfo( tr_web * web, int fd )
121{
122    struct tr_web_sockinfo * s = getSockinfo( web, fd, FALSE );
123
124    if( s != NULL )
125    {
126        tr_list_remove_data( &web->fds, s );
127        clearSockinfoEvent( s );
128        dbgmsg( "freeing sockinfo %p, fd %d", s, s->fd );
129        tr_free( s );
130    }
131}
132
133/***
134****
135***/
136
137struct tr_web_task
138{
139    unsigned long tag;
140    struct evbuffer * response;
141    char * url;
142    char * range;
143    tr_session * session;
144    tr_web_done_func * done_func;
145    void * done_func_user_data;
146};
147
148static size_t
149writeFunc( void * ptr, size_t size, size_t nmemb, void * task )
150{
151    const size_t byteCount = size * nmemb;
152    evbuffer_add( ((struct tr_web_task*)task)->response, ptr, byteCount );
153    dbgmsg( "wrote %zu bytes to task %p's buffer", byteCount, task );
154    return byteCount;
155}
156
157static int
158getCurlProxyType( tr_proxy_type t )
159{
160    switch( t )
161    {
162        case TR_PROXY_SOCKS4: return CURLPROXY_SOCKS4;
163        case TR_PROXY_SOCKS5: return CURLPROXY_SOCKS5;
164        default:              return CURLPROXY_HTTP;
165    }
166}
167
168static void
169addTask( void * vtask )
170{
171    struct tr_web_task * task = vtask;
172    const tr_session * session = task->session;
173
174    if( session && session->web )
175    {
176        struct tr_web * web = session->web;
177        CURL * easy;
178
179        dbgmsg( "adding task #%lu [%s]", task->tag, task->url );
180
181        easy = curl_easy_init( );
182
183        if( !task->range && session->isProxyEnabled ) {
184            curl_easy_setopt( easy, CURLOPT_PROXY, session->proxy );
185            curl_easy_setopt( easy, CURLOPT_PROXYAUTH, CURLAUTH_ANY );
186            curl_easy_setopt( easy, CURLOPT_PROXYPORT, session->proxyPort );
187            curl_easy_setopt( easy, CURLOPT_PROXYTYPE,
188                                      getCurlProxyType( session->proxyType ) );
189        }
190        if( !task->range && session->isProxyAuthEnabled ) {
191            char * str = tr_strdup_printf( "%s:%s", session->proxyUsername,
192                                                    session->proxyPassword );
193            curl_easy_setopt( easy, CURLOPT_PROXYUSERPWD, str );
194            tr_free( str );
195        }
196
197        curl_easy_setopt( easy, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4 );
198        curl_easy_setopt( easy, CURLOPT_DNS_CACHE_TIMEOUT, 360L );
199        curl_easy_setopt( easy, CURLOPT_CONNECTTIMEOUT, 60L );
200
201        /* set a time limit for announces & scrapes */
202        if( strstr( task->url, "scrape" ) )
203            curl_easy_setopt( easy, CURLOPT_TIMEOUT, 15L );
204        else if( strstr( task->url, "announce" ) )
205            curl_easy_setopt( easy, CURLOPT_TIMEOUT, 30L );
206        else
207            curl_easy_setopt( easy, CURLOPT_TIMEOUT, 240L );
208
209        curl_easy_setopt( easy, CURLOPT_FOLLOWLOCATION, 1L );
210        curl_easy_setopt( easy, CURLOPT_AUTOREFERER, 1L );
211        curl_easy_setopt( easy, CURLOPT_FORBID_REUSE, 1L );
212        curl_easy_setopt( easy, CURLOPT_MAXREDIRS, -1L );
213        curl_easy_setopt( easy, CURLOPT_NOSIGNAL, 1L );
214        curl_easy_setopt( easy, CURLOPT_PRIVATE, task );
215        curl_easy_setopt( easy, CURLOPT_SSL_VERIFYHOST, 0L );
216        curl_easy_setopt( easy, CURLOPT_SSL_VERIFYPEER, 0L );
217        curl_easy_setopt( easy, CURLOPT_URL, task->url );
218        curl_easy_setopt( easy, CURLOPT_USERAGENT,
219                                           TR_NAME "/" LONG_VERSION_STRING );
220        curl_easy_setopt( easy, CURLOPT_VERBOSE,
221                                       getenv( "TR_CURL_VERBOSE" ) != NULL );
222        curl_easy_setopt( easy, CURLOPT_WRITEDATA, task );
223        curl_easy_setopt( easy, CURLOPT_WRITEFUNCTION, writeFunc );
224        if( task->range )
225            curl_easy_setopt( easy, CURLOPT_RANGE, task->range );
226        else /* don't set encoding on webseeds; it messes up binary data */
227            curl_easy_setopt( easy, CURLOPT_ENCODING, "" );
228
229        if( web->still_running >= MAX_CONCURRENT_TASKS ) {
230            tr_list_append( &web->easy_queue, easy );
231            dbgmsg( ">> enqueueing a task... size is now %d", tr_list_size( web->easy_queue ) );
232        } else {
233            const CURLMcode mcode = curl_multi_add_handle( web->multi, easy );
234            tr_assert( mcode == CURLM_OK, "curl_multi_add_handle() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
235            if( mcode == CURLM_OK )
236                ++web->still_running;
237            else
238                tr_err( "%s", curl_multi_strerror( mcode ) );
239        }
240    }
241}
242
243/***
244****
245***/
246
247static void
248task_free( struct tr_web_task * task )
249{
250    evbuffer_free( task->response );
251    tr_free( task->range );
252    tr_free( task->url );
253    tr_free( task );
254}
255
256static void
257task_finish( struct tr_web_task * task, long response_code )
258{
259    dbgmsg( "finished a web task... response code is %ld", response_code );
260    dbgmsg( "===================================================" );
261    task->done_func( task->session,
262                     response_code,
263                     EVBUFFER_DATA( task->response ),
264                     EVBUFFER_LENGTH( task->response ),
265                     task->done_func_user_data );
266    task_free( task );
267}
268
269static void
270remove_finished_tasks( tr_web * g )
271{
272    CURL * easy;
273
274    do
275    {
276        CURLMsg * msg;
277        int msgs_left;
278
279        easy = NULL;
280        while(( msg = curl_multi_info_read( g->multi, &msgs_left ))) {
281            if( msg->msg == CURLMSG_DONE ) {
282                easy = msg->easy_handle;
283                break;
284            }
285        }
286
287        if( easy ) {
288            long code;
289            long fd;
290            struct tr_web_task * task;
291            CURLcode ecode;
292            CURLMcode mcode;
293
294            ecode = curl_easy_getinfo( easy, CURLINFO_PRIVATE, (void*)&task );
295            tr_assert( ecode == CURLE_OK, "curl_easy_getinfo() failed: %d (%s)", ecode, curl_easy_strerror( ecode ) );
296
297            ecode = curl_easy_getinfo( easy, CURLINFO_RESPONSE_CODE, &code );
298            tr_assert( ecode == CURLE_OK, "curl_easy_getinfo() failed: %d (%s)", ecode, curl_easy_strerror( ecode ) );
299
300            ecode = curl_easy_getinfo( easy, CURLINFO_LASTSOCKET, &fd );
301            tr_assert( ecode == CURLE_OK, "curl_easy_getinfo() failed: %d (%s)", ecode, curl_easy_strerror( ecode ) );
302            if( fd != -1L )
303                purgeSockinfo( g, fd );
304
305            mcode = curl_multi_remove_handle( g->multi, easy );
306            tr_assert( mcode == CURLM_OK, "curl_multi_remove_handle() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
307
308            curl_easy_cleanup( easy );
309            task_finish( task, code );
310        }
311    }
312    while ( easy );
313
314    g->prev_running = g->still_running;
315}
316
317static void
318stop_timer( tr_web* g )
319{
320    if( evtimer_pending( &g->timer_event, NULL ) )
321    {
322        dbgmsg( "deleting the pending global timer" );
323        evtimer_del( &g->timer_event );
324    }
325}
326
327static void
328restart_timer( tr_web * g )
329{
330    struct timeval interval;
331
332    assert( tr_amInEventThread( g->session ) );
333    assert( g->session != NULL );
334    assert( g->session->events != NULL );
335
336    stop_timer( g );
337    dbgmsg( "adding a timeout for %ld seconds from now", g->timer_ms/1000L );
338    tr_timevalMsec( g->timer_ms, &interval );
339    evtimer_add( &g->timer_event, &interval );
340}
341
342static void
343add_tasks_from_queue( tr_web * g )
344{
345    while( ( g->still_running < MAX_CONCURRENT_TASKS )
346        && ( tr_list_size( g->easy_queue ) > 0 ) )
347    {
348        CURL * easy = tr_list_pop_front( &g->easy_queue );
349        if( easy )
350        {
351            const CURLMcode rc = curl_multi_add_handle( g->multi, easy );
352            if( rc != CURLM_OK )
353                tr_err( "%s", curl_multi_strerror( rc ) );
354            else {
355                dbgmsg( "pumped the task queue, %d remain",
356                        tr_list_size( g->easy_queue ) );
357                ++g->still_running;
358            }
359        }
360    }
361}
362
363static void
364web_close( tr_web * g )
365{
366    CURLMcode mcode;
367
368    stop_timer( g );
369
370    mcode = curl_multi_cleanup( g->multi );
371    tr_assert( mcode == CURLM_OK, "curl_multi_cleanup() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
372    if( mcode != CURLM_OK )
373        tr_err( "%s", curl_multi_strerror( mcode ) );
374
375    tr_free( g );
376}
377
378/* note: this function can free the tr_web if its 'closing' flag is set
379   and no tasks remain.  callers must not reference their g pointer
380   after calling this function */
381static void
382tr_multi_perform( tr_web * g, int fd )
383{
384    int closed = FALSE;
385    CURLMcode mcode;
386
387    dbgmsg( "check_run_count: prev_running %d, still_running %d",
388            g->prev_running, g->still_running );
389
390    /* invoke libcurl's processing */
391#ifdef USE_CURL_MULTI_SOCKET_ACTION
392    do {
393        dbgmsg( "calling curl_multi_socket_action..." );
394        mcode = curl_multi_socket_action( g->multi, fd, 0, &g->still_running );
395        fd = CURL_SOCKET_TIMEOUT;
396        dbgmsg( "done calling curl_multi_socket_action..." );
397    } while( mcode == CURLM_CALL_MULTI_SOCKET );
398#else
399    do {
400        dbgmsg( "calling curl_multi_perform..." );
401        mcode = curl_multi_perform( g->multi, &g->still_running );
402        dbgmsg( "done calling curl_multi_perform..." );
403    } while( mcode == CURLM_CALL_MULTI_PERFORM );
404#endif
405    tr_assert( mcode == CURLM_OK, "curl_multi_perform() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
406    if( mcode != CURLM_OK )
407        tr_err( "%s", curl_multi_strerror( mcode ) );
408
409    remove_finished_tasks( g );
410
411    add_tasks_from_queue( g );
412
413    if( !g->still_running ) {
414        assert( tr_list_size( g->fds ) == 0 );
415        stop_timer( g );
416        if( g->closing ) {
417            web_close( g );
418            closed = TRUE;
419        }
420    }
421
422    if( !closed )
423        restart_timer( g );
424}
425
426/* libevent says that sock is ready to be processed, so wake up libcurl */
427static void
428event_cb( int fd, short kind UNUSED, void * g )
429{
430    tr_multi_perform( g, fd );
431}
432
433/* libevent says that timer_ms have passed, so wake up libcurl */
434static void
435timer_cb( int socket UNUSED, short action UNUSED, void * g )
436{
437    dbgmsg( "libevent timer is done" );
438    tr_multi_perform( g, CURL_SOCKET_TIMEOUT );
439}
440
441/* CURLMOPT_SOCKETFUNCTION */
442static int
443sock_cb( CURL            * e UNUSED,
444         curl_socket_t     fd,
445         int               action,
446         void            * vweb,
447         void            * unused UNUSED)
448{
449    struct tr_web * web = vweb;
450    dbgmsg( "sock_cb: action is %d, fd is %d", action, (int)fd );
451
452    if( action == CURL_POLL_REMOVE )
453    {
454        purgeSockinfo( web, fd );
455    }
456    else
457    {
458        struct tr_web_sockinfo * sockinfo = getSockinfo( web, fd, TRUE );
459        const int kind = EV_PERSIST
460                       | (( action & CURL_POLL_IN ) ? EV_READ : 0 )
461                       | (( action & CURL_POLL_OUT ) ? EV_WRITE : 0 );
462        dbgmsg( "setsock: fd is %d, curl action is %d, libevent action is %d", fd, action, kind );
463        assert( tr_amInEventThread( web->session ) );
464        assert( kind != EV_PERSIST );
465
466        /* clear any old polling on this fd */
467        clearSockinfoEvent( sockinfo );
468
469        /* set the new polling on this fd */
470        dbgmsg( "enabling (libevent %d, libcurl %d) polling on sockinfo %p, fd %d", action, kind, sockinfo, fd );
471        event_set( &sockinfo->ev, fd, kind, event_cb, web );
472        event_add( &sockinfo->ev, NULL );
473        sockinfo->evset = TRUE;
474    }
475
476    return 0;
477}
478
479
480/* libcurl documentation: "If 0, it means you should proceed immediately
481 * without waiting for anything. If it returns -1, there's no timeout at all
482 * set ... (but) you must not wait too long (more than a few seconds perhaps)
483 * before you call curl_multi_perform() again."  */
484static void
485multi_timer_cb( CURLM *multi UNUSED, long timer_ms, void * vg )
486{
487    tr_web * g = vg;
488
489    if( timer_ms < 1 ) {
490        if( timer_ms == 0 ) /* call it immediately */
491            timer_cb( 0, 0, g );
492        timer_ms = DEFAULT_TIMER_MSEC;
493    }
494
495    g->timer_ms = timer_ms;
496    restart_timer( g );
497}
498
499/****
500*****
501****/
502
503void
504tr_webRun( tr_session         * session,
505           const char         * url,
506           const char         * range,
507           tr_web_done_func     done_func,
508           void               * done_func_user_data )
509{
510    if( session->web )
511    {
512        static unsigned long tag = 0;
513        struct tr_web_task * task;
514
515        task = tr_new0( struct tr_web_task, 1 );
516        task->session = session;
517        task->url = tr_strdup( url );
518        task->range = tr_strdup( range );
519        task->done_func = done_func;
520        task->done_func_user_data = done_func_user_data;
521        task->tag = ++tag;
522        task->response = evbuffer_new( );
523
524        tr_runInEventThread( session, addTask, task );
525    }
526}
527
528tr_web*
529tr_webInit( tr_session * session )
530{
531    CURLMcode mcode;
532    static int curlInited = FALSE;
533    tr_web * web;
534
535    /* call curl_global_init if we haven't done it already.
536     * try to enable ssl for https support; but if that fails,
537     * try a plain vanilla init */
538    if( curlInited == FALSE ) {
539        curlInited = TRUE;
540        if( curl_global_init( CURL_GLOBAL_SSL ) )
541            curl_global_init( 0 );
542    }
543
544    web = tr_new0( struct tr_web, 1 );
545    web->multi = curl_multi_init( );
546    web->session = session;
547    web->timer_ms = DEFAULT_TIMER_MSEC; /* overwritten by multi_timer_cb() */
548
549    evtimer_set( &web->timer_event, timer_cb, web );
550    mcode = curl_multi_setopt( web->multi, CURLMOPT_SOCKETDATA, web );
551    tr_assert( mcode == CURLM_OK, "curl_mutli_setopt() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
552    mcode = curl_multi_setopt( web->multi, CURLMOPT_SOCKETFUNCTION, sock_cb );
553    tr_assert( mcode == CURLM_OK, "curl_mutli_setopt() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
554    mcode = curl_multi_setopt( web->multi, CURLMOPT_TIMERDATA, web );
555    tr_assert( mcode == CURLM_OK, "curl_mutli_setopt() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
556    mcode = curl_multi_setopt( web->multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb );
557    tr_assert( mcode == CURLM_OK, "curl_mutli_setopt() failed: %d (%s)", mcode, curl_multi_strerror( mcode ) );
558
559    return web;
560}
561
562void
563tr_webClose( tr_web ** web_in )
564{
565    tr_web * web = *web_in;
566    *web_in = NULL;
567    if( web->still_running < 1 )
568        web_close( web );
569    else
570        web->closing = 1;
571}
572
573/*****
574******
575******
576*****/
577
578static struct http_msg {
579    long code;
580    const char * text;
581} http_msg[] = {
582    {   0, "No Response" },
583    { 101, "Switching Protocols" },
584    { 200, "OK" },
585    { 201, "Created" },
586    { 202, "Accepted" },
587    { 203, "Non-Authoritative Information" },
588    { 204, "No Content" },
589    { 205, "Reset Content" },
590    { 206, "Partial Content" },
591    { 300, "Multiple Choices" },
592    { 301, "Moved Permanently" },
593    { 302, "Found" },
594    { 303, "See Other" },
595    { 304, "Not Modified" },
596    { 305, "Use Proxy" },
597    { 306, "(Unused)" },
598    { 307, "Temporary Redirect" },
599    { 400, "Bad Request" },
600    { 401, "Unauthorized" },
601    { 402, "Payment Required" },
602    { 403, "Forbidden" },
603    { 404, "Not Found" },
604    { 405, "Method Not Allowed" },
605    { 406, "Not Acceptable" },
606    { 407, "Proxy Authentication Required" },
607    { 408, "Request Timeout" },
608    { 409, "Conflict" },
609    { 410, "Gone" },
610    { 411, "Length Required" },
611    { 412, "Precondition Failed" },
612    { 413, "Request Entity Too Large" },
613    { 414, "Request-URI Too Long" },
614    { 415, "Unsupported Media Type" },
615    { 416, "Requested Range Not Satisfiable" },
616    { 417, "Expectation Failed" },
617    { 500, "Internal Server Error" },
618    { 501, "Not Implemented" },
619    { 502, "Bad Gateway" },
620    { 503, "Service Unavailable" },
621    { 504, "Gateway Timeout" },
622    { 505, "HTTP Version Not Supported" }
623};
624
625static int
626compareResponseCodes( const void * va, const void * vb )
627{
628    const long a = *(const long*) va;
629    const struct http_msg * b = vb;
630    return a - b->code;
631}
632
633const char *
634tr_webGetResponseStr( long code )
635{
636    struct http_msg * msg = bsearch( &code,
637                                     http_msg,
638                                     sizeof( http_msg ) / sizeof( http_msg[0] ),
639                                     sizeof( http_msg[0] ),
640                                     compareResponseCodes );
641    return msg ? msg->text : "Unknown Error";
642}
Note: See TracBrowser for help on using the repository browser.