source: trunk/libtransmission/web.c @ 10239

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

(trunk) #2938 "crash when adding a torrent by URL from an ftp source over RPC" -- fixed in trunk for 1.91

  • Property svn:keywords set to Date Rev Author Id
File size: 23.5 KB
Line 
1/*
2 * This file Copyright (C) 2008-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: web.c 10239 2010-02-20 15:57:05Z charles $
11 */
12
13#include <assert.h>
14
15#include <curl/curl.h>
16#include <event.h>
17#include <evdns.h>
18
19#include "transmission.h"
20#include "net.h"
21#include "ptrarray.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    TR_MEMORY_TRASH = 0xCC,
31
32    DEFAULT_TIMER_MSEC = 250, /* arbitrary */
33
34    MIN_DNS_CACHE_TIME = 60 * 60 * 24
35};
36
37#if 0
38#define dbgmsg(...) \
39    do { \
40        fprintf( stderr, __VA_ARGS__ ); \
41        fprintf( stderr, "\n" ); \
42    } while( 0 )
43#else
44#define dbgmsg( ... ) \
45    do { \
46        if( tr_deepLoggingIsActive( ) ) \
47            tr_deepLog( __FILE__, __LINE__, "web", __VA_ARGS__ ); \
48    } while( 0 )
49#endif
50
51/***
52****
53***/
54
55struct tr_web
56{
57    tr_bool closing;
58    tr_bool haveAddr;
59    int taskCount;
60    long timer_msec;
61    CURLM * multi;
62    tr_session * session;
63    tr_address addr;
64    tr_ptrArray dns_cache;
65    struct event timer_event;
66};
67
68struct dns_cache_item;
69static void dns_cache_item_free( struct dns_cache_item * );
70
71static void
72web_free( tr_web * g )
73{
74    evdns_shutdown( TRUE );
75    curl_multi_cleanup( g->multi );
76    evtimer_del( &g->timer_event );
77    tr_ptrArrayDestruct( &g->dns_cache, (PtrArrayForeachFunc)dns_cache_item_free );
78    memset( g, TR_MEMORY_TRASH, sizeof( struct tr_web ) );
79    tr_free( g );
80}
81
82/***
83****
84***/
85
86struct tr_web_task
87{
88    int port;
89    unsigned long tag;
90    struct curl_slist * slist;
91    struct evbuffer * response;
92    char * url;
93    char * resolved_url;
94    char * host;
95    const char * resolved_host;
96    char * range;
97    tr_session * session;
98    tr_web_done_func * done_func;
99    void * done_func_user_data;
100    struct event timer_event;
101    CURL * easy;
102    CURLM * multi;
103    tr_bool timer_event_isSet;
104};
105
106static void
107task_free( struct tr_web_task * task )
108{
109    if( task->slist != NULL )
110        curl_slist_free_all( task->slist );
111    if( task->timer_event_isSet )
112        evtimer_del( &task->timer_event );
113    evbuffer_free( task->response );
114    tr_free( task->host );
115    tr_free( task->range );
116    tr_free( task->resolved_url );
117    tr_free( task->url );
118    memset( task, TR_MEMORY_TRASH, sizeof( struct tr_web_task ) );
119    tr_free( task );
120}
121
122/***
123****
124***/
125
126struct dns_cache_item
127{
128    char * host;
129    char * resolved_host;
130    time_t expiration;
131    tr_bool success;
132};
133
134static void
135dns_cache_item_free( struct dns_cache_item * item )
136{
137    if( item != NULL )
138    {
139        tr_free( item->host );
140        tr_free( item->resolved_host );
141        memset( item, TR_MEMORY_TRASH, sizeof( struct dns_cache_item ) );
142        tr_free( item );
143    }
144}
145
146static int
147dns_cache_compare( const void * va, const void * vb )
148{
149    const struct dns_cache_item * a = va;
150    const struct dns_cache_item * b = vb;
151    return strcmp( a->host, b->host );
152}
153
154typedef enum
155{
156    TR_DNS_OK,
157    TR_DNS_FAIL,
158    TR_DNS_UNTESTED
159}
160tr_dns_result;
161
162static void
163dns_cache_clear_entry( struct tr_ptrArray * cache, const char * host )
164{
165    struct dns_cache_item key;
166    key.host = (char*) host;
167    dns_cache_item_free( tr_ptrArrayRemoveSorted( cache, &key, dns_cache_compare ) );
168}
169
170static tr_dns_result
171dns_cache_lookup( struct tr_web_task * task, const char * host, const char ** resolved )
172{
173    tr_dns_result result = TR_DNS_UNTESTED;
174
175    if( task->session->web != NULL )
176    {
177        struct dns_cache_item key;
178        struct dns_cache_item * item;
179        tr_ptrArray * cache = &task->session->web->dns_cache;
180
181        key.host = (char*) host;
182        item = tr_ptrArrayFindSorted( cache, &key, dns_cache_compare );
183
184        /* has the ttl expired? */
185        if( ( item != NULL ) && ( item->expiration <= tr_time( ) ) )
186        {
187            dns_cache_clear_entry( cache, host );
188            item = NULL;
189        }
190
191        if( item != NULL )
192        {
193            result = item->success ? TR_DNS_OK : TR_DNS_FAIL;
194
195            if( result == TR_DNS_OK )
196            {
197                *resolved = item->resolved_host;
198           
199                dbgmsg( "found cached dns entry for \"%s\": %s", host, *resolved );
200            }
201        }
202    }
203
204    return result;
205}
206
207static void
208dns_cache_set_fail( struct tr_web_task * task, const char * host )
209{
210    if( ( task->session->web != NULL ) && ( host != NULL ) )
211    {
212        struct dns_cache_item * item;
213        tr_ptrArray * cache = &task->session->web->dns_cache;
214
215        dns_cache_clear_entry( cache, host );
216
217        item = tr_new( struct dns_cache_item, 1 );
218        item->host = tr_strdup( host );
219        item->resolved_host = NULL;
220        item->expiration = tr_time( ) + MIN_DNS_CACHE_TIME;
221        item->success = FALSE;
222        tr_ptrArrayInsertSorted( cache, item, dns_cache_compare );
223    }
224}
225
226static const char*
227dns_cache_set_name( struct tr_web_task * task, const char * host,
228                   const char * resolved, int ttl )
229{
230    char * ret = NULL;
231
232    ttl = MAX( MIN_DNS_CACHE_TIME, ttl );
233
234    if( task->session->web != NULL )
235    {
236        struct dns_cache_item * item;
237        tr_ptrArray * cache = &task->session->web->dns_cache;
238
239        dns_cache_clear_entry( cache, host );
240
241        item = tr_new( struct dns_cache_item, 1 );
242        item->host = tr_strdup( host );
243        item->resolved_host = tr_strdup( resolved );
244        item->expiration = tr_time( ) + ttl;
245        item->success = TRUE;
246        tr_ptrArrayInsertSorted( cache, item, dns_cache_compare );
247        ret = item->resolved_host;
248        dbgmsg( "adding dns cache entry for \"%s\": %s", host, resolved );
249    }
250    return ret;
251}
252
253/***
254****
255***/
256
257static size_t
258writeFunc( void * ptr, size_t size, size_t nmemb, void * vtask )
259{
260    const size_t byteCount = size * nmemb;
261    struct tr_web_task * task = vtask;
262    evbuffer_add( task->response, ptr, byteCount );
263    dbgmsg( "wrote %zu bytes to task %p's buffer", byteCount, task );
264    return byteCount;
265}
266
267static int
268sockoptfunction( void * vtask, curl_socket_t fd, curlsocktype purpose UNUSED )
269{
270    struct tr_web_task * task = vtask;
271    const tr_bool isScrape = strstr( task->url, "scrape" ) != NULL;
272    const tr_bool isAnnounce = strstr( task->url, "announce" ) != NULL;
273
274    /* announce and scrape requests have tiny payloads. */
275    if( isScrape || isAnnounce )
276    {
277        const int sndbuf = 1024;
278        const int rcvbuf = isScrape ? 2048 : 3072;
279        setsockopt( fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf) );
280        setsockopt( fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf) );
281    }
282
283    /* return nonzero if this function encountered an error */
284    return 0;
285}
286
287static int
288getCurlProxyType( tr_proxy_type t )
289{
290    if( t == TR_PROXY_SOCKS4 ) return CURLPROXY_SOCKS4;
291    if( t == TR_PROXY_SOCKS5 ) return CURLPROXY_SOCKS5;
292    return CURLPROXY_HTTP;
293}
294
295static int
296getTimeoutFromURL( const char * url )
297{
298    if( strstr( url, "scrape" ) != NULL ) return 30;
299    if( strstr( url, "announce" ) != NULL ) return 120;
300    return 240;
301}
302
303static void task_timeout_cb( int fd UNUSED, short what UNUSED, void * task );
304static void task_finish( struct tr_web_task * task, long response_code );
305
306static void
307addTask( void * vtask )
308{
309    struct tr_web_task * task = vtask;
310    const tr_session * session = task->session;
311
312    if( ( session == NULL ) || ( session->web == NULL ) )
313        return;
314
315    if( !task->resolved_host )
316    {
317        dbgmsg( "couldn't resolve host for \"%s\"... task failed", task->url );
318        task_finish( task, 0 );
319    }
320    else
321    {
322        CURL * e = curl_easy_init( );
323        struct tr_web * web = session->web;
324        const int timeout = getTimeoutFromURL( task->url );
325        const long verbose = getenv( "TR_CURL_VERBOSE" ) != NULL;
326        const char * user_agent = TR_NAME "/" SHORT_VERSION_STRING;
327
328        /* insert the resolved host into the URL s.t. curl's DNS won't block
329         * even if -- like on most OSes -- it wasn't built with C-Ares :(
330         * "http://www.craptrackular.org/announce?key=val&key2=..." becomes
331         * "http://127.0.0.1/announce?key=val&key2=..." */
332        {
333            char * host;
334            struct evbuffer * buf = evbuffer_new( );
335            char * pch = strstr( task->url, task->host );
336            char * tail = pch + strlen( task->host );
337            evbuffer_add( buf, task->url, pch - task->url );
338            evbuffer_add_printf( buf, "%s", task->resolved_host );
339            evbuffer_add_printf( buf, "%s", tail );
340            task->resolved_url = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
341            dbgmsg( "old url: \"%s\" -- new url: \"%s\"", task->url, task->resolved_url );
342            evbuffer_free( buf );
343
344            /* Manually add a Host: argument that refers to the true URL */
345            if( ( ( task->port <= 0 ) ) ||
346                ( ( task->port == 80 ) && !strncmp( task->url, "http://", 7 ) ) ||
347                ( ( task->port == 443 ) && !strncmp( task->url, "https://", 8 ) ) )
348                host = tr_strdup_printf( "Host: %s", task->host );
349            else
350                host = tr_strdup_printf( "Host: %s:%d", task->host, task->port );
351
352            task->slist = curl_slist_append( NULL, host );
353            task->slist = curl_slist_append( task->slist, "Accept:" );
354            curl_easy_setopt( e, CURLOPT_HTTPHEADER, task->slist );
355            tr_free( host );
356        }
357
358        dbgmsg( "adding task #%lu [%s]", task->tag, task->resolved_url ? task->resolved_url : task->url );
359
360        if( !task->range && session->isProxyEnabled ) {
361            curl_easy_setopt( e, CURLOPT_PROXY, session->proxy );
362            curl_easy_setopt( e, CURLOPT_PROXYAUTH, CURLAUTH_ANY );
363            curl_easy_setopt( e, CURLOPT_PROXYPORT, session->proxyPort );
364            curl_easy_setopt( e, CURLOPT_PROXYTYPE,
365                                      getCurlProxyType( session->proxyType ) );
366        }
367        if( !task->range && session->isProxyAuthEnabled ) {
368            char * str = tr_strdup_printf( "%s:%s", session->proxyUsername,
369                                                    session->proxyPassword );
370            curl_easy_setopt( e, CURLOPT_PROXYUSERPWD, str );
371            tr_free( str );
372        }
373
374        task->easy = e;
375        task->multi = web->multi;
376
377        /* use our own timeout instead of CURLOPT_TIMEOUT because the latter
378         * doesn't play nicely with curl_multi.  See curl bug #2501457 */
379        task->timer_event_isSet = TRUE;
380        evtimer_set( &task->timer_event, task_timeout_cb, task );
381        tr_timerAdd( &task->timer_event, timeout, 0 );
382
383        curl_easy_setopt( e, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4 );
384        curl_easy_setopt( e, CURLOPT_SOCKOPTFUNCTION, sockoptfunction );
385        curl_easy_setopt( e, CURLOPT_SOCKOPTDATA, task );
386        curl_easy_setopt( e, CURLOPT_WRITEDATA, task );
387        curl_easy_setopt( e, CURLOPT_WRITEFUNCTION, writeFunc );
388        curl_easy_setopt( e, CURLOPT_DNS_CACHE_TIMEOUT, MIN_DNS_CACHE_TIME );
389        curl_easy_setopt( e, CURLOPT_FOLLOWLOCATION, 1L );
390        curl_easy_setopt( e, CURLOPT_AUTOREFERER, 1L );
391        curl_easy_setopt( e, CURLOPT_FORBID_REUSE, 1L );
392        curl_easy_setopt( e, CURLOPT_MAXREDIRS, -1L );
393        curl_easy_setopt( e, CURLOPT_PRIVATE, task );
394        curl_easy_setopt( e, CURLOPT_SSL_VERIFYHOST, 0L );
395        curl_easy_setopt( e, CURLOPT_SSL_VERIFYPEER, 0L );
396        curl_easy_setopt( e, CURLOPT_URL, task->resolved_url ? task->resolved_url : task->url );
397        curl_easy_setopt( e, CURLOPT_USERAGENT, user_agent );
398        curl_easy_setopt( e, CURLOPT_VERBOSE, verbose );
399        if( web->haveAddr )
400            curl_easy_setopt( e, CURLOPT_INTERFACE, tr_ntop_non_ts( &web->addr ) );
401        if( task->range )
402            curl_easy_setopt( e, CURLOPT_RANGE, task->range );
403
404        if( curl_multi_add_handle( web->multi, e ) == CURLM_OK )
405            ++web->taskCount;
406    }
407}
408
409static void
410dns_ipv6_done_cb( int err, char type, int count, int ttl, void * addresses, void * vtask )
411{
412    struct tr_web_task * task = vtask;
413
414    if( !err && task->host && ( count>0 ) && ( ttl>=0 ) && ( type==DNS_IPv6_AAAA ) )
415    {
416        int i;
417        char buf[INET6_ADDRSTRLEN+1];
418        struct in6_addr *in6_addrs = addresses;
419
420        for( i=0; i<count; ++i ) {
421            const char * b = inet_ntop(AF_INET6, &in6_addrs[i], buf,sizeof(buf));
422            if( b != NULL ) {
423                /* FIXME: is there a better way to tell which one to use if count > 1? */
424                task->resolved_host = dns_cache_set_name( task, task->host, b, ttl );
425                break;
426            }
427        }
428    }
429
430    if( task->resolved_host == NULL )
431        dns_cache_set_fail( task, task->host );
432
433    addTask( task );
434}
435
436static void
437dns_ipv4_done_cb( int err, char type, int count, int ttl, void * addresses, void * vtask )
438{
439    struct tr_web_task * task = vtask;
440
441    if( !err && task->host && ( count>0 ) && ( ttl>=0 ) && ( type==DNS_IPv4_A ) )
442    {
443        struct in_addr * in_addrs = addresses;
444        const char * resolved = inet_ntoa( in_addrs[0] );
445        task->resolved_host = dns_cache_set_name( task, task->host, resolved, ttl );
446        /* FIXME: if count > 1, is there a way to decide which is best to use? */
447    }
448
449    if( ( task->resolved_host != NULL )
450            || ( task->host == NULL )
451            || evdns_resolve_ipv6( task->host, 0, dns_ipv6_done_cb, task ) )
452        dns_ipv6_done_cb( DNS_ERR_UNKNOWN, DNS_IPv6_AAAA, 0, 0, NULL, task );
453}
454
455static void
456doDNS( void * vtask )
457{
458    tr_address addr;
459    int port = -1;
460    char * host = NULL;
461    struct tr_web_task * task = vtask;
462    tr_dns_result lookup_result = TR_DNS_UNTESTED;
463
464    assert( task->resolved_host == NULL );
465
466    if( !tr_urlParse( task->url, -1, NULL, &host, &port, NULL ) )
467    {
468        task->port = port;
469        task->host = host;
470
471        /* If 'host' is an IPv4 or IPv6 address in text form, use it as-is.
472         * Otherwise, see if its resolved name is in our DNS cache */
473        if( tr_pton( task->host, &addr ) != NULL )
474        {
475            task->resolved_host = task->host;
476            lookup_result = TR_DNS_OK;
477        }
478        else
479        {
480            lookup_result = dns_cache_lookup( task, host, &task->resolved_host );
481        }
482    }
483
484    if( lookup_result != TR_DNS_UNTESTED )
485    {
486        addTask( task );
487    }
488    else if( !host || evdns_resolve_ipv4( host, 0, dns_ipv4_done_cb, task ) )
489    {
490        dns_ipv4_done_cb( DNS_ERR_UNKNOWN, DNS_IPv4_A, 0, 0, NULL, task );
491    }
492}
493
494/***
495****
496***/
497
498static void
499task_finish( struct tr_web_task * task, long response_code )
500{
501    dbgmsg( "finished web task %lu; got %ld", task->tag, response_code );
502
503    if( task->done_func != NULL )
504        task->done_func( task->session,
505                         response_code,
506                         EVBUFFER_DATA( task->response ),
507                         EVBUFFER_LENGTH( task->response ),
508                         task->done_func_user_data );
509    task_free( task );
510}
511
512static void
513remove_task( struct tr_web_task * task )
514{
515    long code;
516
517    curl_easy_getinfo( task->easy, CURLINFO_RESPONSE_CODE, &code );
518    curl_multi_remove_handle( task->multi, task->easy );
519    curl_easy_cleanup( task->easy );
520    task_finish( task, code );
521}
522
523static void
524task_timeout_cb( int fd UNUSED, short what UNUSED, void * task )
525{
526    remove_task( task );
527}
528
529static void
530remove_finished_tasks( tr_web * g )
531{
532    CURLMsg * msg;
533    int msgs_left;
534
535    while(( msg = curl_multi_info_read( g->multi, &msgs_left ))) {
536        if(( msg->msg == CURLMSG_DONE ) && ( msg->easy_handle != NULL )) {
537            struct tr_web_task * task;
538            CURL * e = msg->easy_handle;
539            curl_easy_getinfo( e, CURLINFO_PRIVATE, (void*)&task );
540            assert( e == task->easy );
541            remove_task( task );
542        }
543    }
544}
545
546static void
547restart_timer( tr_web * g )
548{
549    dbgmsg( "adding a timeout for %.1f seconds from now", g->timer_msec/1000.0 );
550    evtimer_del( &g->timer_event );
551    tr_timerAddMsec( &g->timer_event, g->timer_msec );
552}
553
554static void
555tr_multi_perform( tr_web * g, int fd, int curl_what )
556{
557    CURLMcode m;
558
559    dbgmsg( "check_run_count: %d taskCount", g->taskCount );
560
561    /* invoke libcurl's processing */
562    do
563        m = curl_multi_socket_action( g->multi, fd, curl_what, &g->taskCount );
564    while( m == CURLM_CALL_MULTI_SOCKET );
565
566    remove_finished_tasks( g );
567
568    if( g->closing && !g->taskCount )
569        web_free( g );
570    else
571        restart_timer( g );
572}
573
574/* libevent says that sock is ready to be processed, so wake up libcurl */
575static void
576event_cb( int fd, short ev_what, void * g )
577{
578    int curl_what = 0;
579    if( ev_what & EV_READ ) curl_what |= CURL_POLL_IN;
580    if( ev_what & EV_WRITE ) curl_what |= CURL_POLL_OUT;
581    tr_multi_perform( g, fd, curl_what );
582}
583
584/* CURLMOPT_SOCKETFUNCTION */
585static int
586sock_cb( CURL * e UNUSED, curl_socket_t fd, int curl_what,
587         void * vweb, void * vevent )
588{
589    /*static int num_events = 0;*/
590    struct tr_web * web = vweb;
591    struct event * io_event = vevent;
592    dbgmsg( "sock_cb: curl_what %d, fd %d, io_event %p",
593            curl_what, (int)fd, io_event );
594
595    if( io_event != NULL )
596        event_del( io_event );
597
598    if( curl_what & ( CURL_POLL_IN | CURL_POLL_OUT ) )
599    {
600        const short ev_what = EV_PERSIST
601                           | (( curl_what & CURL_POLL_IN ) ? EV_READ : 0 )
602                           | (( curl_what & CURL_POLL_OUT ) ? EV_WRITE : 0 );
603
604        if( io_event == NULL ) {
605            io_event = tr_new0( struct event, 1 );
606            curl_multi_assign( web->multi, fd, io_event );
607            /*fprintf( stderr, "+1 io_events to %d\n", ++num_events );*/
608        }
609
610        dbgmsg( "enabling (libevent %hd, libcurl %d) on io_event %p, fd %d",
611                ev_what, curl_what, io_event, fd );
612        event_set( io_event, fd, ev_what, event_cb, web );
613        assert( io_event->ev_base != NULL );
614        event_add( io_event, NULL );
615    }
616
617    if( ( io_event != NULL ) && ( curl_what & CURL_POLL_REMOVE ) )
618    {
619        memset( io_event, TR_MEMORY_TRASH, sizeof( struct event ) );
620        tr_free( io_event );
621        /*fprintf( stderr, "-1 io_events to %d\n", --num_events );*/
622    }
623
624    return 0; /* libcurl documentation: "The callback MUST return 0." */
625}
626
627/* libevent says that timer_msec have passed, so wake up libcurl */
628static void
629libevent_timer_cb( int fd UNUSED, short what UNUSED, void * g )
630{
631    dbgmsg( "libevent timer is done" );
632    tr_multi_perform( g, CURL_SOCKET_TIMEOUT, 0 );
633}
634
635/* libcurl documentation: "If 0, it means you should proceed immediately
636 * without waiting for anything. If it returns -1, there's no timeout at all
637 * set ... (but) you must not wait too long (more than a few seconds perhaps)
638 * before you call curl_multi_perform() again."  */
639static void
640multi_timer_cb( CURLM * multi UNUSED, long timer_msec, void * vg )
641{
642    tr_web * g = vg;
643
644    g->timer_msec = timer_msec > 0 ? timer_msec : DEFAULT_TIMER_MSEC;
645
646    if( timer_msec < 1 )
647        tr_multi_perform( g, CURL_SOCKET_TIMEOUT, 0 );
648    else
649        restart_timer( g );
650}
651
652/****
653*****
654****/
655
656void
657tr_webRun( tr_session         * session,
658           const char         * url,
659           const char         * range,
660           tr_web_done_func     done_func,
661           void               * done_func_user_data )
662{
663    if( session->web != NULL )
664    {
665        static unsigned long tag = 0;
666        struct tr_web_task * task = tr_new0( struct tr_web_task, 1 );
667        task->session = session;
668        task->url = tr_strdup( url );
669        task->range = tr_strdup( range );
670        task->done_func = done_func;
671        task->done_func_user_data = done_func_user_data;
672        task->tag = ++tag;
673        task->response = evbuffer_new( );
674        tr_runInEventThread( session, doDNS, task );
675    }
676}
677
678void
679tr_webSetInterface( tr_web * web, const tr_address * addr )
680{
681    if(( web->haveAddr = ( addr != NULL )))
682        web->addr = *addr;
683}
684
685tr_web*
686tr_webInit( tr_session * session )
687{
688    tr_web * web;
689
690    /* try to enable ssl for https support; but if that fails,
691     * try a plain vanilla init */
692    if( curl_global_init( CURL_GLOBAL_SSL ) )
693        curl_global_init( 0 );
694
695    web = tr_new0( struct tr_web, 1 );
696    web->dns_cache = TR_PTR_ARRAY_INIT;
697    web->session = session;
698    web->timer_msec = DEFAULT_TIMER_MSEC; /* overwritten by multi_timer_cb() */
699    evtimer_set( &web->timer_event, libevent_timer_cb, web );
700
701    web->multi = curl_multi_init( );
702
703    evdns_init( );
704
705    curl_multi_setopt( web->multi, CURLMOPT_SOCKETDATA, web );
706    curl_multi_setopt( web->multi, CURLMOPT_SOCKETFUNCTION, sock_cb );
707    curl_multi_setopt( web->multi, CURLMOPT_TIMERDATA, web );
708    curl_multi_setopt( web->multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb );
709
710    return web;
711}
712
713void
714tr_webClose( tr_web ** web_in )
715{
716    tr_web * web = *web_in;
717    *web_in = NULL;
718    if( web->taskCount < 1 )
719        web_free( web );
720    else
721        web->closing = 1;
722}
723
724/*****
725******
726******
727*****/
728
729const char *
730tr_webGetResponseStr( long code )
731{
732    switch( code )
733    {
734        case   0: return "No Response";
735        case 101: return "Switching Protocols";
736        case 200: return "OK";
737        case 201: return "Created";
738        case 202: return "Accepted";
739        case 203: return "Non-Authoritative Information";
740        case 204: return "No Content";
741        case 205: return "Reset Content";
742        case 206: return "Partial Content";
743        case 300: return "Multiple Choices";
744        case 301: return "Moved Permanently";
745        case 302: return "Found";
746        case 303: return "See Other";
747        case 304: return "Not Modified";
748        case 305: return "Use Proxy";
749        case 306: return "(Unused)";
750        case 307: return "Temporary Redirect";
751        case 400: return "Bad Request";
752        case 401: return "Unauthorized";
753        case 402: return "Payment Required";
754        case 403: return "Forbidden";
755        case 404: return "Not Found";
756        case 405: return "Method Not Allowed";
757        case 406: return "Not Acceptable";
758        case 407: return "Proxy Authentication Required";
759        case 408: return "Request Timeout";
760        case 409: return "Conflict";
761        case 410: return "Gone";
762        case 411: return "Length Required";
763        case 412: return "Precondition Failed";
764        case 413: return "Request Entity Too Large";
765        case 414: return "Request-URI Too Long";
766        case 415: return "Unsupported Media Type";
767        case 416: return "Requested Range Not Satisfiable";
768        case 417: return "Expectation Failed";
769        case 500: return "Internal Server Error";
770        case 501: return "Not Implemented";
771        case 502: return "Bad Gateway";
772        case 503: return "Service Unavailable";
773        case 504: return "Gateway Timeout";
774        case 505: return "HTTP Version Not Supported";
775        default:  return "Unknown Error";
776    }
777}
778
779void
780tr_http_escape( struct evbuffer  * out,
781                const char * str, int len, tr_bool escape_slashes )
782{
783    int i;
784
785    if( ( len < 0 ) && ( str != NULL ) )
786        len = strlen( str );
787
788    for( i = 0; i < len; i++ ) {
789        if( str[i] == ',' || str[i] == '-' || str[i] == '.'
790            || ( '0' <= str[i] && str[i] <= '9' )
791            || ( 'A' <= str[i] && str[i] <= 'Z' )
792            || ( 'a' <= str[i] && str[i] <= 'z' )
793            || ( str[i] == '/' && !escape_slashes ) )
794            evbuffer_add( out, &str[i], 1 );
795        else
796            evbuffer_add_printf( out, "%%%02X", (unsigned)(str[i]&0xFF) );
797    }
798}
799
800char *
801tr_http_unescape( const char * str, int len )
802{
803    char * tmp = curl_unescape( str, len );
804    char * ret = tr_strdup( tmp );
805    curl_free( tmp );
806    return ret;
807}
Note: See TracBrowser for help on using the repository browser.