source: trunk/libtransmission/web.c @ 10024

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

(trunk libT) web.c: add a cache for unresolvable hostnames

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