source: trunk/libtransmission/web.c @ 9740

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

(trunk libT) it never ends

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