static void
ctx_failed (ClientCtx *ctx,
GError *error)
{
g_simple_async_result_take_error (ctx->result, error);
ctx_complete (ctx);
}
static void
check_for_packages_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
ClientCtx *ctx = g_task_get_task_data (G_TASK (result));
GError *error = NULL;
G_GNUC_UNUSED gboolean success = g_task_propagate_boolean (G_TASK (result), &error);
if (error != NULL) {
ctx_failed (ctx, error);
return;
}
ctx_complete (ctx);
}
static void
install_package_names_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
ClientCtx *ctx = user_data;
GError *error = NULL;
GVariant *res;
res = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), result, &error);
if (res == NULL)
{
ctx_failed (ctx, error);
return;
}
ctx_complete (ctx);
g_variant_unref (res);
}
void CTorrent::run()
{
m_bRunning = true;
m_bStopping = false;
try
{
if( !check() ) {
m_nState = STATE_STOPPED;
m_bStopping = m_bRunning = false;
notify("Checking canceled");
return;
}
btContext* ctx = &m_Context;
int dl = 0;
m_pListener->notify("Starting server..");
ctx_startserver(ctx);
m_pListener->notify("Registering...");
ctx_register(ctx, dl);
m_nState = STATE_RUNNING;
m_pListener->notify("Download started");
int ttv;
int tv_slow = 1; /*ms*/
int tv_fast = 0; /*ms*/
btPeer *peer;
int cs;
struct sockaddr csin;
int err;
time_t choke_timer;
time_t report_timer;
time_t now;
int i;
time( &now );
choke_timer = report_timer = now;
while( !m_bStopping )
{
int readerr;
int writeerr;
int execerr;
int pollerr;
socklen_t sa_len;
/*
* Select a socket or time out
*/
if (ctx->xsock) {
ttv = tv_fast;
} else {
ttv = tv_slow;
}
err = poll( ctx->status, ctx->nstatus, ttv);
if (err < 0) {
bts_perror(errno, "poll");
m_nState = STATE_ERROR;
break;
}
time(&now);
for (cs=0; cs < SOCKID_MAX; cs++) {
/* loop through executable sockets */
if (ctx->x_set[ cs]) {
btPeer *p = ctx->sockpeer[cs];
execerr = clientRun( cs, EXECUTE);
if (execerr == 0) {
if ( ctx->x_set[ cs]) {
ctx->x_set[ cs] = 0;
ctx->xsock--;
}
}
if ( kStream_oqlen( &p->ios)) {
/* data is waiting on the output buffer */
ctx_setevents( ctx, cs, POLLOUT);
}
if (execerr < 0) {
clientError("execute", cs);
}
}
}
for (i=0; i<ctx->nstatus; i++) {
/* for each poll event */
cs = ctx->status[i].fd;
readerr=0;
writeerr=0;
execerr=0;
pollerr=0;
if (CTX_STATUS_REVENTS( ctx, i) & POLLIN)
{
bt_assert( ctx->status[i].events & POLLIN);
/* readable */
if (cs == ctx->ss) {
/* service socket */
sa_len = sizeof(csin);
cs = accept( ctx->ss, &csin, &sa_len);
if (cs < 0) {
bts_perror( errno, "accept");
} else {
peer_answer( ctx, cs);
}
} else if (cs == ctx->udpsock) {
int err = udp_ready( ctx);
if (err) {
printf("Error %d processing UDP packet.\n", err);
}
} else {
btPeer *p = ctx->sockpeer[ cs];
readerr = clientRun( cs, READABLE);
if (readerr == 1) {
/* more to read */
if (!ctx->x_set[cs]) {
ctx->x_set[cs] = 1;
ctx->xsock++;
}
}
if ( kStream_oqlen( &p->ios)) {
/* data is waiting on the output buffer */
ctx_setevents( ctx, cs, POLLOUT);
}
}
} /* if */
if (CTX_STATUS_REVENTS( ctx, i) & POLLOUT) {
writeerr = clientWrite( cs );
if (writeerr == 0) {
/* output drained */
ctx_clrevents( ctx, cs, POLLOUT);
if (!ctx->x_set[ cs]) {
/* output buffer is empty, check for more work */
ctx->x_set[ cs] = 1;
ctx->xsock++;
}
}
} /* if */
if (CTX_STATUS_REVENTS( ctx, i) & (POLLERR | POLLHUP | POLLNVAL))
{
int events = CTX_STATUS_REVENTS( ctx, i);
if (events & POLLHUP) {
ctx->sockpeer[cs]->ios.error = BTERR_POLLHUP;
} else if (events & POLLERR) {
ctx->sockpeer[cs]->ios.error = BTERR_POLLERR;
} else if (events & POLLNVAL) {
ctx->sockpeer[cs]->ios.error = BTERR_POLLNVAL;
}
pollerr = -1;
}
if (readerr < 0 || writeerr < 0 || execerr < 0 || pollerr < 0)
{
const char *act = NULL;
if (readerr<0) act = "read";
if (writeerr<0) act = "write";
if (execerr<0) act = "execute";
if (pollerr<0) act = "poll";
clientError( act, cs);
}
peer = ctx->sockpeer[cs];
if ( peer && !peer->remote.choked && peer->local.interested && !peer->local.snubbed && now - peer->lastreceived > 120)
{
peer->local.snubbed = 1;
}
if (peer && peer->pex_supported > 0 && peer->pex_timer > 0 && now - peer->pex_timer >= 60)
{
sendPeerExchange(ctx->downloads[peer->download], peer);
}
}
if (ctx->downloads[dl]->reregister_interval != 0 && now - ctx->downloads[dl]->reregister_timer > ctx->downloads[dl]->reregister_interval)
{
notify("Updating...");
ctx->downloads[dl]->reregister_timer = now;
ctx_reregister( ctx, dl);
}
if (now - report_timer > 0)
{
int complt = bs_countBits( &ctx->downloads[dl]->fileset.completed);
if ((complt == ctx->downloads[dl]->fileset.npieces) && !ctx->downloads[dl]->complete)
{
notify("Completing...");
ctx_complete (ctx, dl);
m_nState = STATE_COMPLETE;
break;
}
report_timer=now;
updateStatus();
}
if (now - choke_timer > 30) {
/* recalculate favorite peers */
choke_timer=now;
peer_favorites( ctx, &ctx->downloads[dl]->peerset);
}
}
}
catch(const char* ex)
{
m_pListener->error( ex );
m_nState = STATE_ERROR;
}
notify("Disconnecting...");
int dl = 0;
ctx_writefastresume(m_Context.downloads[dl], (char*) m_szDownloadDir );
ctx_shutdown( &m_Context, dl );
cacheclose();
m_bRunning = false;
if( m_bStopping ) {
notify("Download stopped");
m_bStopping = false;
m_nState = STATE_STOPPED;
}
else
if( m_nState == STATE_COMPLETE ) {
notify("Download complete");
}
else
if( m_nState == STATE_ERROR ) {
notify("Download failed");
}
else
m_nState = STATE_STOPPED;
}