source: trunk/libtransmission/web.c @ 9704

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

(trunk libT) finally get rid of the last remnants of tr_timer

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