source: trunk/libtransmission/trevent.c @ 6811

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

(libT) make sure to init the rpc server with the correct event base.

  • Property svn:keywords set to Date Rev Author Id
File size: 6.8 KB
Line 
1/*
2 * This file Copyright (C) 2007-2008 Charles Kerr <charles@rebelbase.com>
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: trevent.c 6811 2008-09-29 04:26:52Z charles $
11 */
12
13#include <assert.h>
14#include <errno.h>
15#include <stdlib.h>
16#include <string.h>
17#include <stdio.h>
18
19#include <signal.h>
20
21#ifdef WIN32
22 #include <fcntl.h>
23 #define pipe( f ) _pipe( f, 1000, _O_BINARY )
24#else
25 #include <unistd.h>
26#endif
27
28#include <event.h>
29
30#include "transmission.h"
31#include "platform.h"
32#include "trevent.h"
33#include "utils.h"
34
35/***
36****
37***/
38
39typedef struct tr_event_handle
40{
41    uint8_t      die;
42    int          fds[2];
43    tr_lock *    lock;
44    tr_handle *  h;
45    tr_thread *  thread;
46    struct event_base * base;
47    struct event pipeEvent;
48}
49tr_event_handle;
50
51typedef int timer_func ( void* );
52
53struct tr_timer
54{
55    struct event              event;
56    struct timeval            tv;
57    timer_func *              func;
58    void *                    user_data;
59    struct tr_event_handle *  eh;
60    uint8_t                   inCallback;
61};
62
63struct tr_run_data
64{
65    void    ( *func )( void * );
66    void *  user_data;
67};
68
69#define dbgmsg( fmt... ) tr_deepLog( __FILE__, __LINE__, "event", ## fmt )
70
71static void
72readFromPipe( int    fd,
73              short  eventType,
74              void * veh )
75{
76    char              ch;
77    int               ret;
78    tr_event_handle * eh = veh;
79
80    dbgmsg( "readFromPipe: eventType is %hd", eventType );
81
82    /* read the command type */
83    ch = '\0';
84    do
85    {
86        ret = read( fd, &ch, 1 );
87    }
88    while( !eh->die && ret < 0 && errno == EAGAIN );
89
90    dbgmsg( "command is [%c], ret is %d, errno is %d", ch, ret, (int)errno );
91
92    switch( ch )
93    {
94        case 'r': /* run in libevent thread */
95        {
96            struct tr_run_data data;
97            const size_t       nwant = sizeof( data );
98            const ssize_t      ngot = read( fd, &data, nwant );
99            if( !eh->die && ( ngot == (ssize_t)nwant ) )
100            {
101                dbgmsg( "invoking function in libevent thread" );
102                ( data.func )( data.user_data );
103            }
104            break;
105        }
106
107        case 't': /* create timer */
108        {
109            tr_timer *    timer;
110            const size_t  nwant = sizeof( timer );
111            const ssize_t ngot = read( fd, &timer, nwant );
112            if( !eh->die && ( ngot == (ssize_t)nwant ) )
113            {
114                dbgmsg( "adding timer in libevent thread" );
115                evtimer_add( &timer->event, &timer->tv );
116            }
117            break;
118        }
119
120        case '\0': /* eof */
121        {
122            dbgmsg( "pipe eof reached... removing event listener" );
123            event_del( &eh->pipeEvent );
124            break;
125        }
126
127        default:
128        {
129            assert( 0 && "unhandled command type!" );
130            break;
131        }
132    }
133}
134
135static void
136logFunc( int          severity,
137         const char * message )
138{
139    if( severity >= _EVENT_LOG_ERR )
140        tr_nerr( "%s", message );
141    else
142        tr_ndbg( "%s", message );
143}
144
145static void
146libeventThreadFunc( void * veh )
147{
148    tr_event_handle * eh = (tr_event_handle *) veh;
149
150    tr_dbg( "Starting libevent thread" );
151
152#ifndef WIN32
153    /* Don't exit when writing on a broken socket */
154    signal( SIGPIPE, SIG_IGN );
155#endif
156
157    eh->base = event_init( );
158    eh->h->events = eh;
159    event_set_log_callback( logFunc );
160
161    /* listen to the pipe's read fd */
162    event_set( &eh->pipeEvent, eh->fds[0], EV_READ | EV_PERSIST,
163               readFromPipe,
164               veh );
165    event_add( &eh->pipeEvent, NULL );
166
167    event_dispatch( );
168
169    tr_lockFree( eh->lock );
170    event_base_free( eh->base );
171    eh->h->events = NULL;
172    tr_free( eh );
173    tr_dbg( "Closing libevent thread" );
174}
175
176void
177tr_eventInit( tr_handle * handle )
178{
179    tr_event_handle * eh;
180
181    eh = tr_new0( tr_event_handle, 1 );
182    eh->lock = tr_lockNew( );
183    pipe( eh->fds );
184    eh->h = handle;
185    eh->thread = tr_threadNew( libeventThreadFunc, eh );
186}
187
188void
189tr_eventClose( tr_handle * handle )
190{
191    handle->events->die = TRUE;
192    tr_deepLog( __FILE__, __LINE__, NULL, "closing trevent pipe" );
193    close( handle->events->fds[1] );
194}
195
196/**
197***
198**/
199
200int
201tr_amInEventThread( struct tr_handle * handle )
202{
203    return tr_amInThread( handle->events->thread );
204}
205
206/**
207***
208**/
209
210static void
211timerCallback( int fd      UNUSED,
212               short event UNUSED,
213               void *      vtimer )
214{
215    int               more;
216    struct tr_timer * timer = vtimer;
217
218    timer->inCallback = 1;
219    more = ( *timer->func )( timer->user_data );
220    timer->inCallback = 0;
221
222    if( more )
223        evtimer_add( &timer->event, &timer->tv );
224    else
225        tr_timerFree( &timer );
226}
227
228void
229tr_timerFree( tr_timer ** ptimer )
230{
231    tr_timer * timer;
232
233    /* zero out the argument passed in */
234    assert( ptimer );
235    timer = *ptimer;
236    *ptimer = NULL;
237
238    /* destroy the timer directly or via the command queue */
239    if( timer && !timer->inCallback )
240    {
241        assert( tr_amInEventThread( timer->eh->h ) );
242        event_del( &timer->event );
243        tr_free( timer );
244    }
245}
246
247tr_timer*
248tr_timerNew( struct tr_handle * handle,
249             timer_func         func,
250             void *             user_data,
251             uint64_t           interval_milliseconds )
252{
253    tr_timer * timer = tr_new0( tr_timer, 1 );
254
255    timer->tv = tr_timevalMsec( interval_milliseconds );
256    timer->func = func;
257    timer->user_data = user_data;
258    timer->eh = handle->events;
259    evtimer_set( &timer->event, timerCallback, timer );
260
261    if( tr_amInThread( handle->events->thread ) )
262    {
263        evtimer_add( &timer->event,  &timer->tv );
264    }
265    else
266    {
267        const char ch = 't';
268        int        fd = handle->events->fds[1];
269        tr_lock *  lock = handle->events->lock;
270
271        tr_lockLock( lock );
272        write( fd, &ch, 1 );
273        write( fd, &timer, sizeof( timer ) );
274        tr_lockUnlock( lock );
275    }
276
277    return timer;
278}
279
280void
281tr_runInEventThread( struct tr_handle *       handle,
282                     void               func( void* ),
283                     void *                   user_data )
284{
285    if( tr_amInThread( handle->events->thread ) )
286    {
287        (func)( user_data );
288    }
289    else
290    {
291        const char         ch = 'r';
292        int                fd = handle->events->fds[1];
293        tr_lock *          lock = handle->events->lock;
294        struct tr_run_data data;
295
296        tr_lockLock( lock );
297        write( fd, &ch, 1 );
298        data.func = func;
299        data.user_data = user_data;
300        write( fd, &data, sizeof( data ) );
301        tr_lockUnlock( lock );
302    }
303}
304
305struct event_base *
306tr_eventGetBase( tr_session * session )
307{
308    return session->events->base;
309}
Note: See TracBrowser for help on using the repository browser.