static void
libeventThreadFunc( void * veh )
{
tr_event_handle * eh = veh;
tr_dbg( "Starting libevent thread" );
#ifndef WIN32
/* Don't exit when writing on a broken socket */
signal( SIGPIPE, SIG_IGN );
#endif
eh->h->events = eh;
/* listen to the pipe's read fd */
event_set( &eh->pipeEvent, eh->fds[0], EV_READ | EV_PERSIST,
readFromPipe,
veh );
event_add( &eh->pipeEvent, NULL );
event_set_log_callback( logFunc );
event_dispatch( );
tr_lockFree( eh->lock );
event_base_free( eh->base );
eh->h->events = NULL;
tr_free( eh );
tr_dbg( "Closing libevent thread" );
}
void
tr_sessionClose( tr_session * session )
{
int i;
const int maxwait_msec = SHUTDOWN_MAX_SECONDS * 1000;
const uint64_t deadline = tr_date( ) + maxwait_msec;
assert( tr_isSession( session ) );
dbgmsg( "shutting down transmission session %p", session );
/* close the session */
tr_runInEventThread( session, tr_closeAllConnections, session );
while( !session->isClosed && !deadlineReached( deadline ) )
{
dbgmsg(
"waiting for the shutdown commands to run in the main thread" );
tr_wait( 100 );
}
/* "shared" and "tracker" have live sockets,
* so we need to keep the transmission thread alive
* for a bit while they tell the router & tracker
* that we're closing now */
while( ( session->shared
|| session->tracker ) && !deadlineReached( deadline ) )
{
dbgmsg( "waiting on port unmap (%p) or tracker (%p)",
session->shared, session->tracker );
tr_wait( 100 );
}
tr_fdClose( );
/* close the libtransmission thread */
tr_eventClose( session );
while( session->events && !deadlineReached( deadline ) )
{
dbgmsg( "waiting for the libevent thread to shutdown cleanly" );
tr_wait( 100 );
}
/* free the session memory */
tr_bandwidthFree( session->bandwidth );
tr_lockFree( session->lock );
for( i = 0; i < session->metainfoLookupCount; ++i )
tr_free( session->metainfoLookup[i].filename );
tr_free( session->metainfoLookup );
tr_free( session->tag );
tr_free( session->configDir );
tr_free( session->resumeDir );
tr_free( session->torrentDir );
tr_free( session->downloadDir );
tr_free( session->proxy );
tr_free( session->proxyUsername );
tr_free( session->proxyPassword );
tr_free( session );
}
void
tr_fdClose( void )
{
int i = 0;
for( i = 0; i < TR_MAX_OPEN_FILES; ++i )
if( fileIsOpen( &gFd->open[i] ) )
TrCloseFile( i );
tr_lockFree( gFd->lock );
tr_free( gFd );
gFd = NULL;
}
static void
libeventThreadFunc (void * veh)
{
struct event_base * base;
tr_event_handle * eh = veh;
#ifndef WIN32
/* Don't exit when writing on a broken socket */
signal (SIGPIPE, SIG_IGN);
#endif
/* create the libevent bases */
base = event_base_new ();
/* set the struct's fields */
eh->base = base;
eh->session->event_base = base;
eh->session->evdns_base = evdns_base_new (base, true);
eh->session->events = eh;
/* listen to the pipe's read fd */
eh->pipeEvent = event_new (base, eh->fds[0], EV_READ | EV_PERSIST, readFromPipe, veh);
event_add (eh->pipeEvent, NULL);
event_set_log_callback (logFunc);
/* loop until all the events are done */
while (!eh->die)
event_base_dispatch (base);
/* shut down the thread */
tr_lockFree (eh->lock);
event_base_free (base);
eh->session->events = NULL;
tr_free (eh);
tr_logAddDebug ("Closing libevent thread");
}
static void
tr_webThreadFunc( void * vsession )
{
int unused;
CURLM * multi;
struct tr_web * web;
int taskCount = 0;
tr_session * session = vsession;
/* try to enable ssl for https support; but if that fails,
* try a plain vanilla init */
if( curl_global_init( CURL_GLOBAL_SSL ) )
curl_global_init( 0 );
web = tr_new0( struct tr_web, 1 );
web->close_mode = ~0;
web->taskLock = tr_lockNew( );
web->tasks = NULL;
multi = curl_multi_init( );
session->web = web;
for( ;; )
{
long msec;
CURLMsg * msg;
CURLMcode mcode;
struct tr_web_task * task;
if( web->close_mode == TR_WEB_CLOSE_NOW )
break;
if( ( web->close_mode == TR_WEB_CLOSE_WHEN_IDLE ) && !taskCount )
break;
/* add tasks from the queue */
tr_lockLock( web->taskLock );
while(( task = tr_list_pop_front( &web->tasks )))
{
dbgmsg( "adding task to curl: [%s]", task->url );
curl_multi_add_handle( multi, createEasy( session, task ));
/*fprintf( stderr, "adding a task.. taskCount is now %d\n", taskCount );*/
++taskCount;
}
tr_lockUnlock( web->taskLock );
/* maybe wait a little while before calling curl_multi_perform() */
msec = 0;
curl_multi_timeout( multi, &msec );
if( msec < 0 )
msec = THREADFUNC_MAX_SLEEP_MSEC;
if( msec > 0 )
{
int usec;
int max_fd;
struct timeval t;
fd_set r_fd_set, w_fd_set, c_fd_set;
max_fd = 0;
FD_ZERO( &r_fd_set );
FD_ZERO( &w_fd_set );
FD_ZERO( &c_fd_set );
curl_multi_fdset( multi, &r_fd_set, &w_fd_set, &c_fd_set, &max_fd );
if( msec > THREADFUNC_MAX_SLEEP_MSEC )
msec = THREADFUNC_MAX_SLEEP_MSEC;
usec = msec * 1000;
t.tv_sec = usec / 1000000;
t.tv_usec = usec % 1000000;
tr_select( max_fd+1, &r_fd_set, &w_fd_set, &c_fd_set, &t );
}
/* call curl_multi_perform() */
do {
mcode = curl_multi_perform( multi, &unused );
} while( mcode == CURLM_CALL_MULTI_PERFORM );
/* pump completed tasks from the multi */
while(( msg = curl_multi_info_read( multi, &unused )))
{
if(( msg->msg == CURLMSG_DONE ) && ( msg->easy_handle != NULL ))
{
struct tr_web_task * task;
CURL * e = msg->easy_handle;
curl_easy_getinfo( e, CURLINFO_PRIVATE, (void*)&task );
curl_easy_getinfo( e, CURLINFO_RESPONSE_CODE, &task->code );
curl_multi_remove_handle( multi, e );
curl_easy_cleanup( e );
/*fprintf( stderr, "removing a completed task.. taskCount is now %d (response code: %d, response len: %d)\n", taskCount, (int)task->code, (int)evbuffer_get_length(task->response) );*/
tr_runInEventThread( task->session, task_finish_func, task );
--taskCount;
}
}
}
/* cleanup */
curl_multi_cleanup( multi );
tr_lockFree( web->taskLock );
tr_free( web );
session->web = NULL;
}
static void
tr_webThreadFunc( void * vsession )
{
CURLM * multi;
struct tr_web * web;
int taskCount = 0;
struct tr_web_task * task;
tr_session * session = vsession;
/* try to enable ssl for https support; but if that fails,
* try a plain vanilla init */
if( curl_global_init( CURL_GLOBAL_SSL ) )
curl_global_init( 0 );
web = tr_new0( struct tr_web, 1 );
web->close_mode = ~0;
web->taskLock = tr_lockNew( );
web->tasks = NULL;
web->curl_verbose = getenv( "TR_CURL_VERBOSE" ) != NULL;
web->cookie_filename = tr_buildPath( session->configDir, "cookies.txt", NULL );
multi = curl_multi_init( );
session->web = web;
for( ;; )
{
long msec;
int unused;
CURLMsg * msg;
CURLMcode mcode;
if( web->close_mode == TR_WEB_CLOSE_NOW )
break;
if( ( web->close_mode == TR_WEB_CLOSE_WHEN_IDLE ) && ( web->tasks == NULL ) )
break;
/* add tasks from the queue */
tr_lockLock( web->taskLock );
while( web->tasks != NULL )
{
/* pop the task */
task = web->tasks;
web->tasks = task->next;
task->next = NULL;
dbgmsg( "adding task to curl: [%s]", task->url );
curl_multi_add_handle( multi, createEasy( session, web, task ));
/*fprintf( stderr, "adding a task.. taskCount is now %d\n", taskCount );*/
++taskCount;
}
tr_lockUnlock( web->taskLock );
/* maybe wait a little while before calling curl_multi_perform() */
msec = 0;
curl_multi_timeout( multi, &msec );
if( msec < 0 )
msec = THREADFUNC_MAX_SLEEP_MSEC;
if( session->isClosed )
msec = 100; /* on shutdown, call perform() more frequently */
if( msec > 0 )
{
int usec;
int max_fd;
struct timeval t;
fd_set r_fd_set, w_fd_set, c_fd_set;
max_fd = 0;
FD_ZERO( &r_fd_set );
FD_ZERO( &w_fd_set );
FD_ZERO( &c_fd_set );
curl_multi_fdset( multi, &r_fd_set, &w_fd_set, &c_fd_set, &max_fd );
if( msec > THREADFUNC_MAX_SLEEP_MSEC )
msec = THREADFUNC_MAX_SLEEP_MSEC;
usec = msec * 1000;
t.tv_sec = usec / 1000000;
t.tv_usec = usec % 1000000;
tr_select( max_fd+1, &r_fd_set, &w_fd_set, &c_fd_set, &t );
}
/* call curl_multi_perform() */
do {
mcode = curl_multi_perform( multi, &unused );
} while( mcode == CURLM_CALL_MULTI_PERFORM );
/* pump completed tasks from the multi */
while(( msg = curl_multi_info_read( multi, &unused )))
{
if(( msg->msg == CURLMSG_DONE ) && ( msg->easy_handle != NULL ))
{
double total_time;
struct tr_web_task * task;
long req_bytes_sent;
CURL * e = msg->easy_handle;
curl_easy_getinfo( e, CURLINFO_PRIVATE, (void*)&task );
curl_easy_getinfo( e, CURLINFO_RESPONSE_CODE, &task->code );
curl_easy_getinfo( e, CURLINFO_REQUEST_SIZE, &req_bytes_sent );
curl_easy_getinfo( e, CURLINFO_TOTAL_TIME, &total_time );
task->did_connect = task->code>0 || req_bytes_sent>0;
task->did_timeout = !task->code && ( total_time >= task->timeout_secs );
curl_multi_remove_handle( multi, e );
curl_easy_cleanup( e );
/*fprintf( stderr, "removing a completed task.. taskCount is now %d (response code: %d, response len: %d)\n", taskCount, (int)task->code, (int)evbuffer_get_length(task->response) );*/
tr_runInEventThread( task->session, task_finish_func, task );
--taskCount;
}
}
}
/* Discard any remaining tasks.
* This is rare, but can happen on shutdown with unresponsive trackers. */
while( web->tasks != NULL ) {
task = web->tasks;
web->tasks = task->next;
dbgmsg( "Discarding task \"%s\"", task->url );
task_free( task );
}
/* cleanup */
curl_multi_cleanup( multi );
tr_lockFree( web->taskLock );
tr_free( web->cookie_filename );
tr_free( web );
session->web = NULL;
}
void tr_msg_done()
{
tr_lockFree(msglock);
msglock = NULL;
}
static void
tr_webThreadFunc (void * vsession)
{
char * str;
CURLM * multi;
struct tr_web * web;
int taskCount = 0;
struct tr_web_task * task;
tr_session * session = vsession;
/* try to enable ssl for https support; but if that fails,
* try a plain vanilla init */
if (curl_global_init (CURL_GLOBAL_SSL))
curl_global_init (0);
web = tr_new0 (struct tr_web, 1);
web->close_mode = ~0;
web->taskLock = tr_lockNew ();
web->tasks = NULL;
web->curl_verbose = getenv ("TR_CURL_VERBOSE") != NULL;
web->curl_ssl_verify = getenv ("TR_CURL_SSL_VERIFY") != NULL;
web->curl_ca_bundle = getenv ("CURL_CA_BUNDLE");
if (web->curl_ssl_verify)
{
tr_logAddNamedInfo ("web", "will verify tracker certs using envvar CURL_CA_BUNDLE: %s",
web->curl_ca_bundle == NULL ? "none" : web->curl_ca_bundle);
tr_logAddNamedInfo ("web", "NB: this only works if you built against libcurl with openssl or gnutls, NOT nss");
tr_logAddNamedInfo ("web", "NB: invalid certs will show up as 'Could not connect to tracker' like many other errors");
}
str = tr_buildPath (session->configDir, "cookies.txt", NULL);
if (tr_fileExists (str, NULL))
web->cookie_filename = tr_strdup (str);
tr_free (str);
multi = curl_multi_init ();
session->web = web;
for (;;)
{
long msec;
int unused;
CURLMsg * msg;
CURLMcode mcode;
if (web->close_mode == TR_WEB_CLOSE_NOW)
break;
if ((web->close_mode == TR_WEB_CLOSE_WHEN_IDLE) && (web->tasks == NULL))
break;
/* add tasks from the queue */
tr_lockLock (web->taskLock);
while (web->tasks != NULL)
{
/* pop the task */
task = web->tasks;
web->tasks = task->next;
task->next = NULL;
dbgmsg ("adding task to curl: [%s]", task->url);
curl_multi_add_handle (multi, createEasy (session, web, task));
/*fprintf (stderr, "adding a task.. taskCount is now %d\n", taskCount);*/
++taskCount;
}
tr_lockUnlock (web->taskLock);
/* unpause any paused curl handles */
if (paused_easy_handles != NULL)
{
CURL * handle;
tr_list * tmp;
/* swap paused_easy_handles to prevent oscillation
between writeFunc this while loop */
tmp = paused_easy_handles;
paused_easy_handles = NULL;
while ((handle = tr_list_pop_front (&tmp)))
curl_easy_pause (handle, CURLPAUSE_CONT);
}
/* maybe wait a little while before calling curl_multi_perform () */
msec = 0;
curl_multi_timeout (multi, &msec);
if (msec < 0)
msec = THREADFUNC_MAX_SLEEP_MSEC;
if (session->isClosed)
msec = 100; /* on shutdown, call perform () more frequently */
if (msec > 0)
{
int usec;
int max_fd;
struct timeval t;
fd_set r_fd_set, w_fd_set, c_fd_set;
max_fd = 0;
FD_ZERO (&r_fd_set);
FD_ZERO (&w_fd_set);
FD_ZERO (&c_fd_set);
curl_multi_fdset (multi, &r_fd_set, &w_fd_set, &c_fd_set, &max_fd);
if (msec > THREADFUNC_MAX_SLEEP_MSEC)
msec = THREADFUNC_MAX_SLEEP_MSEC;
usec = msec * 1000;
t.tv_sec = usec / 1000000;
t.tv_usec = usec % 1000000;
tr_select (max_fd+1, &r_fd_set, &w_fd_set, &c_fd_set, &t);
}
/* call curl_multi_perform () */
do
mcode = curl_multi_perform (multi, &unused);
while (mcode == CURLM_CALL_MULTI_PERFORM);
/* pump completed tasks from the multi */
while ((msg = curl_multi_info_read (multi, &unused)))
{
if ((msg->msg == CURLMSG_DONE) && (msg->easy_handle != NULL))
{
double total_time;
struct tr_web_task * task;
long req_bytes_sent;
CURL * e = msg->easy_handle;
curl_easy_getinfo (e, CURLINFO_PRIVATE, (void*)&task);
assert (e == task->curl_easy);
curl_easy_getinfo (e, CURLINFO_RESPONSE_CODE, &task->code);
curl_easy_getinfo (e, CURLINFO_REQUEST_SIZE, &req_bytes_sent);
curl_easy_getinfo (e, CURLINFO_TOTAL_TIME, &total_time);
task->did_connect = task->code>0 || req_bytes_sent>0;
task->did_timeout = !task->code && (total_time >= task->timeout_secs);
curl_multi_remove_handle (multi, e);
tr_list_remove_data (&paused_easy_handles, e);
curl_easy_cleanup (e);
tr_runInEventThread (task->session, task_finish_func, task);
--taskCount;
}
}
}
/* Discard any remaining tasks.
* This is rare, but can happen on shutdown with unresponsive trackers. */
while (web->tasks != NULL)
{
task = web->tasks;
web->tasks = task->next;
dbgmsg ("Discarding task \"%s\"", task->url);
task_free (task);
}
/* cleanup */
tr_list_free (&paused_easy_handles, NULL);
curl_multi_cleanup (multi);
tr_lockFree (web->taskLock);
tr_free (web->cookie_filename);
tr_free (web);
session->web = NULL;
}
