2008-05-12 00:41:55 +00:00
|
|
|
/*
|
2014-01-19 01:09:44 +00:00
|
|
|
* This file Copyright (C) 2008-2014 Mnemosyne LLC
|
2008-05-12 00:41:55 +00:00
|
|
|
*
|
2014-01-21 03:10:30 +00:00
|
|
|
* It may be used under the GNU GPL versions 2 or 3
|
2014-01-19 01:09:44 +00:00
|
|
|
* or any future license endorsed by Mnemosyne LLC.
|
2008-05-12 00:41:55 +00:00
|
|
|
*
|
2008-05-28 17:17:12 +00:00
|
|
|
* $Id$
|
2008-05-12 00:41:55 +00:00
|
|
|
*/
|
|
|
|
|
2008-05-12 13:05:06 +00:00
|
|
|
#include <assert.h>
|
2008-05-18 16:44:30 +00:00
|
|
|
#include <ctype.h> /* isdigit */
|
2010-04-19 16:18:12 +00:00
|
|
|
#include <errno.h>
|
2008-05-18 16:44:30 +00:00
|
|
|
#include <stdlib.h> /* strtol */
|
2008-05-12 13:05:06 +00:00
|
|
|
#include <string.h> /* strcmp */
|
|
|
|
|
2014-07-13 21:50:56 +00:00
|
|
|
#include <zlib.h>
|
2010-10-31 17:16:12 +00:00
|
|
|
|
2010-12-24 08:58:41 +00:00
|
|
|
#include <event2/buffer.h>
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
#include "transmission.h"
|
2009-04-13 19:04:21 +00:00
|
|
|
#include "completion.h"
|
2014-12-04 19:58:34 +00:00
|
|
|
#include "crypto-utils.h"
|
2014-07-28 04:13:38 +00:00
|
|
|
#include "error.h"
|
2010-10-31 17:16:12 +00:00
|
|
|
#include "fdlimit.h"
|
2014-07-08 00:08:43 +00:00
|
|
|
#include "file.h"
|
2013-01-25 23:34:20 +00:00
|
|
|
#include "log.h"
|
2013-07-08 17:07:31 +00:00
|
|
|
#include "platform-quota.h" /* tr_device_info_get_free_space() */
|
2009-04-13 19:04:21 +00:00
|
|
|
#include "rpcimpl.h"
|
2008-05-18 16:44:30 +00:00
|
|
|
#include "session.h"
|
2008-05-12 00:41:55 +00:00
|
|
|
#include "torrent.h"
|
|
|
|
#include "utils.h"
|
2012-12-14 04:34:42 +00:00
|
|
|
#include "variant.h"
|
2009-04-13 19:04:21 +00:00
|
|
|
#include "version.h"
|
2009-01-18 15:24:26 +00:00
|
|
|
#include "web.h"
|
2008-05-12 00:41:55 +00:00
|
|
|
|
2013-01-13 20:39:56 +00:00
|
|
|
#define RPC_VERSION 15
|
2010-04-02 17:57:25 +00:00
|
|
|
#define RPC_VERSION_MIN 1
|
|
|
|
|
2009-04-04 05:29:08 +00:00
|
|
|
#define RECENTLY_ACTIVE_SECONDS 60
|
|
|
|
|
2012-12-05 17:29:46 +00:00
|
|
|
#define TR_N_ELEMENTS(ary)(sizeof (ary) / sizeof (*ary))
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2009-01-20 02:03:09 +00:00
|
|
|
#if 0
|
|
|
|
#define dbgmsg(fmt, ...) \
|
|
|
|
do { \
|
2012-12-05 17:29:46 +00:00
|
|
|
fprintf (stderr, "%s:%d"#fmt, __FILE__, __LINE__, __VA_ARGS__); \
|
|
|
|
fprintf (stderr, "\n"); \
|
|
|
|
} while (0)
|
2009-01-20 02:03:09 +00:00
|
|
|
#else
|
2012-12-05 17:29:46 +00:00
|
|
|
#define dbgmsg(...) \
|
2013-01-25 23:34:20 +00:00
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
if (tr_logGetDeepEnabled ()) \
|
|
|
|
tr_logAddDeep (__FILE__, __LINE__, "RPC", __VA_ARGS__); \
|
|
|
|
} \
|
|
|
|
while (0)
|
2009-01-20 02:03:09 +00:00
|
|
|
#endif
|
2009-01-18 15:24:26 +00:00
|
|
|
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2008-08-14 02:12:29 +00:00
|
|
|
static tr_rpc_callback_status
|
2012-12-05 17:29:46 +00:00
|
|
|
notify (tr_session * session,
|
2008-09-23 19:11:04 +00:00
|
|
|
int type,
|
2012-12-05 17:29:46 +00:00
|
|
|
tr_torrent * tor)
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2008-08-14 02:12:29 +00:00
|
|
|
tr_rpc_callback_status status = 0;
|
|
|
|
|
2012-12-05 17:29:46 +00:00
|
|
|
if (session->rpc_func)
|
|
|
|
status = session->rpc_func (session, type, tor,
|
|
|
|
session->rpc_func_user_data);
|
2008-08-14 02:12:29 +00:00
|
|
|
|
|
|
|
return status;
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2009-01-18 15:24:26 +00:00
|
|
|
/* For functions that can't be immediately executed, like torrentAdd,
|
|
|
|
* this is the callback data used to pass a response to the caller
|
|
|
|
* when the task is complete */
|
|
|
|
struct tr_rpc_idle_data
|
|
|
|
{
|
2015-07-13 00:32:48 +00:00
|
|
|
tr_session * session;
|
|
|
|
tr_variant * response;
|
|
|
|
tr_variant * args_out;
|
|
|
|
tr_rpc_response_func callback;
|
|
|
|
void * callback_user_data;
|
2009-01-18 15:24:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
2012-12-05 17:29:46 +00:00
|
|
|
tr_idle_function_done (struct tr_rpc_idle_data * data, const char * result)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2015-07-13 00:32:48 +00:00
|
|
|
if (result == NULL)
|
|
|
|
result = "success";
|
|
|
|
tr_variantDictAddStr (data->response, TR_KEY_result, result);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2015-07-13 00:32:48 +00:00
|
|
|
(*data->callback)(data->session, data->response, data->callback_user_data);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2015-07-13 00:32:48 +00:00
|
|
|
tr_variantFree (data->response);
|
|
|
|
tr_free (data->response);
|
|
|
|
tr_free (data);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static tr_torrent **
|
2012-12-05 17:29:46 +00:00
|
|
|
getTorrents (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args,
|
2012-12-05 17:29:46 +00:00
|
|
|
int * setmeCount)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int torrentCount = 0;
|
|
|
|
int64_t id;
|
|
|
|
tr_torrent ** torrents = NULL;
|
|
|
|
tr_variant * ids;
|
|
|
|
const char * str;
|
2008-05-12 00:41:55 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantDictFindList (args, TR_KEY_ids, &ids))
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
const int n = tr_variantListSize (ids);
|
2008-05-12 00:41:55 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
torrents = tr_new0 (tr_torrent *, n);
|
2008-05-12 00:41:55 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<n; ++i)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * str;
|
|
|
|
tr_torrent * tor;
|
|
|
|
tr_variant * node = tr_variantListChild (ids, i);
|
|
|
|
|
|
|
|
if (tr_variantGetInt (node, &id))
|
|
|
|
tor = tr_torrentFindFromId (session, id);
|
|
|
|
else if (tr_variantGetStr (node, &str, NULL))
|
|
|
|
tor = tr_torrentFindFromHashString (session, str);
|
|
|
|
else
|
|
|
|
tor = NULL;
|
|
|
|
|
|
|
|
if (tor != NULL)
|
|
|
|
torrents[torrentCount++] = tor;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else if (tr_variantDictFindInt (args, TR_KEY_ids, &id)
|
|
|
|
|| tr_variantDictFindInt (args, TR_KEY_id, &id))
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor;
|
|
|
|
torrents = tr_new0 (tr_torrent *, 1);
|
|
|
|
if ((tor = tr_torrentFindFromId (session, id)))
|
|
|
|
torrents[torrentCount++] = tor;
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else if (tr_variantDictFindStr (args, TR_KEY_ids, &str, NULL))
|
2009-03-23 00:16:37 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
if (!strcmp (str, "recently-active"))
|
2009-03-23 00:16:37 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor = NULL;
|
|
|
|
const time_t now = tr_time ();
|
|
|
|
const time_t window = RECENTLY_ACTIVE_SECONDS;
|
|
|
|
const int n = tr_sessionCountTorrents (session);
|
|
|
|
torrents = tr_new0 (tr_torrent *, n);
|
|
|
|
while ((tor = tr_torrentNext (session, tor)))
|
|
|
|
if (tor->anyDate >= now - window)
|
|
|
|
torrents[torrentCount++] = tor;
|
2009-03-23 00:16:37 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else
|
2009-05-08 17:24:16 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor;
|
|
|
|
torrents = tr_new0 (tr_torrent *, 1);
|
|
|
|
if ((tor = tr_torrentFindFromHashString (session, str)))
|
|
|
|
torrents[torrentCount++] = tor;
|
2009-05-08 17:24:16 +00:00
|
|
|
}
|
2009-03-23 00:16:37 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else /* all of them */
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-07-20 15:37:13 +00:00
|
|
|
torrents = tr_sessionGetTorrents (session, &torrentCount);
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
*setmeCount = torrentCount;
|
|
|
|
return torrents;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2011-08-01 22:24:24 +00:00
|
|
|
static void
|
2012-12-05 17:29:46 +00:00
|
|
|
notifyBatchQueueChange (tr_session * session, tr_torrent ** torrents, int n)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
for (i=0; i<n; ++i)
|
|
|
|
notify (session, TR_RPC_TORRENT_CHANGED, torrents[i]);
|
|
|
|
notify (session, TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED, NULL);
|
2011-08-01 22:24:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
queueMoveTop (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int n;
|
|
|
|
tr_torrent ** torrents = getTorrents (session, args_in, &n);
|
|
|
|
tr_torrentsQueueMoveTop (torrents, n);
|
|
|
|
notifyBatchQueueChange (session, torrents, n);
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2011-08-01 22:24:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
queueMoveUp (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int n;
|
|
|
|
tr_torrent ** torrents = getTorrents (session, args_in, &n);
|
|
|
|
tr_torrentsQueueMoveUp (torrents, n);
|
|
|
|
notifyBatchQueueChange (session, torrents, n);
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2011-08-01 22:24:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
queueMoveDown (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int n;
|
|
|
|
tr_torrent ** torrents = getTorrents (session, args_in, &n);
|
|
|
|
tr_torrentsQueueMoveDown (torrents, n);
|
|
|
|
notifyBatchQueueChange (session, torrents, n);
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2011-08-01 22:24:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
queueMoveBottom (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int n;
|
|
|
|
tr_torrent ** torrents = getTorrents (session, args_in, &n);
|
|
|
|
tr_torrentsQueueMoveBottom (torrents, n);
|
|
|
|
notifyBatchQueueChange (session, torrents, n);
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2011-08-01 22:24:24 +00:00
|
|
|
}
|
|
|
|
|
2015-01-02 11:15:31 +00:00
|
|
|
static int
|
|
|
|
compareTorrentByQueuePosition (const void * va, const void * vb)
|
|
|
|
{
|
|
|
|
const tr_torrent * a = * (const tr_torrent **) va;
|
|
|
|
const tr_torrent * b = * (const tr_torrent **) vb;
|
2013-10-20 17:24:57 +00:00
|
|
|
|
2015-01-02 11:15:31 +00:00
|
|
|
return a->queuePosition - b->queuePosition;
|
|
|
|
}
|
2013-10-20 17:24:57 +00:00
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentStart (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents;
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data == NULL);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
2015-01-02 11:15:31 +00:00
|
|
|
qsort (torrents, torrentCount, sizeof (tr_torrent *), compareTorrentByQueuePosition);
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<torrentCount; ++i)
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor = torrents[i];
|
|
|
|
if (!tor->isRunning)
|
2010-02-21 23:03:29 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrentStart (tor);
|
|
|
|
notify (session, TR_RPC_TORRENT_STARTED, tor);
|
2010-02-21 23:03:29 +00:00
|
|
|
}
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2011-08-01 22:24:24 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentStartNow (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents;
|
2011-08-01 22:24:24 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data == NULL);
|
2011-08-01 22:24:24 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
2015-01-02 11:15:31 +00:00
|
|
|
qsort (torrents, torrentCount, sizeof (tr_torrent *), compareTorrentByQueuePosition);
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<torrentCount; ++i)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor = torrents[i];
|
|
|
|
|
|
|
|
if (!tor->isRunning)
|
2011-08-01 22:24:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrentStartNow (tor);
|
|
|
|
notify (session, TR_RPC_TORRENT_STARTED, tor);
|
2011-08-01 22:24:24 +00:00
|
|
|
}
|
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2011-08-01 22:24:24 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentStop (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents;
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data == NULL);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
|
|
|
for (i=0; i<torrentCount; ++i)
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor = torrents[i];
|
2010-06-25 06:57:34 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tor->isRunning || tr_torrentIsQueued (tor))
|
2010-02-21 23:03:29 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tor->isStopping = true;
|
|
|
|
notify (session, TR_RPC_TORRENT_STOPPED, tor);
|
2010-02-21 23:03:29 +00:00
|
|
|
}
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2008-05-20 23:58:59 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentRemove (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-20 23:58:59 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_rpc_callback_type type;
|
2015-05-09 11:56:35 +00:00
|
|
|
bool deleteFlag;
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent ** torrents;
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data == NULL);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2015-05-09 11:56:35 +00:00
|
|
|
if (!tr_variantDictFindBool (args_in, TR_KEY_delete_local_data, &deleteFlag))
|
|
|
|
deleteFlag = false;
|
2013-05-23 00:11:09 +00:00
|
|
|
type = deleteFlag ? TR_RPC_TORRENT_TRASHING
|
|
|
|
: TR_RPC_TORRENT_REMOVING;
|
2011-02-06 17:30:46 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
|
|
|
for (i=0; i<torrentCount; ++i)
|
2008-05-20 23:58:59 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor = torrents[i];
|
|
|
|
const tr_rpc_callback_status status = notify (session, type, tor);
|
|
|
|
|
|
|
|
if (!(status & TR_RPC_NOREMOVE))
|
|
|
|
tr_torrentRemove (tor, deleteFlag, NULL);
|
2008-05-20 23:58:59 +00:00
|
|
|
}
|
2008-12-14 11:21:11 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2008-05-20 23:58:59 +00:00
|
|
|
}
|
|
|
|
|
2009-03-26 18:06:54 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentReannounce (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2009-03-26 18:06:54 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents;
|
2009-03-26 18:06:54 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data == NULL);
|
2009-03-26 18:06:54 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
|
|
|
for (i=0; i<torrentCount; ++i)
|
2009-03-26 18:06:54 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor = torrents[i];
|
|
|
|
|
|
|
|
if (tr_torrentCanManualUpdate (tor))
|
2009-03-26 18:06:54 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrentManualUpdate (tor);
|
|
|
|
notify (session, TR_RPC_TORRENT_CHANGED, tor);
|
2009-03-26 18:06:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2009-03-26 18:06:54 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentVerify (tr_session * session,
|
2013-01-19 08:43:26 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents;
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data == NULL);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
|
|
|
for (i=0; i<torrentCount; ++i)
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrent * tor = torrents[i];
|
|
|
|
tr_torrentVerify (tor, NULL, NULL);
|
|
|
|
notify (session, TR_RPC_TORRENT_CHANGED, tor);
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
2008-12-14 11:21:11 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (torrents);
|
|
|
|
return NULL;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2009-03-31 22:13:43 +00:00
|
|
|
static void
|
2012-12-14 04:34:42 +00:00
|
|
|
addFileStats (const tr_torrent * tor, tr_variant * list)
|
2009-03-31 22:13:43 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_file_index_t i;
|
|
|
|
tr_file_index_t n;
|
|
|
|
const tr_info * info = tr_torrentInfo (tor);
|
|
|
|
tr_file_stat * files = tr_torrentFiles (tor, &n);
|
2009-03-31 22:13:43 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<info->fileCount; ++i)
|
2009-03-31 22:13:43 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const tr_file * file = &info->files[i];
|
|
|
|
tr_variant * d = tr_variantListAddDict (list, 3);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_bytesCompleted, files[i].bytesCompleted);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_priority, file->priority);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_wanted, !file->dnd);
|
2009-03-31 22:13:43 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrentFilesFree (files, n);
|
2009-03-31 22:13:43 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static void
|
2013-01-20 01:31:58 +00:00
|
|
|
addFiles (const tr_torrent * tor, tr_variant * list)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_file_index_t i;
|
|
|
|
tr_file_index_t n;
|
|
|
|
const tr_info * info = tr_torrentInfo (tor);
|
|
|
|
tr_file_stat * files = tr_torrentFiles (tor, &n);
|
2008-07-21 18:42:51 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<info->fileCount; ++i)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const tr_file * file = &info->files[i];
|
|
|
|
tr_variant * d = tr_variantListAddDict (list, 3);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_bytesCompleted, files[i].bytesCompleted);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_length, file->length);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_name, file->name);
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
2008-07-21 18:42:51 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrentFilesFree (files, n);
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2008-06-16 03:47:50 +00:00
|
|
|
static void
|
2012-12-30 22:06:45 +00:00
|
|
|
addWebseeds (const tr_info * info,
|
|
|
|
tr_variant * webseeds)
|
2008-06-16 03:47:50 +00:00
|
|
|
{
|
2012-12-30 22:06:45 +00:00
|
|
|
unsigned int i;
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2012-12-30 22:06:45 +00:00
|
|
|
for (i=0; i< info->webseedCount; ++i)
|
|
|
|
tr_variantListAddStr (webseeds, info->webseeds[i]);
|
2008-06-16 03:47:50 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static void
|
2012-12-30 22:06:45 +00:00
|
|
|
addTrackers (const tr_info * info,
|
|
|
|
tr_variant * trackers)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2012-12-30 22:06:45 +00:00
|
|
|
unsigned int i;
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2012-12-30 22:06:45 +00:00
|
|
|
for (i=0; i<info->trackerCount; ++i)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2012-12-30 22:06:45 +00:00
|
|
|
const tr_tracker_info * t = &info->trackers[i];
|
|
|
|
tr_variant * d = tr_variantListAddDict (trackers, 4);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_announce, t->announce);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_id, t->id);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_scrape, t->scrape);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_tier, t->tier);
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-25 21:05:59 +00:00
|
|
|
static void
|
2012-12-14 04:34:42 +00:00
|
|
|
addTrackerStats (const tr_tracker_stat * st, int n, tr_variant * list)
|
2009-09-25 21:05:59 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
2009-09-25 21:05:59 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<n; ++i)
|
2009-09-25 21:05:59 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const tr_tracker_stat * s = &st[i];
|
|
|
|
tr_variant * d = tr_variantListAddDict (list, 26);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_announce, s->announce);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_announceState, s->announceState);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_downloadCount, s->downloadCount);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_hasAnnounced, s->hasAnnounced);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_hasScraped, s->hasScraped);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_host, s->host);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_id, s->id);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_isBackup, s->isBackup);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_lastAnnouncePeerCount, s->lastAnnouncePeerCount);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_lastAnnounceResult, s->lastAnnounceResult);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_lastAnnounceStartTime, s->lastAnnounceStartTime);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_lastAnnounceSucceeded, s->lastAnnounceSucceeded);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_lastAnnounceTime, s->lastAnnounceTime);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_lastAnnounceTimedOut, s->lastAnnounceTimedOut);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_lastScrapeResult, s->lastScrapeResult);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_lastScrapeStartTime, s->lastScrapeStartTime);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_lastScrapeSucceeded, s->lastScrapeSucceeded);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_lastScrapeTime, s->lastScrapeTime);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_lastScrapeTimedOut, s->lastScrapeTimedOut);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_leecherCount, s->leecherCount);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_nextAnnounceTime, s->nextAnnounceTime);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_nextScrapeTime, s->nextScrapeTime);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_scrape, s->scrape);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_scrapeState, s->scrapeState);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_seederCount, s->seederCount);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_tier, s->tier);
|
2009-09-25 21:05:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-22 17:59:31 +00:00
|
|
|
static void
|
2012-12-14 04:34:42 +00:00
|
|
|
addPeers (tr_torrent * tor, tr_variant * list)
|
2008-08-22 17:59:31 +00:00
|
|
|
{
|
2012-12-12 20:22:57 +00:00
|
|
|
int i;
|
|
|
|
int peerCount;
|
|
|
|
tr_peer_stat * peers = tr_torrentPeers (tor, &peerCount);
|
2008-08-22 17:59:31 +00:00
|
|
|
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantInitList (list, peerCount);
|
2008-08-22 17:59:31 +00:00
|
|
|
|
2012-12-12 20:22:57 +00:00
|
|
|
for (i=0; i<peerCount; ++i)
|
2008-08-22 17:59:31 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variant * d = tr_variantListAddDict (list, 16);
|
|
|
|
const tr_peer_stat * peer = peers + i;
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_address, peer->addr);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_clientName, peer->client);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_clientIsChoked, peer->clientIsChoked);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_clientIsInterested, peer->clientIsInterested);
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_flagStr, peer->flagStr);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_isDownloadingFrom, peer->isDownloadingFrom);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_isEncrypted, peer->isEncrypted);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_isIncoming, peer->isIncoming);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_isUploadingTo, peer->isUploadingTo);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_isUTP, peer->isUTP);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_peerIsChoked, peer->peerIsChoked);
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_peerIsInterested, peer->peerIsInterested);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_port, peer->port);
|
|
|
|
tr_variantDictAddReal (d, TR_KEY_progress, peer->progress);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_rateToClient, toSpeedBytes (peer->rateToClient_KBps));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_rateToPeer, toSpeedBytes (peer->rateToPeer_KBps));
|
2008-08-22 17:59:31 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_torrentPeersFree (peers, peerCount);
|
2008-08-22 17:59:31 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 13:05:06 +00:00
|
|
|
static void
|
2012-12-12 20:22:57 +00:00
|
|
|
addField (tr_torrent * const tor,
|
2011-05-09 04:13:14 +00:00
|
|
|
const tr_info * const inf,
|
|
|
|
const tr_stat * const st,
|
2012-12-22 20:35:19 +00:00
|
|
|
tr_variant * const d,
|
|
|
|
const tr_quark key)
|
2008-05-12 13:05:06 +00:00
|
|
|
{
|
2012-12-22 20:35:19 +00:00
|
|
|
char * str;
|
2012-12-05 17:29:46 +00:00
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
switch (key)
|
|
|
|
{
|
|
|
|
case TR_KEY_activityDate:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->activityDate);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_addedDate:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->addedDate);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_bandwidthPriority:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetPriority (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_comment:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, inf->comment ? inf->comment : "");
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_corruptEver:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->corruptEver);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_creator:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, inf->creator ? inf->creator : "");
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_dateCreated:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, inf->dateCreated);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_desiredAvailable:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->desiredAvailable);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_doneDate:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->doneDate);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_downloadDir:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, tr_torrentGetDownloadDir (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_downloadedEver:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->downloadedEver);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_downloadLimit:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetSpeedLimit_KBps (tor, TR_DOWN));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_downloadLimited:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddBool (d, key, tr_torrentUsesSpeedLimit (tor, TR_DOWN));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_error:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->error);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_errorString:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, st->errorString);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_eta:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->eta);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_files:
|
2012-12-14 04:34:42 +00:00
|
|
|
addFiles (tor, tr_variantDictAddList (d, key, inf->fileCount));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_fileStats:
|
2012-12-14 04:34:42 +00:00
|
|
|
addFileStats (tor, tr_variantDictAddList (d, key, inf->fileCount));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_hashString:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, tor->info.hashString);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_haveUnchecked:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->haveUnchecked);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_haveValid:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->haveValid);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_honorsSessionLimits:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddBool (d, key, tr_torrentUsesSessionLimits (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_id:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->id);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_isFinished:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddBool (d, key, st->finished);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_isPrivate:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddBool (d, key, tr_torrentIsPrivate (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_isStalled:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddBool (d, key, st->isStalled);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_leftUntilDone:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->leftUntilDone);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_manualAnnounceTime:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->manualAnnounceTime);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_maxConnectedPeers:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetPeerLimit (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_magnetLink:
|
|
|
|
str = tr_torrentGetMagnetLink (tor);
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, str);
|
2012-12-05 17:29:46 +00:00
|
|
|
tr_free (str);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_metadataPercentComplete:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddReal (d, key, st->metadataPercentComplete);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_name:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, tr_torrentName (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_percentDone:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddReal (d, key, st->percentDone);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_peer_limit:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetPeerLimit (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_peers:
|
|
|
|
addPeers (tor, tr_variantDictAdd (d, key));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_peersConnected:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->peersConnected);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_peersFrom:
|
|
|
|
{
|
|
|
|
tr_variant * tmp = tr_variantDictAddDict (d, key, 7);
|
|
|
|
const int * f = st->peersFrom;
|
|
|
|
tr_variantDictAddInt (tmp, TR_KEY_fromCache, f[TR_PEER_FROM_RESUME]);
|
|
|
|
tr_variantDictAddInt (tmp, TR_KEY_fromDht, f[TR_PEER_FROM_DHT]);
|
|
|
|
tr_variantDictAddInt (tmp, TR_KEY_fromIncoming, f[TR_PEER_FROM_INCOMING]);
|
|
|
|
tr_variantDictAddInt (tmp, TR_KEY_fromLpd, f[TR_PEER_FROM_LPD]);
|
|
|
|
tr_variantDictAddInt (tmp, TR_KEY_fromLtep, f[TR_PEER_FROM_LTEP]);
|
|
|
|
tr_variantDictAddInt (tmp, TR_KEY_fromPex, f[TR_PEER_FROM_PEX]);
|
|
|
|
tr_variantDictAddInt (tmp, TR_KEY_fromTracker, f[TR_PEER_FROM_TRACKER]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TR_KEY_peersGettingFromUs:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->peersGettingFromUs);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_peersSendingToUs:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->peersSendingToUs);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_pieces:
|
|
|
|
if (tr_torrentHasMetadata (tor))
|
|
|
|
{
|
2012-09-19 05:11:19 +00:00
|
|
|
size_t byte_count = 0;
|
2013-08-18 13:06:39 +00:00
|
|
|
void * bytes = tr_torrentCreatePieceBitfield (tor, &byte_count);
|
2012-12-05 17:29:46 +00:00
|
|
|
char * str = tr_base64_encode (bytes, byte_count, NULL);
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, str!=NULL ? str : "");
|
2012-12-05 17:29:46 +00:00
|
|
|
tr_free (str);
|
|
|
|
tr_free (bytes);
|
2012-12-22 20:35:19 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, "");
|
2012-12-22 20:35:19 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_pieceCount:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, inf->pieceCount);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_pieceSize:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, inf->pieceSize);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_priorities:
|
|
|
|
{
|
|
|
|
tr_file_index_t i;
|
|
|
|
tr_variant * p = tr_variantDictAddList (d, key, inf->fileCount);
|
|
|
|
for (i=0; i<inf->fileCount; ++i)
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantListAddInt (p, inf->files[i].priority);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TR_KEY_queuePosition:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->queuePosition);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
2013-01-13 20:39:56 +00:00
|
|
|
case TR_KEY_etaIdle:
|
|
|
|
tr_variantDictAddInt (d, key, st->etaIdle);
|
|
|
|
break;
|
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
case TR_KEY_rateDownload:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, toSpeedBytes (st->pieceDownloadSpeed_KBps));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_rateUpload:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, toSpeedBytes (st->pieceUploadSpeed_KBps));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_recheckProgress:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddReal (d, key, st->recheckProgress);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_seedIdleLimit:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetIdleLimit (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_seedIdleMode:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetIdleMode (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_seedRatioLimit:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddReal (d, key, tr_torrentGetRatioLimit (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_seedRatioMode:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetRatioMode (tor));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_sizeWhenDone:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->sizeWhenDone);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_startDate:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->startDate);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_status:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->activity);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_secondsDownloading:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->secondsDownloading);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_secondsSeeding:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->secondsSeeding);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_trackers:
|
2012-12-14 04:34:42 +00:00
|
|
|
addTrackers (inf, tr_variantDictAddList (d, key, inf->trackerCount));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_trackerStats:
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
tr_tracker_stat * s = tr_torrentTrackers (tor, &n);
|
|
|
|
addTrackerStats (s, n, tr_variantDictAddList (d, key, n));
|
|
|
|
tr_torrentTrackersFree (s, n);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TR_KEY_torrentFile:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddStr (d, key, inf->torrent);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_totalSize:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, inf->totalSize);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_uploadedEver:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->uploadedEver);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_uploadLimit:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, tr_torrentGetSpeedLimit_KBps (tor, TR_UP));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_uploadLimited:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddBool (d, key, tr_torrentUsesSpeedLimit (tor, TR_UP));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_uploadRatio:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddReal (d, key, st->ratio);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_wanted:
|
|
|
|
{
|
|
|
|
tr_file_index_t i;
|
|
|
|
tr_variant * w = tr_variantDictAddList (d, key, inf->fileCount);
|
|
|
|
for (i=0; i<inf->fileCount; ++i)
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantListAddInt (w, inf->files[i].dnd ? 0 : 1);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TR_KEY_webseeds:
|
2012-12-14 04:34:42 +00:00
|
|
|
addWebseeds (inf, tr_variantDictAddList (d, key, inf->webseedCount));
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TR_KEY_webseedsSendingToUs:
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variantDictAddInt (d, key, st->webseedsSendingToUs);
|
2012-12-22 20:35:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2008-07-26 14:47:07 +00:00
|
|
|
}
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2008-07-26 14:47:07 +00:00
|
|
|
static void
|
2012-12-14 04:34:42 +00:00
|
|
|
addInfo (tr_torrent * tor, tr_variant * d, tr_variant * fields)
|
2008-07-26 14:47:07 +00:00
|
|
|
{
|
2012-12-22 20:35:19 +00:00
|
|
|
const int n = tr_variantListSize (fields);
|
2008-06-16 03:47:50 +00:00
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
tr_variantInitDict (d, n);
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
if (n > 0)
|
2011-05-09 04:13:14 +00:00
|
|
|
{
|
2012-12-22 20:35:19 +00:00
|
|
|
int i;
|
2013-09-08 17:58:14 +00:00
|
|
|
const tr_info * const inf = tr_torrentInfo (tor);
|
|
|
|
const tr_stat * const st = tr_torrentStat ((tr_torrent*)tor);
|
2011-05-09 04:13:14 +00:00
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
for (i=0; i<n; ++i)
|
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
const char * str;
|
|
|
|
if (tr_variantGetStr (tr_variantListChild (fields, i), &str, &len))
|
|
|
|
addField (tor, inf, st, d, tr_quark_new (str, len));
|
|
|
|
}
|
2011-05-09 04:13:14 +00:00
|
|
|
}
|
2008-06-16 03:47:50 +00:00
|
|
|
}
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentGet (tr_session * session,
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
|
|
|
|
tr_variant * list = tr_variantDictAddList (args_out, TR_KEY_torrents, torrentCount);
|
|
|
|
tr_variant * fields;
|
|
|
|
const char * strVal;
|
|
|
|
const char * errmsg = NULL;
|
|
|
|
|
|
|
|
assert (idle_data == NULL);
|
|
|
|
|
|
|
|
if (tr_variantDictFindStr (args_in, TR_KEY_ids, &strVal, NULL) && !strcmp (strVal, "recently-active"))
|
|
|
|
{
|
|
|
|
int n = 0;
|
|
|
|
tr_variant * d;
|
|
|
|
const time_t now = tr_time ();
|
|
|
|
const int interval = RECENTLY_ACTIVE_SECONDS;
|
|
|
|
tr_variant * removed_out = tr_variantDictAddList (args_out, TR_KEY_removed, 0);
|
|
|
|
while ((d = tr_variantListChild (&session->removedTorrents, n++)))
|
|
|
|
{
|
|
|
|
int64_t intVal;
|
|
|
|
if (tr_variantDictFindInt (d, TR_KEY_date, &intVal) && (intVal >= now - interval))
|
|
|
|
{
|
|
|
|
tr_variantDictFindInt (d, TR_KEY_id, &intVal);
|
|
|
|
tr_variantListAddInt (removed_out, intVal);
|
2009-04-04 05:29:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (!tr_variantDictFindList (args_in, TR_KEY_fields, &fields))
|
|
|
|
errmsg = "no fields specified";
|
|
|
|
else for (i=0; i<torrentCount; ++i)
|
|
|
|
addInfo (torrents[i], tr_variantListAdd (list), fields);
|
2009-09-25 21:05:59 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (torrents);
|
|
|
|
return errmsg;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2008-06-16 03:47:50 +00:00
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2009-03-03 20:06:45 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
setFilePriorities (tr_torrent * tor,
|
2008-09-23 19:11:04 +00:00
|
|
|
int priority,
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variant * list)
|
2008-05-12 13:05:06 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int64_t tmp;
|
|
|
|
int fileCount = 0;
|
|
|
|
const int n = tr_variantListSize (list);
|
|
|
|
const char * errmsg = NULL;
|
|
|
|
tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
|
|
|
|
|
|
|
|
if (n)
|
2008-07-10 20:59:15 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<n; ++i)
|
|
|
|
{
|
|
|
|
if (tr_variantGetInt (tr_variantListChild (list, i), &tmp))
|
|
|
|
{
|
|
|
|
if (0 <= tmp && tmp < tor->info.fileCount)
|
|
|
|
files[fileCount++] = tmp;
|
|
|
|
else
|
|
|
|
errmsg = "file index out of range";
|
2009-03-03 20:06:45 +00:00
|
|
|
}
|
|
|
|
}
|
2008-07-10 20:59:15 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else /* if empty set, apply to all */
|
2008-07-10 20:59:15 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_file_index_t t;
|
|
|
|
for (t=0; t<tor->info.fileCount; ++t)
|
|
|
|
files[fileCount++] = t;
|
2008-07-10 20:59:15 +00:00
|
|
|
}
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (fileCount)
|
|
|
|
tr_torrentSetFilePriorities (tor, files, fileCount, priority);
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (files);
|
|
|
|
return errmsg;
|
2008-05-12 13:05:06 +00:00
|
|
|
}
|
|
|
|
|
2009-03-03 20:06:45 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
setFileDLs (tr_torrent * tor,
|
2008-09-23 19:11:04 +00:00
|
|
|
int do_download,
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variant * list)
|
2008-05-12 13:05:06 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int64_t tmp;
|
|
|
|
int fileCount = 0;
|
|
|
|
const int n = tr_variantListSize (list);
|
|
|
|
const char * errmsg = NULL;
|
|
|
|
tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
|
|
|
|
|
|
|
|
if (n) /* if argument list, process them */
|
2008-07-10 20:59:15 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<n; ++i)
|
|
|
|
{
|
|
|
|
if (tr_variantGetInt (tr_variantListChild (list, i), &tmp))
|
|
|
|
{
|
|
|
|
if (0 <= tmp && tmp < tor->info.fileCount)
|
|
|
|
files[fileCount++] = tmp;
|
|
|
|
else
|
|
|
|
errmsg = "file index out of range";
|
2009-03-03 20:06:45 +00:00
|
|
|
}
|
|
|
|
}
|
2008-07-10 20:59:15 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else /* if empty set, apply to all */
|
2008-07-10 20:59:15 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_file_index_t t;
|
|
|
|
|
|
|
|
for (t=0; t<tor->info.fileCount; ++t)
|
|
|
|
files[fileCount++] = t;
|
2008-07-10 20:59:15 +00:00
|
|
|
}
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (fileCount)
|
|
|
|
tr_torrentSetFileDLs (tor, files, fileCount, do_download);
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (files);
|
|
|
|
return errmsg;
|
2008-05-12 13:05:06 +00:00
|
|
|
}
|
|
|
|
|
2011-03-22 15:19:54 +00:00
|
|
|
static bool
|
2012-12-05 17:29:46 +00:00
|
|
|
findAnnounceUrl (const tr_tracker_info * t, int n, const char * url, int * pos)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
bool found = false;
|
2010-06-30 05:52:24 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<n; ++i)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
if (!strcmp (t[i].announce, url))
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
found = true;
|
|
|
|
|
|
|
|
if (pos != NULL)
|
|
|
|
*pos = i;
|
|
|
|
|
|
|
|
break;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
return found;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
2010-07-27 19:43:32 +00:00
|
|
|
static int
|
2012-12-05 17:29:46 +00:00
|
|
|
copyTrackers (tr_tracker_info * tgt, const tr_tracker_info * src, int n)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int maxTier = -1;
|
2010-11-11 15:31:11 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<n; ++i)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tgt[i].tier = src[i].tier;
|
|
|
|
tgt[i].announce = tr_strdup (src[i].announce);
|
|
|
|
maxTier = MAX (maxTier, src[i].tier);
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
return maxTier;
|
2010-07-27 19:43:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-12-05 17:29:46 +00:00
|
|
|
freeTrackers (tr_tracker_info * trackers, int n)
|
2010-07-27 19:43:32 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
2010-07-27 19:43:32 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<n; ++i)
|
|
|
|
tr_free (trackers[i].announce);
|
2010-07-27 19:43:32 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (trackers);
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-14 04:34:42 +00:00
|
|
|
addTrackerUrls (tr_torrent * tor, tr_variant * urls)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int n;
|
|
|
|
int tier;
|
|
|
|
tr_variant * val;
|
|
|
|
tr_tracker_info * trackers;
|
|
|
|
bool changed = false;
|
|
|
|
const tr_info * inf = tr_torrentInfo (tor);
|
|
|
|
const char * errmsg = NULL;
|
|
|
|
|
|
|
|
/* make a working copy of the existing announce list */
|
|
|
|
n = inf->trackerCount;
|
|
|
|
trackers = tr_new0 (tr_tracker_info, n + tr_variantListSize (urls));
|
|
|
|
tier = copyTrackers (trackers, inf->trackers, n);
|
|
|
|
|
|
|
|
/* and add the new ones */
|
|
|
|
i = 0;
|
|
|
|
while ((val = tr_variantListChild (urls, i++)))
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * announce = NULL;
|
2010-06-30 05:52:24 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if ( tr_variantGetStr (val, &announce, NULL)
|
|
|
|
&& tr_urlIsValidTracker (announce)
|
|
|
|
&& !findAnnounceUrl (trackers, n, announce, NULL))
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
trackers[n].tier = ++tier; /* add a new tier */
|
|
|
|
trackers[n].announce = tr_strdup (announce);
|
|
|
|
++n;
|
|
|
|
changed = true;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (!changed)
|
|
|
|
errmsg = "invalid argument";
|
|
|
|
else if (!tr_torrentSetAnnounceList (tor, trackers, n))
|
|
|
|
errmsg = "error setting announce list";
|
2010-07-27 19:43:32 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
freeTrackers (trackers, n);
|
|
|
|
return errmsg;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-14 04:34:42 +00:00
|
|
|
replaceTrackers (tr_torrent * tor, tr_variant * urls)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
tr_variant * pair[2];
|
|
|
|
tr_tracker_info * trackers;
|
|
|
|
bool changed = false;
|
|
|
|
const tr_info * inf = tr_torrentInfo (tor);
|
|
|
|
const int n = inf->trackerCount;
|
|
|
|
const char * errmsg = NULL;
|
|
|
|
|
|
|
|
/* make a working copy of the existing announce list */
|
|
|
|
trackers = tr_new0 (tr_tracker_info, n);
|
|
|
|
copyTrackers (trackers, inf->trackers, n);
|
|
|
|
|
|
|
|
/* make the substitutions... */
|
|
|
|
i = 0;
|
|
|
|
while (((pair[0] = tr_variantListChild (urls,i))) &&
|
|
|
|
((pair[1] = tr_variantListChild (urls,i+1))))
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
size_t len;
|
|
|
|
int64_t pos;
|
|
|
|
const char * newval;
|
|
|
|
|
|
|
|
if (tr_variantGetInt (pair[0], &pos)
|
|
|
|
&& tr_variantGetStr (pair[1], &newval, &len)
|
|
|
|
&& tr_urlIsValidTracker (newval)
|
|
|
|
&& pos < n
|
|
|
|
&& pos >= 0)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (trackers[pos].announce);
|
|
|
|
trackers[pos].announce = tr_strndup (newval, len);
|
|
|
|
changed = true;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
i += 2;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (!changed)
|
|
|
|
errmsg = "invalid argument";
|
|
|
|
else if (!tr_torrentSetAnnounceList (tor, trackers, n))
|
|
|
|
errmsg = "error setting announce list";
|
2010-07-27 19:43:32 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
freeTrackers (trackers, n);
|
|
|
|
return errmsg;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-14 04:34:42 +00:00
|
|
|
removeTrackers (tr_torrent * tor, tr_variant * ids)
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int n;
|
|
|
|
int t = 0;
|
|
|
|
int dup = -1;
|
|
|
|
int * tids;
|
|
|
|
tr_variant * val;
|
|
|
|
tr_tracker_info * trackers;
|
|
|
|
bool changed = false;
|
|
|
|
const tr_info * inf = tr_torrentInfo (tor);
|
|
|
|
const char * errmsg = NULL;
|
|
|
|
|
|
|
|
/* make a working copy of the existing announce list */
|
|
|
|
n = inf->trackerCount;
|
|
|
|
tids = tr_new0 (int, n);
|
|
|
|
trackers = tr_new0 (tr_tracker_info, n);
|
|
|
|
copyTrackers (trackers, inf->trackers, n);
|
|
|
|
|
|
|
|
/* remove the ones specified in the urls list */
|
|
|
|
i = 0;
|
|
|
|
while ((val = tr_variantListChild (ids, i++)))
|
2010-06-30 05:52:24 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int64_t pos;
|
2010-09-19 20:36:31 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantGetInt (val, &pos) && (0 <= pos) && (pos < n))
|
|
|
|
tids[t++] = pos;
|
2010-09-14 06:23:48 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
/* sort trackerIds and remove from largest to smallest so there is no need to recacluate array indicies */
|
|
|
|
qsort (tids, t, sizeof (int), compareInt);
|
|
|
|
while (t--)
|
2010-09-14 06:23:48 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
/* check for duplicates */
|
|
|
|
if (tids[t] == dup)
|
|
|
|
continue;
|
|
|
|
tr_removeElementFromArray (trackers, tids[t], sizeof (tr_tracker_info), n--);
|
|
|
|
dup = tids[t];
|
|
|
|
changed = true;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (!changed)
|
|
|
|
errmsg = "invalid argument";
|
|
|
|
else if (!tr_torrentSetAnnounceList (tor, trackers, n))
|
|
|
|
errmsg = "error setting announce list";
|
2010-07-27 19:43:32 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
freeTrackers (trackers, n);
|
|
|
|
tr_free (tids);
|
|
|
|
return errmsg;
|
2010-06-30 05:52:24 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentSet (tr_session * session,
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents;
|
|
|
|
const char * errmsg = NULL;
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data == NULL);
|
|
|
|
|
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
for (i=0; i<torrentCount; ++i)
|
2008-05-12 13:05:06 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int64_t tmp;
|
|
|
|
double d;
|
|
|
|
tr_variant * files;
|
|
|
|
tr_variant * trackers;
|
|
|
|
bool boolVal;
|
|
|
|
tr_torrent * tor;
|
|
|
|
|
|
|
|
tor = torrents[i];
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_bandwidthPriority, &tmp))
|
|
|
|
if (tr_isPriority (tmp))
|
|
|
|
tr_torrentSetPriority (tor, tmp);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_files_unwanted, &files))
|
|
|
|
errmsg = setFileDLs (tor, false, files);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_files_wanted, &files))
|
|
|
|
errmsg = setFileDLs (tor, true, files);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit, &tmp))
|
|
|
|
tr_torrentSetPeerLimit (tor, tmp);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_priority_high, &files))
|
|
|
|
errmsg = setFilePriorities (tor, TR_PRI_HIGH, files);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_priority_low, &files))
|
|
|
|
errmsg = setFilePriorities (tor, TR_PRI_LOW, files);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_priority_normal, &files))
|
|
|
|
errmsg = setFilePriorities (tor, TR_PRI_NORMAL, files);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_downloadLimit, &tmp))
|
|
|
|
tr_torrentSetSpeedLimit_KBps (tor, TR_DOWN, tmp);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_downloadLimited, &boolVal))
|
|
|
|
tr_torrentUseSpeedLimit (tor, TR_DOWN, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_honorsSessionLimits, &boolVal))
|
|
|
|
tr_torrentUseSessionLimits (tor, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_uploadLimit, &tmp))
|
|
|
|
tr_torrentSetSpeedLimit_KBps (tor, TR_UP, tmp);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_uploadLimited, &boolVal))
|
|
|
|
tr_torrentUseSpeedLimit (tor, TR_UP, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_seedIdleLimit, &tmp))
|
|
|
|
tr_torrentSetIdleLimit (tor, tmp);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_seedIdleMode, &tmp))
|
|
|
|
tr_torrentSetIdleMode (tor, tmp);
|
|
|
|
|
|
|
|
if (tr_variantDictFindReal (args_in, TR_KEY_seedRatioLimit, &d))
|
|
|
|
tr_torrentSetRatioLimit (tor, d);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_seedRatioMode, &tmp))
|
|
|
|
tr_torrentSetRatioMode (tor, tmp);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_queuePosition, &tmp))
|
|
|
|
tr_torrentSetQueuePosition (tor, tmp);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerAdd, &trackers))
|
|
|
|
errmsg = addTrackerUrls (tor, trackers);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerRemove, &trackers))
|
|
|
|
errmsg = removeTrackers (tor, trackers);
|
|
|
|
|
|
|
|
if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerReplace, &trackers))
|
|
|
|
errmsg = replaceTrackers (tor, trackers);
|
|
|
|
|
|
|
|
notify (session, TR_RPC_TORRENT_CHANGED, tor);
|
2008-05-12 13:05:06 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (torrents);
|
|
|
|
return errmsg;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2009-05-13 15:54:04 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentSetLocation (tr_session * session,
|
2012-12-22 20:35:19 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2009-05-13 15:54:04 +00:00
|
|
|
{
|
2012-12-22 20:35:19 +00:00
|
|
|
const char * errmsg = NULL;
|
|
|
|
const char * location = NULL;
|
2009-05-13 15:54:04 +00:00
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
assert (idle_data == NULL);
|
2009-05-13 15:54:04 +00:00
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
if (!tr_variantDictFindStr (args_in, TR_KEY_location, &location, NULL))
|
2009-05-13 15:54:04 +00:00
|
|
|
{
|
2012-12-22 20:35:19 +00:00
|
|
|
errmsg = "no location";
|
2009-05-13 15:54:04 +00:00
|
|
|
}
|
2012-12-22 20:35:19 +00:00
|
|
|
else
|
2009-05-13 15:54:04 +00:00
|
|
|
{
|
2015-05-09 11:56:35 +00:00
|
|
|
bool move;
|
2012-12-22 20:35:19 +00:00
|
|
|
int i, torrentCount;
|
|
|
|
tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
|
2009-05-13 15:54:04 +00:00
|
|
|
|
2015-05-09 11:56:35 +00:00
|
|
|
if (!tr_variantDictFindBool (args_in, TR_KEY_move, &move))
|
|
|
|
move = false;
|
2009-05-13 15:54:04 +00:00
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
for (i=0; i<torrentCount; ++i)
|
2009-05-13 15:54:04 +00:00
|
|
|
{
|
2012-12-22 20:35:19 +00:00
|
|
|
tr_torrent * tor = torrents[i];
|
|
|
|
tr_torrentSetLocation (tor, location, move, NULL, NULL);
|
|
|
|
notify (session, TR_RPC_TORRENT_MOVED, tor);
|
2009-05-13 15:54:04 +00:00
|
|
|
}
|
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
tr_free (torrents);
|
2009-05-13 15:54:04 +00:00
|
|
|
}
|
|
|
|
|
2012-12-22 20:35:19 +00:00
|
|
|
return errmsg;
|
2009-05-13 15:54:04 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 13:05:06 +00:00
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2013-01-20 01:31:58 +00:00
|
|
|
static void
|
|
|
|
torrentRenamePathDone (tr_torrent * tor,
|
|
|
|
const char * oldpath,
|
|
|
|
const char * newname,
|
|
|
|
int error,
|
|
|
|
void * user_data)
|
|
|
|
{
|
|
|
|
const char * result;
|
|
|
|
struct tr_rpc_idle_data * data = user_data;
|
|
|
|
|
|
|
|
tr_variantDictAddInt (data->args_out, TR_KEY_id, tr_torrentId(tor));
|
|
|
|
tr_variantDictAddStr (data->args_out, TR_KEY_path, oldpath);
|
|
|
|
tr_variantDictAddStr (data->args_out, TR_KEY_name, newname);
|
|
|
|
|
|
|
|
if (error == 0)
|
|
|
|
result = NULL;
|
|
|
|
else
|
|
|
|
result = tr_strerror (error);
|
|
|
|
|
|
|
|
tr_idle_function_done (data, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
|
|
|
torrentRenamePath (tr_session * session,
|
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
|
|
|
struct tr_rpc_idle_data * idle_data)
|
|
|
|
{
|
|
|
|
int torrentCount;
|
|
|
|
tr_torrent ** torrents;
|
|
|
|
const char * oldpath = NULL;
|
|
|
|
const char * newname = NULL;
|
|
|
|
|
|
|
|
tr_variantDictFindStr (args_in, TR_KEY_path, &oldpath, NULL);
|
|
|
|
tr_variantDictFindStr (args_in, TR_KEY_name, &newname, NULL);
|
|
|
|
torrents = getTorrents (session, args_in, &torrentCount);
|
|
|
|
|
|
|
|
if (torrentCount == 1)
|
|
|
|
tr_torrentRenamePath (torrents[0], oldpath, newname, torrentRenamePathDone, idle_data);
|
|
|
|
else
|
|
|
|
tr_idle_function_done (idle_data, "torrent-rename-path requires 1 torrent");
|
|
|
|
|
|
|
|
/* cleanup */
|
|
|
|
tr_free (torrents);
|
|
|
|
return NULL; /* ignored */
|
|
|
|
}
|
|
|
|
|
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2009-04-06 16:36:00 +00:00
|
|
|
static void
|
2012-12-05 17:29:46 +00:00
|
|
|
portTested (tr_session * session UNUSED,
|
2011-03-22 15:19:54 +00:00
|
|
|
bool did_connect UNUSED,
|
|
|
|
bool did_timeout UNUSED,
|
2009-04-06 16:36:00 +00:00
|
|
|
long response_code,
|
|
|
|
const void * response,
|
|
|
|
size_t response_byte_count,
|
2012-12-05 17:29:46 +00:00
|
|
|
void * user_data)
|
2009-04-06 16:36:00 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
char result[1024];
|
|
|
|
struct tr_rpc_idle_data * data = user_data;
|
2009-04-06 16:36:00 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (response_code != 200)
|
2009-04-06 16:36:00 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_snprintf (result, sizeof (result), "portTested: http error %ld: %s",
|
|
|
|
response_code, tr_webGetResponseStr (response_code));
|
2009-04-06 16:36:00 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else /* success */
|
2009-04-06 16:36:00 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const bool isOpen = response_byte_count && * (char*)response == '1';
|
|
|
|
tr_variantDictAddBool (data->args_out, TR_KEY_port_is_open, isOpen);
|
|
|
|
tr_snprintf (result, sizeof (result), "success");
|
2009-04-06 16:36:00 +00:00
|
|
|
}
|
|
|
|
|
2015-07-13 00:32:48 +00:00
|
|
|
tr_idle_function_done (data, result);
|
2009-04-06 16:36:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
portTest (tr_session * session,
|
2013-01-20 01:31:58 +00:00
|
|
|
tr_variant * args_in UNUSED,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data)
|
2009-04-06 16:36:00 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const int port = tr_sessionGetPeerPort (session);
|
|
|
|
char * url = tr_strdup_printf ("http://portcheck.transmissionbt.com/%d", port);
|
|
|
|
tr_webRun (session, url, portTested, idle_data);
|
|
|
|
tr_free (url);
|
|
|
|
return NULL;
|
2009-04-06 16:36:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2009-04-03 23:21:40 +00:00
|
|
|
static void
|
2012-12-05 17:29:46 +00:00
|
|
|
gotNewBlocklist (tr_session * session,
|
2011-03-22 15:19:54 +00:00
|
|
|
bool did_connect UNUSED,
|
|
|
|
bool did_timeout UNUSED,
|
2009-04-03 23:21:40 +00:00
|
|
|
long response_code,
|
|
|
|
const void * response,
|
|
|
|
size_t response_byte_count,
|
2012-12-05 17:29:46 +00:00
|
|
|
void * user_data)
|
2009-04-03 23:21:40 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
char result[1024];
|
|
|
|
struct tr_rpc_idle_data * data = user_data;
|
2009-04-03 23:21:40 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
*result = '\0';
|
2011-06-10 05:34:16 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (response_code != 200)
|
2009-04-03 23:21:40 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_snprintf (result, sizeof (result), "gotNewBlocklist: http error %ld: %s",
|
|
|
|
response_code, tr_webGetResponseStr (response_code));
|
2009-04-03 23:21:40 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else /* successfully fetched the blocklist... */
|
2009-04-03 23:21:40 +00:00
|
|
|
{
|
2014-07-28 04:13:38 +00:00
|
|
|
tr_sys_file_t fd;
|
2013-05-23 00:11:09 +00:00
|
|
|
int err;
|
|
|
|
char * filename;
|
|
|
|
z_stream stream;
|
|
|
|
const char * configDir = tr_sessionGetConfigDir (session);
|
|
|
|
const size_t buflen = 1024 * 128; /* 128 KiB buffer */
|
|
|
|
uint8_t * buf = tr_valloc (buflen);
|
2014-07-28 04:13:38 +00:00
|
|
|
tr_error * error = NULL;
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
/* this is an odd Magic Number required by zlib to enable gz support.
|
|
|
|
See zlib's inflateInit2 () documentation for a full description */
|
|
|
|
const int windowBits = 15 + 32;
|
|
|
|
|
|
|
|
stream.zalloc = (alloc_func) Z_NULL;
|
|
|
|
stream.zfree = (free_func) Z_NULL;
|
|
|
|
stream.opaque = (voidpf) Z_NULL;
|
|
|
|
stream.next_in = (void*) response;
|
|
|
|
stream.avail_in = response_byte_count;
|
|
|
|
inflateInit2 (&stream, windowBits);
|
|
|
|
|
2014-07-28 04:13:38 +00:00
|
|
|
filename = tr_buildPath (configDir, "blocklist.tmp.XXXXXX", NULL);
|
|
|
|
fd = tr_sys_file_open_temp (filename, &error);
|
|
|
|
if (fd == TR_BAD_SYS_FILE)
|
|
|
|
{
|
|
|
|
tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, error->message);
|
|
|
|
tr_error_clear (&error);
|
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
for (;;)
|
2011-06-26 17:05:17 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
stream.next_out = (void*) buf;
|
|
|
|
stream.avail_out = buflen;
|
|
|
|
err = inflate (&stream, Z_NO_FLUSH);
|
|
|
|
|
|
|
|
if (stream.avail_out < buflen)
|
|
|
|
{
|
2014-07-28 04:13:38 +00:00
|
|
|
if (!tr_sys_file_write (fd, buf, buflen - stream.avail_out, NULL, &error))
|
2013-05-23 00:11:09 +00:00
|
|
|
{
|
2014-07-28 04:13:38 +00:00
|
|
|
tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, error->message);
|
|
|
|
tr_error_clear (&error);
|
2013-05-23 00:11:09 +00:00
|
|
|
break;
|
2010-10-31 17:16:12 +00:00
|
|
|
}
|
2010-04-19 16:18:12 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (err != Z_OK)
|
|
|
|
{
|
|
|
|
if ((err != Z_STREAM_END) && (err != Z_DATA_ERROR))
|
|
|
|
tr_snprintf (result, sizeof (result), _("Error uncompressing blocklist: %s (%d)"), zError (err), err);
|
|
|
|
break;
|
2010-04-19 16:18:12 +00:00
|
|
|
}
|
2011-06-26 17:05:17 +00:00
|
|
|
}
|
2009-04-03 23:21:40 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
inflateEnd (&stream);
|
2011-06-10 05:34:16 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (err == Z_DATA_ERROR) /* couldn't inflate it... it's probably already uncompressed */
|
2014-07-28 04:13:38 +00:00
|
|
|
if (!tr_sys_file_write (fd, response, response_byte_count, NULL, &error))
|
|
|
|
{
|
|
|
|
tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, error->message);
|
|
|
|
tr_error_clear (&error);
|
|
|
|
}
|
2010-10-31 17:16:12 +00:00
|
|
|
|
2014-07-28 04:13:38 +00:00
|
|
|
tr_sys_file_close (fd, NULL);
|
2014-01-19 02:03:41 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (*result)
|
|
|
|
{
|
|
|
|
tr_logAddError ("%s", result);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* feed it to the session and give the client a response */
|
|
|
|
const int rule_count = tr_blocklistSetContent (session, filename);
|
|
|
|
tr_variantDictAddInt (data->args_out, TR_KEY_blocklist_size, rule_count);
|
|
|
|
tr_snprintf (result, sizeof (result), "success");
|
2010-04-19 16:18:12 +00:00
|
|
|
}
|
2009-04-03 23:21:40 +00:00
|
|
|
|
2014-07-08 00:08:43 +00:00
|
|
|
tr_sys_path_remove (filename, NULL);
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (filename);
|
|
|
|
tr_free (buf);
|
2009-04-03 23:21:40 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_idle_function_done (data, result);
|
2009-04-03 23:21:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
blocklistUpdate (tr_session * session,
|
2013-04-13 20:25:28 +00:00
|
|
|
tr_variant * args_in UNUSED,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data)
|
2009-04-03 23:21:40 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_webRun (session, session->blocklist_url, gotNewBlocklist, idle_data);
|
|
|
|
return NULL;
|
2009-04-03 23:21:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2009-01-18 15:24:26 +00:00
|
|
|
static void
|
2012-12-05 17:29:46 +00:00
|
|
|
addTorrentImpl (struct tr_rpc_idle_data * data, tr_ctor * ctor)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-22 20:35:38 +00:00
|
|
|
int err;
|
|
|
|
int duplicate_id;
|
|
|
|
const char * result;
|
|
|
|
tr_torrent * tor;
|
|
|
|
tr_quark key;
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-22 20:35:38 +00:00
|
|
|
err = 0;
|
|
|
|
duplicate_id = 0;
|
|
|
|
tor = tr_torrentNew (ctor, &err, &duplicate_id);
|
|
|
|
tr_ctorFree (ctor);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-22 20:35:38 +00:00
|
|
|
if (!err)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-22 20:35:38 +00:00
|
|
|
key = TR_KEY_torrent_added;
|
|
|
|
result = NULL;
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
2013-05-22 20:35:38 +00:00
|
|
|
else if (err == TR_PARSE_DUPLICATE)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-22 20:35:38 +00:00
|
|
|
tor = tr_torrentFindFromId (data->session, duplicate_id);
|
|
|
|
key = TR_KEY_torrent_duplicate;
|
|
|
|
result = "duplicate torrent";
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
2013-08-17 16:31:03 +00:00
|
|
|
else /* err == TR_PARSE_ERR */
|
|
|
|
{
|
|
|
|
key = 0;
|
|
|
|
result = "invalid or corrupt torrent file";
|
|
|
|
}
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-07-10 22:28:40 +00:00
|
|
|
if (tor && key)
|
2013-05-22 20:35:38 +00:00
|
|
|
{
|
|
|
|
tr_variant fields;
|
|
|
|
tr_variantInitList (&fields, 3);
|
|
|
|
tr_variantListAddStr (&fields, "id");
|
|
|
|
tr_variantListAddStr (&fields, "name");
|
|
|
|
tr_variantListAddStr (&fields, "hashString");
|
|
|
|
addInfo (tor, tr_variantDictAdd (data->args_out, key), &fields);
|
2015-04-29 19:42:05 +00:00
|
|
|
if (result == NULL)
|
|
|
|
notify (data->session, TR_RPC_TORRENT_ADDED, tor);
|
2013-05-22 20:35:38 +00:00
|
|
|
tr_variantFree (&fields);
|
2013-07-10 22:28:40 +00:00
|
|
|
result = NULL;
|
2013-05-22 20:35:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tr_idle_function_done (data, result);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
struct add_torrent_idle_data
|
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
struct tr_rpc_idle_data * data;
|
|
|
|
tr_ctor * ctor;
|
2009-01-18 15:24:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
2012-12-05 17:29:46 +00:00
|
|
|
gotMetadataFromURL (tr_session * session UNUSED,
|
2011-03-22 15:19:54 +00:00
|
|
|
bool did_connect UNUSED,
|
|
|
|
bool did_timeout UNUSED,
|
2009-01-18 15:24:26 +00:00
|
|
|
long response_code,
|
|
|
|
const void * response,
|
|
|
|
size_t response_byte_count,
|
2012-12-05 17:29:46 +00:00
|
|
|
void * user_data)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
struct add_torrent_idle_data * data = user_data;
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-09-08 17:32:09 +00:00
|
|
|
dbgmsg ("torrentAdd: HTTP response code was %ld (%s); response length was %"TR_PRIuSIZE" bytes",
|
2013-05-23 00:11:09 +00:00
|
|
|
response_code, tr_webGetResponseStr (response_code), response_byte_count);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (response_code==200 || response_code==221) /* http or ftp success.. */
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_ctorSetMetainfo (data->ctor, response, response_byte_count);
|
|
|
|
addTorrentImpl (data->data, data->ctor);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
char result[1024];
|
|
|
|
tr_snprintf (result, sizeof (result), "gotMetadataFromURL: http error %ld: %s",
|
|
|
|
response_code, tr_webGetResponseStr (response_code));
|
|
|
|
tr_idle_function_done (data->data, result);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (data);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
|
|
|
|
2011-03-22 15:19:54 +00:00
|
|
|
static bool
|
2012-12-05 17:29:46 +00:00
|
|
|
isCurlURL (const char * filename)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
if (filename == NULL)
|
|
|
|
return false;
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
return !strncmp (filename, "ftp://", 6) ||
|
|
|
|
!strncmp (filename, "http://", 7) ||
|
|
|
|
!strncmp (filename, "https://", 8);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
|
|
|
|
2009-04-02 20:43:42 +00:00
|
|
|
static tr_file_index_t*
|
2012-12-14 04:34:42 +00:00
|
|
|
fileListFromList (tr_variant * list, tr_file_index_t * setmeCount)
|
2009-04-02 20:43:42 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
size_t i;
|
|
|
|
const size_t childCount = tr_variantListSize (list);
|
|
|
|
tr_file_index_t n = 0;
|
|
|
|
tr_file_index_t * files = tr_new0 (tr_file_index_t, childCount);
|
|
|
|
|
|
|
|
for (i=0; i<childCount; ++i)
|
|
|
|
{
|
|
|
|
int64_t intVal;
|
|
|
|
if (tr_variantGetInt (tr_variantListChild (list, i), &intVal))
|
|
|
|
files[n++] = (tr_file_index_t)intVal;
|
2009-04-02 20:43:42 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
*setmeCount = n;
|
|
|
|
return files;
|
2009-04-02 20:43:42 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
torrentAdd (tr_session * session,
|
2013-01-20 01:31:58 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * filename = NULL;
|
|
|
|
const char * metainfo_base64 = NULL;
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
assert (idle_data != NULL);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantDictFindStr (args_in, TR_KEY_filename, &filename, NULL);
|
|
|
|
tr_variantDictFindStr (args_in, TR_KEY_metainfo, &metainfo_base64, NULL);
|
|
|
|
if (!filename && !metainfo_base64)
|
|
|
|
{
|
|
|
|
return "no filename or metainfo specified";
|
|
|
|
}
|
|
|
|
else
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int64_t i;
|
|
|
|
bool boolVal;
|
|
|
|
tr_variant * l;
|
|
|
|
const char * str;
|
|
|
|
const char * cookies = NULL;
|
|
|
|
tr_ctor * ctor = tr_ctorNew (session);
|
2008-05-20 17:33:54 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
/* set the optional arguments */
|
2009-04-02 20:43:42 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantDictFindStr (args_in, TR_KEY_cookies, &cookies, NULL);
|
2011-03-15 04:22:47 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantDictFindStr (args_in, TR_KEY_download_dir, &str, NULL))
|
|
|
|
tr_ctorSetDownloadDir (ctor, TR_FORCE, str);
|
2009-04-02 20:43:42 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_paused, &boolVal))
|
|
|
|
tr_ctorSetPaused (ctor, TR_FORCE, boolVal);
|
2009-04-02 20:43:42 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit, &i))
|
|
|
|
tr_ctorSetPeerLimit (ctor, TR_FORCE, i);
|
2008-05-20 17:33:54 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_bandwidthPriority, &i))
|
|
|
|
tr_ctorSetBandwidthPriority (ctor, i);
|
2010-02-02 07:48:03 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantDictFindList (args_in, TR_KEY_files_unwanted, &l))
|
|
|
|
{
|
|
|
|
tr_file_index_t fileCount;
|
|
|
|
tr_file_index_t * files = fileListFromList (l, &fileCount);
|
|
|
|
tr_ctorSetFilesWanted (ctor, files, fileCount, false);
|
|
|
|
tr_free (files);
|
2009-04-02 20:43:42 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
if (tr_variantDictFindList (args_in, TR_KEY_files_wanted, &l))
|
|
|
|
{
|
|
|
|
tr_file_index_t fileCount;
|
|
|
|
tr_file_index_t * files = fileListFromList (l, &fileCount);
|
|
|
|
tr_ctorSetFilesWanted (ctor, files, fileCount, true);
|
|
|
|
tr_free (files);
|
2009-04-02 20:43:42 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (tr_variantDictFindList (args_in, TR_KEY_priority_low, &l))
|
|
|
|
{
|
|
|
|
tr_file_index_t fileCount;
|
|
|
|
tr_file_index_t * files = fileListFromList (l, &fileCount);
|
|
|
|
tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_LOW);
|
|
|
|
tr_free (files);
|
2009-04-02 20:43:42 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
if (tr_variantDictFindList (args_in, TR_KEY_priority_normal, &l))
|
|
|
|
{
|
|
|
|
tr_file_index_t fileCount;
|
|
|
|
tr_file_index_t * files = fileListFromList (l, &fileCount);
|
|
|
|
tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_NORMAL);
|
|
|
|
tr_free (files);
|
2009-04-02 20:43:42 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
if (tr_variantDictFindList (args_in, TR_KEY_priority_high, &l))
|
|
|
|
{
|
|
|
|
tr_file_index_t fileCount;
|
|
|
|
tr_file_index_t * files = fileListFromList (l, &fileCount);
|
|
|
|
tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_HIGH);
|
|
|
|
tr_free (files);
|
2009-04-02 20:43:42 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
dbgmsg ("torrentAdd: filename is \"%s\"", filename ? filename : " (null)");
|
2008-05-12 13:05:06 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (isCurlURL (filename))
|
2008-09-23 19:11:04 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
struct add_torrent_idle_data * d = tr_new0 (struct add_torrent_idle_data, 1);
|
|
|
|
d->data = idle_data;
|
|
|
|
d->ctor = ctor;
|
|
|
|
tr_webRunWithCookies (session, filename, cookies, gotMetadataFromURL, d);
|
2008-09-23 19:11:04 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else
|
2008-09-23 19:11:04 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
char * fname = tr_strstrip (tr_strdup (filename));
|
2010-01-20 18:15:09 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
if (fname == NULL)
|
2009-11-24 02:16:31 +00:00
|
|
|
{
|
2014-12-04 19:58:34 +00:00
|
|
|
size_t len;
|
|
|
|
char * metainfo = tr_base64_decode_str (metainfo_base64, &len);
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_ctorSetMetainfo (ctor, (uint8_t*)metainfo, len);
|
|
|
|
tr_free (metainfo);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else if (!strncmp (fname, "magnet:?", 8))
|
2009-11-24 02:16:31 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_ctorSetMetainfoFromMagnetLink (ctor, fname);
|
2009-11-24 02:16:31 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else
|
2009-11-24 02:16:31 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_ctorSetMetainfoFromFile (ctor, fname);
|
2009-11-24 02:16:31 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
addTorrentImpl (idle_data, ctor);
|
2010-01-20 18:15:09 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (fname);
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2008-05-12 13:05:06 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
return NULL;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 13:05:06 +00:00
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
sessionSet (tr_session * session,
|
2013-02-09 04:05:03 +00:00
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int64_t i;
|
|
|
|
double d;
|
|
|
|
bool boolVal;
|
|
|
|
const char * str;
|
|
|
|
|
|
|
|
assert (idle_data == NULL);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_cache_size_mb, &i))
|
|
|
|
tr_sessionSetCacheLimit_MB (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_up, &i))
|
|
|
|
tr_sessionSetAltSpeed_KBps (session, TR_UP, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_down, &i))
|
|
|
|
tr_sessionSetAltSpeed_KBps (session, TR_DOWN, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_alt_speed_enabled, &boolVal))
|
|
|
|
tr_sessionUseAltSpeed (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_begin, &i))
|
|
|
|
tr_sessionSetAltSpeedBegin (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_end, &i))
|
|
|
|
tr_sessionSetAltSpeedEnd (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_day, &i))
|
|
|
|
tr_sessionSetAltSpeedDay (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_alt_speed_time_enabled, &boolVal))
|
|
|
|
tr_sessionUseAltSpeedTime (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_blocklist_enabled, &boolVal))
|
|
|
|
tr_blocklistSetEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindStr (args_in, TR_KEY_blocklist_url, &str, NULL))
|
|
|
|
tr_blocklistSetURL (session, str);
|
|
|
|
|
|
|
|
if (tr_variantDictFindStr (args_in, TR_KEY_download_dir, &str, NULL))
|
|
|
|
tr_sessionSetDownloadDir (session, str);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_queue_stalled_minutes, &i))
|
|
|
|
tr_sessionSetQueueStalledMinutes (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_queue_stalled_enabled, &boolVal))
|
|
|
|
tr_sessionSetQueueStalledEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_download_queue_size, &i))
|
|
|
|
tr_sessionSetQueueSize (session, TR_DOWN, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_download_queue_enabled, &boolVal))
|
|
|
|
tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindStr (args_in, TR_KEY_incomplete_dir, &str, NULL))
|
|
|
|
tr_sessionSetIncompleteDir (session, str);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_incomplete_dir_enabled, &boolVal))
|
|
|
|
tr_sessionSetIncompleteDirEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit_global, &i))
|
|
|
|
tr_sessionSetPeerLimit (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit_per_torrent, &i))
|
|
|
|
tr_sessionSetPeerLimitPerTorrent (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_pex_enabled, &boolVal))
|
|
|
|
tr_sessionSetPexEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_dht_enabled, &boolVal))
|
|
|
|
tr_sessionSetDHTEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_utp_enabled, &boolVal))
|
|
|
|
tr_sessionSetUTPEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_lpd_enabled, &boolVal))
|
|
|
|
tr_sessionSetLPDEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_peer_port_random_on_start, &boolVal))
|
|
|
|
tr_sessionSetPeerPortRandomOnStart (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_peer_port, &i))
|
|
|
|
tr_sessionSetPeerPort (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_port_forwarding_enabled, &boolVal))
|
|
|
|
tr_sessionSetPortForwardingEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_rename_partial_files, &boolVal))
|
|
|
|
tr_sessionSetIncompleteFileNamingEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindReal (args_in, TR_KEY_seedRatioLimit, &d))
|
|
|
|
tr_sessionSetRatioLimit (session, d);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_seedRatioLimited, &boolVal))
|
|
|
|
tr_sessionSetRatioLimited (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_idle_seeding_limit, &i))
|
|
|
|
tr_sessionSetIdleLimit (session, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_idle_seeding_limit_enabled, &boolVal))
|
|
|
|
tr_sessionSetIdleLimited (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_start_added_torrents, &boolVal))
|
|
|
|
tr_sessionSetPaused (session, !boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_seed_queue_enabled, &boolVal))
|
|
|
|
tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_seed_queue_size, &i))
|
|
|
|
tr_sessionSetQueueSize (session, TR_UP, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindStr (args_in, TR_KEY_script_torrent_done_filename, &str, NULL))
|
|
|
|
tr_sessionSetTorrentDoneScript (session, str);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_script_torrent_done_enabled, &boolVal))
|
|
|
|
tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_trash_original_torrent_files, &boolVal))
|
|
|
|
tr_sessionSetDeleteSource (session, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_speed_limit_down, &i))
|
|
|
|
tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_speed_limit_down_enabled, &boolVal))
|
|
|
|
tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindInt (args_in, TR_KEY_speed_limit_up, &i))
|
|
|
|
tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
|
|
|
|
|
|
|
|
if (tr_variantDictFindBool (args_in, TR_KEY_speed_limit_up_enabled, &boolVal))
|
|
|
|
tr_sessionLimitSpeed (session, TR_UP, boolVal);
|
|
|
|
|
|
|
|
if (tr_variantDictFindStr (args_in, TR_KEY_encryption, &str, NULL))
|
|
|
|
{
|
|
|
|
if (!tr_strcmp0 (str, "required"))
|
|
|
|
tr_sessionSetEncryption (session, TR_ENCRYPTION_REQUIRED);
|
|
|
|
else if (!tr_strcmp0 (str, "tolerated"))
|
|
|
|
tr_sessionSetEncryption (session, TR_CLEAR_PREFERRED);
|
|
|
|
else
|
|
|
|
tr_sessionSetEncryption (session, TR_ENCRYPTION_PREFERRED);
|
2008-05-12 16:33:17 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
notify (session, TR_RPC_SESSION_CHANGED, NULL);
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
return NULL;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2008-06-18 22:01:15 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
sessionStats (tr_session * session,
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variant * args_in UNUSED,
|
|
|
|
tr_variant * args_out,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-06-18 22:01:15 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int running = 0;
|
|
|
|
int total = 0;
|
|
|
|
tr_variant * d;
|
|
|
|
tr_session_stats currentStats = { 0.0f, 0, 0, 0, 0, 0 };
|
|
|
|
tr_session_stats cumulativeStats = { 0.0f, 0, 0, 0, 0, 0 };
|
|
|
|
tr_torrent * tor = NULL;
|
|
|
|
|
|
|
|
assert (idle_data == NULL);
|
|
|
|
|
|
|
|
while ((tor = tr_torrentNext (session, tor)))
|
|
|
|
{
|
|
|
|
++total;
|
|
|
|
|
|
|
|
if (tor->isRunning)
|
|
|
|
++running;
|
2008-06-18 22:01:15 +00:00
|
|
|
}
|
2008-09-23 19:11:04 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_sessionGetStats (session, ¤tStats);
|
|
|
|
tr_sessionGetCumulativeStats (session, &cumulativeStats);
|
|
|
|
|
|
|
|
tr_variantDictAddInt (args_out, TR_KEY_activeTorrentCount, running);
|
|
|
|
tr_variantDictAddReal (args_out, TR_KEY_downloadSpeed, tr_sessionGetPieceSpeed_Bps (session, TR_DOWN));
|
|
|
|
tr_variantDictAddInt (args_out, TR_KEY_pausedTorrentCount, total - running);
|
|
|
|
tr_variantDictAddInt (args_out, TR_KEY_torrentCount, total);
|
|
|
|
tr_variantDictAddReal (args_out, TR_KEY_uploadSpeed, tr_sessionGetPieceSpeed_Bps (session, TR_UP));
|
|
|
|
|
|
|
|
d = tr_variantDictAddDict (args_out, TR_KEY_cumulative_stats, 5);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_downloadedBytes, cumulativeStats.downloadedBytes);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_filesAdded, cumulativeStats.filesAdded);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_secondsActive, cumulativeStats.secondsActive);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_sessionCount, cumulativeStats.sessionCount);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_uploadedBytes, cumulativeStats.uploadedBytes);
|
|
|
|
|
|
|
|
d = tr_variantDictAddDict (args_out, TR_KEY_current_stats, 5);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_downloadedBytes, currentStats.downloadedBytes);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_filesAdded, currentStats.filesAdded);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_secondsActive, currentStats.secondsActive);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_sessionCount, currentStats.sessionCount);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_uploadedBytes, currentStats.uploadedBytes);
|
|
|
|
|
|
|
|
return NULL;
|
2008-06-18 22:01:15 +00:00
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
sessionGet (tr_session * s,
|
2013-02-10 19:36:13 +00:00
|
|
|
tr_variant * args_in UNUSED,
|
|
|
|
tr_variant * args_out,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * str;
|
|
|
|
tr_variant * d = args_out;
|
|
|
|
|
|
|
|
assert (idle_data == NULL);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_alt_speed_up, tr_sessionGetAltSpeed_KBps (s,TR_UP));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_alt_speed_down, tr_sessionGetAltSpeed_KBps (s,TR_DOWN));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_alt_speed_enabled, tr_sessionUsesAltSpeed (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_alt_speed_time_begin, tr_sessionGetAltSpeedBegin (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_alt_speed_time_end,tr_sessionGetAltSpeedEnd (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_alt_speed_time_day,tr_sessionGetAltSpeedDay (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_alt_speed_time_enabled, tr_sessionUsesAltSpeedTime (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_blocklist_enabled, tr_blocklistIsEnabled (s));
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_blocklist_url, tr_blocklistGetURL (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_cache_size_mb, tr_sessionGetCacheLimit_MB (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_blocklist_size, tr_blocklistGetRuleCount (s));
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_config_dir, tr_sessionGetConfigDir (s));
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_download_dir, tr_sessionGetDownloadDir (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_download_dir_free_space, tr_device_info_get_free_space (s->downloadDir));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_download_queue_enabled, tr_sessionGetQueueEnabled (s, TR_DOWN));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_download_queue_size, tr_sessionGetQueueSize (s, TR_DOWN));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_peer_limit_global, tr_sessionGetPeerLimit (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_peer_limit_per_torrent, tr_sessionGetPeerLimitPerTorrent (s));
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_incomplete_dir, tr_sessionGetIncompleteDir (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_incomplete_dir_enabled, tr_sessionIsIncompleteDirEnabled (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_pex_enabled, tr_sessionIsPexEnabled (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_utp_enabled, tr_sessionIsUTPEnabled (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_dht_enabled, tr_sessionIsDHTEnabled (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_lpd_enabled, tr_sessionIsLPDEnabled (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_peer_port, tr_sessionGetPeerPort (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_peer_port_random_on_start, tr_sessionGetPeerPortRandomOnStart (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_port_forwarding_enabled, tr_sessionIsPortForwardingEnabled (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_rename_partial_files, tr_sessionIsIncompleteFileNamingEnabled (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_rpc_version, RPC_VERSION);
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_rpc_version_minimum, RPC_VERSION_MIN);
|
|
|
|
tr_variantDictAddReal (d, TR_KEY_seedRatioLimit, tr_sessionGetRatioLimit (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_seedRatioLimited, tr_sessionIsRatioLimited (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_idle_seeding_limit, tr_sessionGetIdleLimit (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_idle_seeding_limit_enabled, tr_sessionIsIdleLimited (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_seed_queue_enabled, tr_sessionGetQueueEnabled (s, TR_UP));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_seed_queue_size, tr_sessionGetQueueSize (s, TR_UP));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_start_added_torrents, !tr_sessionGetPaused (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_trash_original_torrent_files, tr_sessionGetDeleteSource (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_speed_limit_up, tr_sessionGetSpeedLimit_KBps (s, TR_UP));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_speed_limit_up_enabled, tr_sessionIsSpeedLimited (s, TR_UP));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_speed_limit_down, tr_sessionGetSpeedLimit_KBps (s, TR_DOWN));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_speed_limit_down_enabled, tr_sessionIsSpeedLimited (s, TR_DOWN));
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_script_torrent_done_filename, tr_sessionGetTorrentDoneScript (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_script_torrent_done_enabled, tr_sessionIsTorrentDoneScriptEnabled (s));
|
|
|
|
tr_variantDictAddBool (d, TR_KEY_queue_stalled_enabled, tr_sessionGetQueueStalledEnabled (s));
|
|
|
|
tr_variantDictAddInt (d, TR_KEY_queue_stalled_minutes, tr_sessionGetQueueStalledMinutes (s));
|
|
|
|
tr_formatter_get_units (tr_variantDictAddDict (d, TR_KEY_units, 0));
|
|
|
|
tr_variantDictAddStr (d, TR_KEY_version, LONG_VERSION_STRING);
|
|
|
|
switch (tr_sessionGetEncryption (s))
|
|
|
|
{
|
|
|
|
case TR_CLEAR_PREFERRED: str = "tolerated"; break;
|
|
|
|
case TR_ENCRYPTION_REQUIRED: str = "required"; break;
|
|
|
|
default: str = "preferred"; break;
|
2008-05-12 16:33:17 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantDictAddStr (d, TR_KEY_encryption, str);
|
2011-03-04 23:26:10 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
return NULL;
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2013-02-09 04:05:03 +00:00
|
|
|
static const char*
|
|
|
|
freeSpace (tr_session * session,
|
|
|
|
tr_variant * args_in,
|
|
|
|
tr_variant * args_out,
|
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
|
|
|
{
|
|
|
|
int tmperr;
|
|
|
|
const char * path = NULL;
|
|
|
|
const char * err = NULL;
|
|
|
|
int64_t free_space = -1;
|
|
|
|
|
|
|
|
/* get the free space */
|
|
|
|
tr_variantDictFindStr (args_in, TR_KEY_path, &path, NULL);
|
|
|
|
tmperr = errno;
|
|
|
|
errno = 0;
|
|
|
|
free_space = tr_sessionGetDirFreeSpace (session, path);
|
|
|
|
if (free_space < 0)
|
|
|
|
err = tr_strerror (errno);
|
|
|
|
errno = tmperr;
|
|
|
|
|
|
|
|
/* response */
|
|
|
|
if (path != NULL)
|
|
|
|
tr_variantDictAddStr (args_out, TR_KEY_path, path);
|
|
|
|
tr_variantDictAddInt (args_out, TR_KEY_size_bytes, free_space);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-05-12 00:41:55 +00:00
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2011-01-15 18:12:45 +00:00
|
|
|
static const char*
|
2012-12-05 17:29:46 +00:00
|
|
|
sessionClose (tr_session * session,
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variant * args_in UNUSED,
|
|
|
|
tr_variant * args_out UNUSED,
|
2012-12-05 17:29:46 +00:00
|
|
|
struct tr_rpc_idle_data * idle_data UNUSED)
|
2011-01-15 18:12:45 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
notify (session, TR_RPC_SESSION_CLOSE, NULL);
|
|
|
|
return NULL;
|
2011-01-15 18:12:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/***
|
|
|
|
****
|
|
|
|
***/
|
|
|
|
|
2012-12-14 04:34:42 +00:00
|
|
|
typedef const char* (*handler)(tr_session*, tr_variant*, tr_variant*, struct tr_rpc_idle_data *);
|
2008-09-23 19:11:04 +00:00
|
|
|
|
|
|
|
static struct method
|
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * name;
|
|
|
|
bool immediate;
|
|
|
|
handler func;
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
|
|
|
methods[] =
|
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
{ "port-test", false, portTest },
|
|
|
|
{ "blocklist-update", false, blocklistUpdate },
|
|
|
|
{ "free-space", true, freeSpace },
|
|
|
|
{ "session-close", true, sessionClose },
|
|
|
|
{ "session-get", true, sessionGet },
|
|
|
|
{ "session-set", true, sessionSet },
|
|
|
|
{ "session-stats", true, sessionStats },
|
|
|
|
{ "torrent-add", false, torrentAdd },
|
|
|
|
{ "torrent-get", true, torrentGet },
|
|
|
|
{ "torrent-remove", true, torrentRemove },
|
|
|
|
{ "torrent-rename-path", false, torrentRenamePath },
|
|
|
|
{ "torrent-set", true, torrentSet },
|
|
|
|
{ "torrent-set-location", true, torrentSetLocation },
|
|
|
|
{ "torrent-start", true, torrentStart },
|
|
|
|
{ "torrent-start-now", true, torrentStartNow },
|
|
|
|
{ "torrent-stop", true, torrentStop },
|
|
|
|
{ "torrent-verify", true, torrentVerify },
|
|
|
|
{ "torrent-reannounce", true, torrentReannounce },
|
|
|
|
{ "queue-move-top", true, queueMoveTop },
|
|
|
|
{ "queue-move-up", true, queueMoveUp },
|
|
|
|
{ "queue-move-down", true, queueMoveDown },
|
|
|
|
{ "queue-move-bottom", true, queueMoveBottom }
|
2008-05-12 13:05:06 +00:00
|
|
|
};
|
|
|
|
|
2009-01-20 02:03:09 +00:00
|
|
|
static void
|
2015-07-13 00:32:48 +00:00
|
|
|
noop_response_callback (tr_session * session UNUSED,
|
|
|
|
tr_variant * response UNUSED,
|
|
|
|
void * user_data UNUSED)
|
2009-01-20 02:03:09 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2015-07-13 00:32:48 +00:00
|
|
|
void
|
|
|
|
tr_rpc_request_exec_json (tr_session * session,
|
|
|
|
const tr_variant * request,
|
|
|
|
tr_rpc_response_func callback,
|
|
|
|
void * callback_user_data)
|
2008-05-12 00:41:55 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int i;
|
|
|
|
const char * str;
|
2015-07-13 00:32:48 +00:00
|
|
|
tr_variant * const mutable_request = (tr_variant *) request;
|
|
|
|
tr_variant * args_in = tr_variantDictFind (mutable_request, TR_KEY_arguments);
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * result = NULL;
|
|
|
|
|
|
|
|
if (callback == NULL)
|
|
|
|
callback = noop_response_callback;
|
|
|
|
|
|
|
|
/* parse the request */
|
2015-07-13 00:32:48 +00:00
|
|
|
if (!tr_variantDictFindStr (mutable_request, TR_KEY_method, &str, NULL))
|
2013-05-23 00:11:09 +00:00
|
|
|
{
|
|
|
|
result = "no method name";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const int n = TR_N_ELEMENTS (methods);
|
|
|
|
|
|
|
|
for (i=0; i<n; ++i)
|
|
|
|
if (!strcmp (str, methods[i].name))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (i ==n)
|
|
|
|
result = "method name not recognized";
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
/* if we couldn't figure out which method to use, return an error */
|
|
|
|
if (result != NULL)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int64_t tag;
|
|
|
|
tr_variant response;
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantInitDict (&response, 3);
|
|
|
|
tr_variantDictAddDict (&response, TR_KEY_arguments, 0);
|
|
|
|
tr_variantDictAddStr (&response, TR_KEY_result, result);
|
2015-07-13 00:32:48 +00:00
|
|
|
if (tr_variantDictFindInt (mutable_request, TR_KEY_tag, &tag))
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantDictAddInt (&response, TR_KEY_tag, tag);
|
2009-01-18 15:24:26 +00:00
|
|
|
|
2015-07-13 00:32:48 +00:00
|
|
|
(*callback)(session, &response, callback_user_data);
|
2011-04-27 21:22:08 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantFree (&response);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else if (methods[i].immediate)
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int64_t tag;
|
|
|
|
tr_variant response;
|
|
|
|
tr_variant * args_out;
|
|
|
|
|
|
|
|
tr_variantInitDict (&response, 3);
|
|
|
|
args_out = tr_variantDictAddDict (&response, TR_KEY_arguments, 0);
|
|
|
|
result = (*methods[i].func)(session, args_in, args_out, NULL);
|
|
|
|
if (result == NULL)
|
|
|
|
result = "success";
|
|
|
|
tr_variantDictAddStr (&response, TR_KEY_result, result);
|
2015-07-13 00:32:48 +00:00
|
|
|
if (tr_variantDictFindInt (mutable_request, TR_KEY_tag, &tag))
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantDictAddInt (&response, TR_KEY_tag, tag);
|
|
|
|
|
2015-07-13 00:32:48 +00:00
|
|
|
(*callback)(session, &response, callback_user_data);
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
tr_variantFree (&response);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
else
|
2009-01-18 15:24:26 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int64_t tag;
|
|
|
|
struct tr_rpc_idle_data * data = tr_new0 (struct tr_rpc_idle_data, 1);
|
|
|
|
data->session = session;
|
|
|
|
data->response = tr_new0 (tr_variant, 1);
|
|
|
|
tr_variantInitDict (data->response, 3);
|
2015-07-13 00:32:48 +00:00
|
|
|
if (tr_variantDictFindInt (mutable_request, TR_KEY_tag, &tag))
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantDictAddInt (data->response, TR_KEY_tag, tag);
|
|
|
|
data->args_out = tr_variantDictAddDict (data->response, TR_KEY_arguments, 0);
|
|
|
|
data->callback = callback;
|
|
|
|
data->callback_user_data = callback_user_data;
|
|
|
|
(*methods[i].func)(session, args_in, data->args_out, data);
|
2009-01-18 15:24:26 +00:00
|
|
|
}
|
2008-05-12 00:41:55 +00:00
|
|
|
}
|
|
|
|
|
2008-05-24 18:22:16 +00:00
|
|
|
/**
|
|
|
|
* Munge the URI into a usable form.
|
|
|
|
*
|
|
|
|
* We have very loose typing on this to make the URIs as simple as possible:
|
|
|
|
* - anything not a 'tag' or 'method' is automatically in 'arguments'
|
|
|
|
* - values that are all-digits are numbers
|
|
|
|
* - values that are all-digits or commas are number lists
|
|
|
|
* - all other values are strings
|
|
|
|
*/
|
|
|
|
void
|
2012-12-14 04:34:42 +00:00
|
|
|
tr_rpc_parse_list_str (tr_variant * setme,
|
2009-02-09 17:25:48 +00:00
|
|
|
const char * str,
|
2012-12-05 17:29:46 +00:00
|
|
|
int len)
|
2008-05-24 18:22:16 +00:00
|
|
|
|
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
int valueCount;
|
|
|
|
int * values = tr_parseNumberRange (str, len, &valueCount);
|
|
|
|
|
|
|
|
if (valueCount == 0)
|
|
|
|
{
|
|
|
|
tr_variantInitStr (setme, str, len);
|
|
|
|
}
|
|
|
|
else if (valueCount == 1)
|
|
|
|
{
|
|
|
|
tr_variantInitInt (setme, values[0]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
tr_variantInitList (setme, valueCount);
|
|
|
|
|
|
|
|
for (i=0; i<valueCount; ++i)
|
|
|
|
tr_variantListAddInt (setme, values[i]);
|
2008-05-24 18:22:16 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_free (values);
|
2008-05-24 18:22:16 +00:00
|
|
|
}
|
|
|
|
|
2008-12-30 22:07:39 +00:00
|
|
|
void
|
2012-12-05 17:29:46 +00:00
|
|
|
tr_rpc_request_exec_uri (tr_session * session,
|
2009-01-18 15:24:26 +00:00
|
|
|
const void * request_uri,
|
2009-01-19 14:05:43 +00:00
|
|
|
int request_len,
|
2009-01-18 15:24:26 +00:00
|
|
|
tr_rpc_response_func callback,
|
2012-12-05 17:29:46 +00:00
|
|
|
void * callback_user_data)
|
2008-05-13 12:52:58 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * pch;
|
|
|
|
tr_variant top;
|
|
|
|
tr_variant * args;
|
|
|
|
char * request = tr_strndup (request_uri, request_len);
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
tr_variantInitDict (&top, 3);
|
|
|
|
args = tr_variantDictAddDict (&top, TR_KEY_arguments, 0);
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
pch = strchr (request, '?');
|
|
|
|
if (!pch) pch = request;
|
|
|
|
while (pch)
|
2008-05-13 17:31:09 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
const char * delim = strchr (pch, '=');
|
|
|
|
const char * next = strchr (pch, '&');
|
|
|
|
if (delim)
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2013-05-23 00:11:09 +00:00
|
|
|
char * key = tr_strndup (pch, delim - pch);
|
|
|
|
int isArg = strcmp (key, "method") && strcmp (key, "tag");
|
|
|
|
tr_variant * parent = isArg ? args : ⊤
|
|
|
|
|
|
|
|
tr_rpc_parse_list_str (tr_variantDictAdd (parent, tr_quark_new (key, delim-pch)),
|
|
|
|
delim + 1,
|
|
|
|
next ? (size_t)(next - (delim + 1)) : strlen (delim + 1));
|
|
|
|
tr_free (key);
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
2013-05-23 00:11:09 +00:00
|
|
|
|
|
|
|
pch = next ? next + 1 : NULL;
|
2008-05-13 17:31:09 +00:00
|
|
|
}
|
|
|
|
|
2015-07-13 00:32:48 +00:00
|
|
|
tr_rpc_request_exec_json (session, &top, callback, callback_user_data);
|
2008-05-13 17:31:09 +00:00
|
|
|
|
2013-05-23 00:11:09 +00:00
|
|
|
/* cleanup */
|
|
|
|
tr_variantFree (&top);
|
|
|
|
tr_free (request);
|
2008-05-13 12:52:58 +00:00
|
|
|
}
|