source: trunk/libtransmission/web.c @ 10019

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

(trunk libT) #2792 "since 1.80 update downloads failing" -- try to handle non-resolving tracker addresses without blocking in curl

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