source: trunk/daemon/remote.c @ 14336

Last change on this file since 14336 was 14336, checked in by jordan, 8 years ago

(trunk) #4160: mike.dld patch: 4160-07-env.patch

  • Property svn:keywords set to Date Rev Author Id
File size: 91.0 KB
Line 
1/*
2 * This file Copyright (C) 2008-2014 Mnemosyne LLC
3 *
4 * It may be used under the GNU GPL versions 2 or 3
5 * or any future license endorsed by Mnemosyne LLC.
6 *
7 * $Id: remote.c 14336 2014-09-21 18:05:14Z jordan $
8 */
9
10#include <assert.h>
11#include <ctype.h> /* isspace */
12#include <math.h>
13#include <stdio.h>
14#include <stdlib.h>
15#include <string.h> /* strcmp */
16
17#include <event2/buffer.h>
18
19#define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
20#include <curl/curl.h>
21
22#include <libtransmission/transmission.h>
23#include <libtransmission/error.h>
24#include <libtransmission/file.h>
25#include <libtransmission/log.h>
26#include <libtransmission/rpcimpl.h>
27#include <libtransmission/tr-getopt.h>
28#include <libtransmission/utils.h>
29#include <libtransmission/variant.h>
30#include <libtransmission/version.h>
31
32#define MY_NAME "transmission-remote"
33#define DEFAULT_HOST "localhost"
34#define DEFAULT_PORT atoi (TR_DEFAULT_RPC_PORT_STR)
35#define DEFAULT_URL TR_DEFAULT_RPC_URL_STR "rpc/"
36
37#define ARGUMENTS TR_KEY_arguments
38
39#define MEM_K 1024
40#define MEM_B_STR   "B"
41#define MEM_K_STR "KiB"
42#define MEM_M_STR "MiB"
43#define MEM_G_STR "GiB"
44#define MEM_T_STR "TiB"
45
46#define DISK_K 1000
47#define DISK_B_STR  "B"
48#define DISK_K_STR "kB"
49#define DISK_M_STR "MB"
50#define DISK_G_STR "GB"
51#define DISK_T_STR "TB"
52
53#define SPEED_K 1000
54#define SPEED_B_STR  "B/s"
55#define SPEED_K_STR "kB/s"
56#define SPEED_M_STR "MB/s"
57#define SPEED_G_STR "GB/s"
58#define SPEED_T_STR "TB/s"
59
60/***
61****
62****  Display Utilities
63****
64***/
65
66static void
67etaToString (char *  buf, size_t  buflen, int64_t eta)
68{
69    if (eta < 0)
70        tr_snprintf (buf, buflen, "Unknown");
71    else if (eta < 60)
72        tr_snprintf (buf, buflen, "%" PRId64 " sec", eta);
73    else if (eta < (60 * 60))
74        tr_snprintf (buf, buflen, "%" PRId64 " min", eta / 60);
75    else if (eta < (60 * 60 * 24))
76        tr_snprintf (buf, buflen, "%" PRId64 " hrs", eta / (60 * 60));
77    else
78        tr_snprintf (buf, buflen, "%" PRId64 " days", eta / (60 * 60 * 24));
79}
80
81static char*
82tr_strltime (char * buf, int seconds, size_t buflen)
83{
84    int  days, hours, minutes, total_seconds;
85    char b[128], d[128], h[128], m[128], s[128], t[128];
86
87    if (seconds < 0)
88        seconds = 0;
89
90    total_seconds = seconds;
91    days = seconds / 86400;
92    hours = (seconds % 86400) / 3600;
93    minutes = (seconds % 3600) / 60;
94    seconds = (seconds % 3600) % 60;
95
96    tr_snprintf (d, sizeof (d), "%d %s", days, days==1?"day":"days");
97    tr_snprintf (h, sizeof (h), "%d %s", hours, hours==1?"hour":"hours");
98    tr_snprintf (m, sizeof (m), "%d %s", minutes, minutes==1?"minute":"minutes");
99    tr_snprintf (s, sizeof (s), "%d %s", seconds, seconds==1?"second":"seconds");
100    tr_snprintf (t, sizeof (t), "%d %s", total_seconds, total_seconds==1?"second":"seconds");
101
102    if (days)
103    {
104        if (days >= 4 || !hours)
105            tr_strlcpy (b, d, sizeof (b));
106        else
107            tr_snprintf (b, sizeof (b), "%s, %s", d, h);
108    }
109    else if (hours)
110    {
111        if (hours >= 4 || !minutes)
112            tr_strlcpy (b, h, sizeof (b));
113        else
114            tr_snprintf (b, sizeof (b), "%s, %s", h, m);
115    }
116    else if (minutes)
117    {
118        if (minutes >= 4 || !seconds)
119            tr_strlcpy (b, m, sizeof (b));
120        else
121            tr_snprintf (b, sizeof (b), "%s, %s", m, s);
122    }
123    else tr_strlcpy (b, s, sizeof (b));
124
125    tr_snprintf (buf, buflen, "%s (%s)", b, t);
126    return buf;
127}
128
129static char*
130strlpercent (char * buf, double x, size_t buflen)
131{
132    return tr_strpercent (buf, x, buflen);
133}
134
135static char*
136strlratio2 (char * buf, double ratio, size_t buflen)
137{
138    return tr_strratio (buf, buflen, ratio, "Inf");
139}
140
141static char*
142strlratio (char * buf, int64_t numerator, int64_t denominator, size_t buflen)
143{
144    double ratio;
145
146    if (denominator != 0)
147        ratio = numerator / (double)denominator;
148    else if (numerator != 0)
149        ratio = TR_RATIO_INF;
150    else
151        ratio = TR_RATIO_NA;
152
153    return strlratio2 (buf, ratio, buflen);
154}
155
156static char*
157strlmem (char * buf, int64_t bytes, size_t buflen)
158{
159    if (!bytes)
160        tr_strlcpy (buf, "None", buflen);
161    else
162        tr_formatter_mem_B (buf, bytes, buflen);
163
164    return buf;
165}
166
167static char*
168strlsize (char * buf, int64_t bytes, size_t buflen)
169{
170    if (bytes < 0)
171        tr_strlcpy (buf, "Unknown", buflen);
172    else if (bytes == 0)
173        tr_strlcpy (buf, "None", buflen);
174    else
175        tr_formatter_size_B (buf, bytes, buflen);
176
177    return buf;
178}
179
180enum
181{
182    TAG_SESSION,
183    TAG_STATS,
184    TAG_DETAILS,
185    TAG_FILES,
186    TAG_LIST,
187    TAG_PEERS,
188    TAG_PIECES,
189    TAG_PORTTEST,
190    TAG_TORRENT_ADD,
191    TAG_TRACKERS
192};
193
194static const char*
195getUsage (void)
196{
197    return
198        MY_NAME" "LONG_VERSION_STRING"\n"
199        "A fast and easy BitTorrent client\n"
200        "http://www.transmissionbt.com/\n"
201        "\n"
202        "Usage: " MY_NAME
203        " [host] [options]\n"
204        "       "
205        MY_NAME " [port] [options]\n"
206                "       "
207        MY_NAME " [host:port] [options]\n"
208                "       "
209        MY_NAME " [http(s?)://host:port/transmission/] [options]\n"
210                "\n"
211                "See the man page for detailed explanations and many examples.";
212}
213
214/***
215****
216****  Command-Line Arguments
217****
218***/
219
220static tr_option opts[] =
221{
222    { 'a', "add",                    "Add torrent files by filename or URL", "a",  0, NULL },
223    { 970, "alt-speed",              "Use the alternate Limits", "as",  0, NULL },
224    { 971, "no-alt-speed",           "Don't use the alternate Limits", "AS",  0, NULL },
225    { 972, "alt-speed-downlimit",    "max alternate download speed (in "SPEED_K_STR")", "asd",  1, "<speed>" },
226    { 973, "alt-speed-uplimit",      "max alternate upload speed (in "SPEED_K_STR")", "asu",  1, "<speed>" },
227    { 974, "alt-speed-scheduler",    "Use the scheduled on/off times", "asc",  0, NULL },
228    { 975, "no-alt-speed-scheduler", "Don't use the scheduled on/off times", "ASC",  0, NULL },
229    { 976, "alt-speed-time-begin",   "Time to start using the alt speed limits (in hhmm)", NULL,  1, "<time>" },
230    { 977, "alt-speed-time-end",     "Time to stop using the alt speed limits (in hhmm)", NULL,  1, "<time>" },
231    { 978, "alt-speed-days",         "Numbers for any/all days of the week - eg. \"1-7\"", NULL,  1, "<days>" },
232    { 963, "blocklist-update",       "Blocklist update", NULL, 0, NULL },
233    { 'c', "incomplete-dir",         "Where to store new torrents until they're complete", "c", 1, "<dir>" },
234    { 'C', "no-incomplete-dir",      "Don't store incomplete torrents in a different location", "C", 0, NULL },
235    { 'b', "debug",                  "Print debugging information", "b",  0, NULL },
236    { 'd', "downlimit",              "Set the max download speed in "SPEED_K_STR" for the current torrent(s) or globally", "d", 1, "<speed>" },
237    { 'D', "no-downlimit",           "Disable max download speed for the current torrent(s) or globally", "D", 0, NULL },
238    { 'e', "cache",                  "Set the maximum size of the session's memory cache (in " MEM_M_STR ")", "e", 1, "<size>" },
239    { 910, "encryption-required",    "Encrypt all peer connections", "er", 0, NULL },
240    { 911, "encryption-preferred",   "Prefer encrypted peer connections", "ep", 0, NULL },
241    { 912, "encryption-tolerated",   "Prefer unencrypted peer connections", "et", 0, NULL },
242    { 850, "exit",                   "Tell the transmission session to shut down", NULL, 0, NULL },
243    { 940, "files",                  "List the current torrent(s)' files", "f",  0, NULL },
244    { 'g', "get",                    "Mark files for download", "g",  1, "<files>" },
245    { 'G', "no-get",                 "Mark files for not downloading", "G",  1, "<files>" },
246    { 'i', "info",                   "Show the current torrent(s)' details", "i",  0, NULL },
247    { 940, "info-files",             "List the current torrent(s)' files", "if",  0, NULL },
248    { 941, "info-peers",             "List the current torrent(s)' peers", "ip",  0, NULL },
249    { 942, "info-pieces",            "List the current torrent(s)' pieces", "ic",  0, NULL },
250    { 943, "info-trackers",          "List the current torrent(s)' trackers", "it",  0, NULL },
251    { 920, "session-info",           "Show the session's details", "si", 0, NULL },
252    { 921, "session-stats",          "Show the session's statistics", "st", 0, NULL },
253    { 'l', "list",                   "List all torrents", "l",  0, NULL },
254    { 960, "move",                   "Move current torrent's data to a new folder", NULL, 1, "<path>" },
255    { 961, "find",                   "Tell Transmission where to find a torrent's data", NULL, 1, "<path>" },
256    { 'm', "portmap",                "Enable portmapping via NAT-PMP or UPnP", "m",  0, NULL },
257    { 'M', "no-portmap",             "Disable portmapping", "M",  0, NULL },
258    { 'n', "auth",                   "Set username and password", "n",  1, "<user:pw>" },
259    { 810, "authenv",                "Set authentication info from the TR_AUTH environment variable (user:pw)", "ne", 0, NULL },
260    { 'N', "netrc",                  "Set authentication info from a .netrc file", "N",  1, "<file>" },
261    { 820, "ssl",                    "Use SSL when talking to daemon", NULL,  0, NULL },
262    { 'o', "dht",                    "Enable distributed hash tables (DHT)", "o", 0, NULL },
263    { 'O', "no-dht",                 "Disable distributed hash tables (DHT)", "O", 0, NULL },
264    { 'p', "port",                   "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "p", 1, "<port>" },
265    { 962, "port-test",              "Port testing", "pt", 0, NULL },
266    { 'P', "random-port",            "Random port for incomping peers", "P", 0, NULL },
267    { 900, "priority-high",          "Try to download these file(s) first", "ph", 1, "<files>" },
268    { 901, "priority-normal",        "Try to download these file(s) normally", "pn", 1, "<files>" },
269    { 902, "priority-low",           "Try to download these file(s) last", "pl", 1, "<files>" },
270    { 700, "bandwidth-high",         "Give this torrent first chance at available bandwidth", "Bh", 0, NULL },
271    { 701, "bandwidth-normal",       "Give this torrent bandwidth left over by high priority torrents", "Bn", 0, NULL },
272    { 702, "bandwidth-low",          "Give this torrent bandwidth left over by high and normal priority torrents", "Bl", 0, NULL },
273    { 600, "reannounce",             "Reannounce the current torrent(s)", NULL,  0, NULL },
274    { 'r', "remove",                 "Remove the current torrent(s)", "r",  0, NULL },
275    { 930, "peers",                  "Set the maximum number of peers for the current torrent(s) or globally", "pr", 1, "<max>" },
276    { 'R', "remove-and-delete",      "Remove the current torrent(s) and delete local data", NULL, 0, NULL },
277    { 800, "torrent-done-script",    "Specify a script to run when a torrent finishes", NULL, 1, "<file>" },
278    { 801, "no-torrent-done-script", "Don't run a script when torrents finish", NULL, 0, NULL },
279    { 950, "seedratio",              "Let the current torrent(s) seed until a specific ratio", "sr", 1, "ratio" },
280    { 951, "seedratio-default",      "Let the current torrent(s) use the global seedratio settings", "srd", 0, NULL },
281    { 952, "no-seedratio",           "Let the current torrent(s) seed regardless of ratio", "SR", 0, NULL },
282    { 953, "global-seedratio",       "All torrents, unless overridden by a per-torrent setting, should seed until a specific ratio", "gsr", 1, "ratio" },
283    { 954, "no-global-seedratio",    "All torrents, unless overridden by a per-torrent setting, should seed regardless of ratio", "GSR", 0, NULL },
284    { 710, "tracker-add",            "Add a tracker to a torrent", "td", 1, "<tracker>" },
285    { 712, "tracker-remove",         "Remove a tracker from a torrent", "tr", 1, "<trackerId>" },
286    { 's', "start",                  "Start the current torrent(s)", "s",  0, NULL },
287    { 'S', "stop",                   "Stop the current torrent(s)", "S",  0, NULL },
288    { 't', "torrent",                "Set the current torrent(s)", "t",  1, "<torrent>" },
289    { 990, "start-paused",           "Start added torrents paused", NULL, 0, NULL },
290    { 991, "no-start-paused",        "Start added torrents unpaused", NULL, 0, NULL },
291    { 992, "trash-torrent",          "Delete torrents after adding", NULL, 0, NULL },
292    { 993, "no-trash-torrent",       "Do not delete torrents after adding", NULL, 0, NULL },
293    { 984, "honor-session",          "Make the current torrent(s) honor the session limits", "hl",  0, NULL },
294    { 985, "no-honor-session",       "Make the current torrent(s) not honor the session limits", "HL",  0, NULL },
295    { 'u', "uplimit",                "Set the max upload speed in "SPEED_K_STR" for the current torrent(s) or globally", "u", 1, "<speed>" },
296    { 'U', "no-uplimit",             "Disable max upload speed for the current torrent(s) or globally", "U", 0, NULL },
297    { 830, "utp",                    "Enable uTP for peer connections", NULL, 0, NULL },
298    { 831, "no-utp",                 "Disable uTP for peer connections", NULL, 0, NULL },
299    { 'v', "verify",                 "Verify the current torrent(s)", "v",  0, NULL },
300    { 'V', "version",                "Show version number and exit", "V", 0, NULL },
301    { 'w', "download-dir",           "When used in conjunction with --add, set the new torrent's download folder. Otherwise, set the default download folder", "w",  1, "<path>" },
302    { 'x', "pex",                    "Enable peer exchange (PEX)", "x",  0, NULL },
303    { 'X', "no-pex",                 "Disable peer exchange (PEX)", "X",  0, NULL },
304    { 'y', "lpd",                    "Enable local peer discovery (LPD)", "y",  0, NULL },
305    { 'Y', "no-lpd",                 "Disable local peer discovery (LPD)", "Y",  0, NULL },
306    { 941, "peer-info",              "List the current torrent(s)' peers", "pi",  0, NULL },
307    {   0, NULL,                     NULL, NULL, 0, NULL }
308};
309
310static void
311showUsage (void)
312{
313    tr_getopt_usage (MY_NAME, getUsage (), opts);
314}
315
316static int
317numarg (const char * arg)
318{
319  char * end = NULL;
320  const long num = strtol (arg, &end, 10);
321
322  if (*end)
323    {
324      fprintf (stderr, "Not a number: \"%s\"\n", arg);
325      showUsage ();
326      exit (EXIT_FAILURE);
327    }
328
329  return num;
330}
331
332enum
333{
334  MODE_TORRENT_START         = (1<<0),
335  MODE_TORRENT_STOP          = (1<<1),
336  MODE_TORRENT_VERIFY        = (1<<2),
337  MODE_TORRENT_REANNOUNCE    = (1<<3),
338  MODE_TORRENT_SET           = (1<<4),
339  MODE_TORRENT_GET           = (1<<5),
340  MODE_TORRENT_ADD           = (1<<6),
341  MODE_TORRENT_REMOVE        = (1<<7),
342  MODE_TORRENT_SET_LOCATION  = (1<<8),
343  MODE_SESSION_SET           = (1<<9),
344  MODE_SESSION_GET           = (1<<10),
345  MODE_SESSION_STATS         = (1<<11),
346  MODE_SESSION_CLOSE         = (1<<12),
347  MODE_BLOCKLIST_UPDATE      = (1<<13),
348  MODE_PORT_TEST             = (1<<14)
349};
350
351static int
352getOptMode (int val)
353{
354  switch (val)
355    {
356      case TR_OPT_ERR:
357      case TR_OPT_UNK:
358      case 'a': /* add torrent */
359      case 'b': /* debug */
360      case 'n': /* auth */
361      case 810: /* authenv */
362      case 'N': /* netrc */
363      case 820: /* UseSSL */
364      case 't': /* set current torrent */
365      case 'V': /* show version number */
366        return 0;
367
368      case 'c': /* incomplete-dir */
369      case 'C': /* no-incomplete-dir */
370      case 'e': /* cache */
371      case 'm': /* portmap */
372      case 'M': /* "no-portmap */
373      case 'o': /* dht */
374      case 'O': /* no-dht */
375      case 'p': /* incoming peer port */
376      case 'P': /* random incoming peer port */
377      case 'x': /* pex */
378      case 'X': /* no-pex */
379      case 'y': /* lpd */
380      case 'Y': /* no-lpd */
381      case 800: /* torrent-done-script */
382      case 801: /* no-torrent-done-script */
383      case 830: /* utp */
384      case 831: /* no-utp */
385      case 970: /* alt-speed */
386      case 971: /* no-alt-speed */
387      case 972: /* alt-speed-downlimit */
388      case 973: /* alt-speed-uplimit */
389      case 974: /* alt-speed-scheduler */
390      case 975: /* no-alt-speed-scheduler */
391      case 976: /* alt-speed-time-begin */
392      case 977: /* alt-speed-time-end */
393      case 978: /* alt-speed-days */
394      case 910: /* encryption-required */
395      case 911: /* encryption-preferred */
396      case 912: /* encryption-tolerated */
397      case 953: /* global-seedratio */
398      case 954: /* no-global-seedratio */
399      case 990: /* start-paused */
400      case 991: /* no-start-paused */
401      case 992: /* trash-torrent */
402      case 993: /* no-trash-torrent */
403        return MODE_SESSION_SET;
404
405      case 712: /* tracker-remove */
406      case 950: /* seedratio */
407      case 951: /* seedratio-default */
408      case 952: /* no-seedratio */
409      case 984: /* honor-session */
410      case 985: /* no-honor-session */
411        return MODE_TORRENT_SET;
412
413      case 920: /* session-info */
414        return MODE_SESSION_GET;
415
416      case 'g': /* get */
417      case 'G': /* no-get */
418      case 700: /* torrent priority-high */
419      case 701: /* torrent priority-normal */
420      case 702: /* torrent priority-low */
421      case 710: /* tracker-add */
422      case 900: /* file priority-high */
423      case 901: /* file priority-normal */
424      case 902: /* file priority-low */
425        return MODE_TORRENT_SET | MODE_TORRENT_ADD;
426
427      case 961: /* find */
428        return MODE_TORRENT_SET_LOCATION | MODE_TORRENT_ADD;
429
430      case 'i': /* info */
431      case 'l': /* list all torrents */
432      case 940: /* info-files */
433      case 941: /* info-peer */
434      case 942: /* info-pieces */
435      case 943: /* info-tracker */
436        return MODE_TORRENT_GET;
437
438      case 'd': /* download speed limit */
439      case 'D': /* no download speed limit */
440      case 'u': /* upload speed limit */
441      case 'U': /* no upload speed limit */
442      case 930: /* peers */
443        return MODE_SESSION_SET | MODE_TORRENT_SET;
444
445      case 's': /* start */
446        return MODE_TORRENT_START | MODE_TORRENT_ADD;
447
448      case 'S': /* stop */
449        return MODE_TORRENT_STOP | MODE_TORRENT_ADD;
450
451      case 'w': /* download-dir */
452        return MODE_SESSION_SET | MODE_TORRENT_ADD;
453
454      case 850: /* session-close */
455        return MODE_SESSION_CLOSE;
456
457      case 963: /* blocklist-update */
458        return MODE_BLOCKLIST_UPDATE;
459
460      case 921: /* session-stats */
461        return MODE_SESSION_STATS;
462
463      case 'v': /* verify */
464        return MODE_TORRENT_VERIFY;
465
466      case 600: /* reannounce */
467        return MODE_TORRENT_REANNOUNCE;
468
469      case 962: /* port-test */
470        return MODE_PORT_TEST;
471
472      case 'r': /* remove */
473      case 'R': /* remove and delete */
474        return MODE_TORRENT_REMOVE;
475
476      case 960: /* move */
477        return MODE_TORRENT_SET_LOCATION;
478
479      default:
480        fprintf (stderr, "unrecognized argument %d\n", val);
481        assert ("unrecognized argument" && 0);
482        return 0;
483    }
484}
485
486static bool debug = 0;
487static char * auth = NULL;
488static char * netrc = NULL;
489static char * sessionId = NULL;
490static bool UseSSL = false;
491
492static char*
493tr_getcwd (void)
494{
495  char * result;
496  tr_error * error = NULL;
497
498  result = tr_sys_dir_get_current (&error);
499
500  if (result == NULL)
501    {
502      fprintf (stderr, "getcwd error: \"%s\"", error->message);
503      tr_error_free (error);
504      result = tr_strdup ("");
505    }
506
507  return result;
508}
509
510static char*
511absolutify (const char * path)
512{
513  char * buf;
514
515  if (*path == '/')
516    {
517      buf = tr_strdup (path);
518    }
519  else
520    {
521      char * cwd = tr_getcwd ();
522      buf = tr_buildPath (cwd, path, NULL);
523      tr_free (cwd);
524    }
525
526  return buf;
527}
528
529static char*
530getEncodedMetainfo (const char * filename)
531{
532    size_t    len = 0;
533    char *    b64 = NULL;
534    uint8_t * buf = tr_loadFile (filename, &len);
535
536    if (buf)
537    {
538        b64 = tr_base64_encode (buf, len, NULL);
539        tr_free (buf);
540    }
541    return b64;
542}
543
544static void
545addIdArg (tr_variant * args, const char * id, const char * fallback)
546{
547  if (!id || !*id)
548    {
549      id = fallback;
550
551      if (!id || !*id)
552        {
553          fprintf (stderr, "No torrent specified!  Please use the -t option first.\n");
554          id = "-1"; /* no torrent will have this ID, so will act as a no-op */
555        }
556    }
557
558  if (!tr_strcmp0 (id, "active"))
559    {
560      tr_variantDictAddStr (args, TR_KEY_ids, "recently-active");
561    }
562  else if (strcmp (id, "all"))
563    {
564      const char * pch;
565      bool isList = strchr (id,',') || strchr (id,'-');
566      bool isNum = true;
567
568      for (pch=id; isNum && *pch; ++pch)
569        if (!isdigit (*pch))
570          isNum = false;
571
572      if (isNum || isList)
573        tr_rpc_parse_list_str (tr_variantDictAdd (args, TR_KEY_ids), id, strlen (id));
574      else
575        tr_variantDictAddStr (args, TR_KEY_ids, id); /* it's a torrent sha hash */
576    }
577}
578
579static void
580addTime (tr_variant * args, const tr_quark key, const char * arg)
581{
582    int time;
583    bool success = false;
584
585    if (arg && (strlen (arg) == 4))
586    {
587        const char hh[3] = { arg[0], arg[1], '\0' };
588        const char mm[3] = { arg[2], arg[3], '\0' };
589        const int hour = atoi (hh);
590        const int min = atoi (mm);
591
592        if (0<=hour && hour<24 && 0<=min && min<60)
593        {
594            time = min + (hour * 60);
595            success = true;
596        }
597    }
598
599    if (success)
600        tr_variantDictAddInt (args, key, time);
601    else
602        fprintf (stderr, "Please specify the time of day in 'hhmm' format.\n");
603}
604
605static void
606addDays (tr_variant * args, const tr_quark key, const char * arg)
607{
608  int days = 0;
609
610  if (arg)
611    {
612      int i;
613      int valueCount;
614      int * values;
615
616      values = tr_parseNumberRange (arg, -1, &valueCount);
617      for (i=0; i<valueCount; ++i)
618        {
619          if (values[i] < 0 || values[i] > 7)
620            continue;
621
622          if (values[i] == 7)
623            values[i] = 0;
624
625          days |= 1 << values[i];
626        }
627
628      tr_free (values);
629    }
630
631  if (days)
632    tr_variantDictAddInt (args, key, days);
633  else
634    fprintf (stderr, "Please specify the days of the week in '1-3,4,7' format.\n");
635}
636
637static void
638addFiles (tr_variant      * args,
639          const tr_quark    key,
640          const char      * arg)
641{
642  tr_variant * files = tr_variantDictAddList (args, key, 100);
643
644  if (!*arg)
645    {
646      fprintf (stderr, "No files specified!\n");
647      arg = "-1"; /* no file will have this index, so should be a no-op */
648    }
649
650  if (strcmp (arg, "all"))
651    {
652      int i;
653      int valueCount;
654      int * values = tr_parseNumberRange (arg, -1, &valueCount);
655
656      for (i=0; i<valueCount; ++i)
657        tr_variantListAddInt (files, values[i]);
658
659      tr_free (values);
660    }
661}
662
663#define TR_N_ELEMENTS(ary) (sizeof (ary) / sizeof (*ary))
664
665static const tr_quark files_keys[] = {
666    TR_KEY_files,
667    TR_KEY_name,
668    TR_KEY_priorities,
669    TR_KEY_wanted
670};
671
672static const tr_quark details_keys[] = {
673    TR_KEY_activityDate,
674    TR_KEY_addedDate,
675    TR_KEY_bandwidthPriority,
676    TR_KEY_comment,
677    TR_KEY_corruptEver,
678    TR_KEY_creator,
679    TR_KEY_dateCreated,
680    TR_KEY_desiredAvailable,
681    TR_KEY_doneDate,
682    TR_KEY_downloadDir,
683    TR_KEY_downloadedEver,
684    TR_KEY_downloadLimit,
685    TR_KEY_downloadLimited,
686    TR_KEY_error,
687    TR_KEY_errorString,
688    TR_KEY_eta,
689    TR_KEY_hashString,
690    TR_KEY_haveUnchecked,
691    TR_KEY_haveValid,
692    TR_KEY_honorsSessionLimits,
693    TR_KEY_id,
694    TR_KEY_isFinished,
695    TR_KEY_isPrivate,
696    TR_KEY_leftUntilDone,
697    TR_KEY_magnetLink,
698    TR_KEY_name,
699    TR_KEY_peersConnected,
700    TR_KEY_peersGettingFromUs,
701    TR_KEY_peersSendingToUs,
702    TR_KEY_peer_limit,
703    TR_KEY_pieceCount,
704    TR_KEY_pieceSize,
705    TR_KEY_rateDownload,
706    TR_KEY_rateUpload,
707    TR_KEY_recheckProgress,
708    TR_KEY_secondsDownloading,
709    TR_KEY_secondsSeeding,
710    TR_KEY_seedRatioMode,
711    TR_KEY_seedRatioLimit,
712    TR_KEY_sizeWhenDone,
713    TR_KEY_startDate,
714    TR_KEY_status,
715    TR_KEY_totalSize,
716    TR_KEY_uploadedEver,
717    TR_KEY_uploadLimit,
718    TR_KEY_uploadLimited,
719    TR_KEY_webseeds,
720    TR_KEY_webseedsSendingToUs
721};
722
723static const tr_quark list_keys[] = {
724    TR_KEY_error,
725    TR_KEY_errorString,
726    TR_KEY_eta,
727    TR_KEY_id,
728    TR_KEY_isFinished,
729    TR_KEY_leftUntilDone,
730    TR_KEY_name,
731    TR_KEY_peersGettingFromUs,
732    TR_KEY_peersSendingToUs,
733    TR_KEY_rateDownload,
734    TR_KEY_rateUpload,
735    TR_KEY_sizeWhenDone,
736    TR_KEY_status,
737    TR_KEY_uploadRatio
738};
739
740static size_t
741writeFunc (void * ptr, size_t size, size_t nmemb, void * buf)
742{
743    const size_t byteCount = size * nmemb;
744    evbuffer_add (buf, ptr, byteCount);
745    return byteCount;
746}
747
748/* look for a session id in the header in case the server gives back a 409 */
749static size_t
750parseResponseHeader (void *ptr, size_t size, size_t nmemb, void * stream UNUSED)
751{
752    const char * line = ptr;
753    const size_t line_len = size * nmemb;
754    const char * key = TR_RPC_SESSION_ID_HEADER ": ";
755    const size_t key_len = strlen (key);
756
757    if ((line_len >= key_len) && !memcmp (line, key, key_len))
758    {
759        const char * begin = line + key_len;
760        const char * end = begin;
761        while (!isspace (*end))
762            ++end;
763        tr_free (sessionId);
764        sessionId = tr_strndup (begin, end-begin);
765    }
766
767    return line_len;
768}
769
770static long
771getTimeoutSecs (const char * req)
772{
773  if (strstr (req, "\"method\":\"blocklist-update\"") != NULL)
774    return 300L;
775
776  return 60L; /* default value */
777}
778
779static char*
780getStatusString (tr_variant * t, char * buf, size_t buflen)
781{
782    int64_t status;
783    bool boolVal;
784
785    if (!tr_variantDictFindInt (t, TR_KEY_status, &status))
786    {
787        *buf = '\0';
788    }
789    else switch (status)
790    {
791        case TR_STATUS_DOWNLOAD_WAIT:
792        case TR_STATUS_SEED_WAIT:
793            tr_strlcpy (buf, "Queued", buflen);
794            break;
795
796        case TR_STATUS_STOPPED:
797            if (tr_variantDictFindBool (t, TR_KEY_isFinished, &boolVal) && boolVal)
798                tr_strlcpy (buf, "Finished", buflen);
799            else
800                tr_strlcpy (buf, "Stopped", buflen);
801            break;
802
803        case TR_STATUS_CHECK_WAIT:
804        case TR_STATUS_CHECK: {
805            const char * str = status == TR_STATUS_CHECK_WAIT
806                             ? "Will Verify"
807                             : "Verifying";
808            double percent;
809            if (tr_variantDictFindReal (t, TR_KEY_recheckProgress, &percent))
810                tr_snprintf (buf, buflen, "%s (%.0f%%)", str, floor (percent*100.0));
811            else
812                tr_strlcpy (buf, str, buflen);
813
814            break;
815        }
816
817        case TR_STATUS_DOWNLOAD:
818        case TR_STATUS_SEED: {
819            int64_t fromUs = 0;
820            int64_t toUs = 0;
821            tr_variantDictFindInt (t, TR_KEY_peersGettingFromUs, &fromUs);
822            tr_variantDictFindInt (t, TR_KEY_peersSendingToUs, &toUs);
823            if (fromUs && toUs)
824                tr_strlcpy (buf, "Up & Down", buflen);
825            else if (toUs)
826                tr_strlcpy (buf, "Downloading", buflen);
827            else if (fromUs) {
828                int64_t leftUntilDone = 0;
829                tr_variantDictFindInt (t, TR_KEY_leftUntilDone, &leftUntilDone);
830                if (leftUntilDone > 0)
831                    tr_strlcpy (buf, "Uploading", buflen);
832                else
833                    tr_strlcpy (buf, "Seeding", buflen);
834            } else {
835                tr_strlcpy (buf, "Idle", buflen);
836            }
837            break;
838        }
839
840        default:
841            tr_strlcpy (buf, "Unknown", buflen);
842            break;
843    }
844
845    return buf;
846}
847
848static const char *bandwidthPriorityNames[] =
849    { "Low", "Normal", "High", "Invalid" };
850
851static void
852printDetails (tr_variant * top)
853{
854    tr_variant *args, *torrents;
855
856    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args))
857      && (tr_variantDictFindList (args, TR_KEY_torrents, &torrents)))
858    {
859        int ti, tCount;
860        for (ti = 0, tCount = tr_variantListSize (torrents); ti < tCount;
861             ++ti)
862        {
863            tr_variant *    t = tr_variantListChild (torrents, ti);
864            tr_variant *    l;
865            const char * str;
866            char         buf[512];
867            char         buf2[512];
868            int64_t      i, j, k;
869            bool      boolVal;
870            double       d;
871
872            printf ("NAME\n");
873            if (tr_variantDictFindInt (t, TR_KEY_id, &i))
874                printf ("  Id: %" PRId64 "\n", i);
875            if (tr_variantDictFindStr (t, TR_KEY_name, &str, NULL))
876                printf ("  Name: %s\n", str);
877            if (tr_variantDictFindStr (t, TR_KEY_hashString, &str, NULL))
878                printf ("  Hash: %s\n", str);
879            if (tr_variantDictFindStr (t, TR_KEY_magnetLink, &str, NULL))
880                printf ("  Magnet: %s\n", str);
881            printf ("\n");
882
883            printf ("TRANSFER\n");
884            getStatusString (t, buf, sizeof (buf));
885            printf ("  State: %s\n", buf);
886
887            if (tr_variantDictFindStr (t, TR_KEY_downloadDir, &str, NULL))
888                printf ("  Location: %s\n", str);
889
890            if (tr_variantDictFindInt (t, TR_KEY_sizeWhenDone, &i)
891              && tr_variantDictFindInt (t, TR_KEY_leftUntilDone, &j))
892            {
893                strlpercent (buf, 100.0 * (i - j) / i, sizeof (buf));
894                printf ("  Percent Done: %s%%\n", buf);
895            }
896
897            if (tr_variantDictFindInt (t, TR_KEY_eta, &i))
898                printf ("  ETA: %s\n", tr_strltime (buf, i, sizeof (buf)));
899            if (tr_variantDictFindInt (t, TR_KEY_rateDownload, &i))
900                printf ("  Download Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
901            if (tr_variantDictFindInt (t, TR_KEY_rateUpload, &i))
902                printf ("  Upload Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
903            if (tr_variantDictFindInt (t, TR_KEY_haveUnchecked, &i)
904              && tr_variantDictFindInt (t, TR_KEY_haveValid, &j))
905            {
906                strlsize (buf, i + j, sizeof (buf));
907                strlsize (buf2, j, sizeof (buf2));
908                printf ("  Have: %s (%s verified)\n", buf, buf2);
909            }
910
911            if (tr_variantDictFindInt (t, TR_KEY_sizeWhenDone, &i))
912            {
913                if (i < 1)
914                    printf ("  Availability: None\n");
915                if (tr_variantDictFindInt (t, TR_KEY_desiredAvailable, &j)
916                    && tr_variantDictFindInt (t, TR_KEY_leftUntilDone, &k))
917                {
918                    j += i - k;
919                    strlpercent (buf, 100.0 * j / i, sizeof (buf));
920                    printf ("  Availability: %s%%\n", buf);
921                }
922                if (tr_variantDictFindInt (t, TR_KEY_totalSize, &j))
923                {
924                    strlsize (buf2, i, sizeof (buf2));
925                    strlsize (buf, j, sizeof (buf));
926                    printf ("  Total size: %s (%s wanted)\n", buf, buf2);
927                }
928            }
929            if (tr_variantDictFindInt (t, TR_KEY_downloadedEver, &i)
930              && tr_variantDictFindInt (t, TR_KEY_uploadedEver, &j))
931            {
932                strlsize (buf, i, sizeof (buf));
933                printf ("  Downloaded: %s\n", buf);
934                strlsize (buf, j, sizeof (buf));
935                printf ("  Uploaded: %s\n", buf);
936                strlratio (buf, j, i, sizeof (buf));
937                printf ("  Ratio: %s\n", buf);
938            }
939            if (tr_variantDictFindInt (t, TR_KEY_corruptEver, &i))
940            {
941                strlsize (buf, i, sizeof (buf));
942                printf ("  Corrupt DL: %s\n", buf);
943            }
944            if (tr_variantDictFindStr (t, TR_KEY_errorString, &str, NULL) && str && *str &&
945                tr_variantDictFindInt (t, TR_KEY_error, &i) && i)
946            {
947                switch (i) {
948                    case TR_STAT_TRACKER_WARNING: printf ("  Tracker gave a warning: %s\n", str); break;
949                    case TR_STAT_TRACKER_ERROR:   printf ("  Tracker gave an error: %s\n", str); break;
950                    case TR_STAT_LOCAL_ERROR:     printf ("  Error: %s\n", str); break;
951                    default: break; /* no error */
952                }
953            }
954            if (tr_variantDictFindInt (t, TR_KEY_peersConnected, &i)
955              && tr_variantDictFindInt (t, TR_KEY_peersGettingFromUs, &j)
956              && tr_variantDictFindInt (t, TR_KEY_peersSendingToUs, &k))
957            {
958                printf (
959                    "  Peers: "
960                    "connected to %" PRId64 ", "
961                                            "uploading to %" PRId64
962                    ", "
963                    "downloading from %"
964                    PRId64 "\n",
965                    i, j, k);
966            }
967
968            if (tr_variantDictFindList (t, TR_KEY_webseeds, &l)
969              && tr_variantDictFindInt (t, TR_KEY_webseedsSendingToUs, &i))
970            {
971                const int64_t n = tr_variantListSize (l);
972                if (n > 0)
973                    printf (
974                        "  Web Seeds: downloading from %" PRId64 " of %"
975                        PRId64
976                        " web seeds\n", i, n);
977            }
978            printf ("\n");
979
980            printf ("HISTORY\n");
981            if (tr_variantDictFindInt (t, TR_KEY_addedDate, &i) && i)
982            {
983                const time_t tt = i;
984                printf ("  Date added:       %s", ctime (&tt));
985            }
986            if (tr_variantDictFindInt (t, TR_KEY_doneDate, &i) && i)
987            {
988                const time_t tt = i;
989                printf ("  Date finished:    %s", ctime (&tt));
990            }
991            if (tr_variantDictFindInt (t, TR_KEY_startDate, &i) && i)
992            {
993                const time_t tt = i;
994                printf ("  Date started:     %s", ctime (&tt));
995            }
996            if (tr_variantDictFindInt (t, TR_KEY_activityDate, &i) && i)
997            {
998                const time_t tt = i;
999                printf ("  Latest activity:  %s", ctime (&tt));
1000            }
1001            if (tr_variantDictFindInt (t, TR_KEY_secondsDownloading, &i) && (i > 0))
1002                printf ("  Downloading Time: %s\n", tr_strltime (buf, i, sizeof (buf)));
1003            if (tr_variantDictFindInt (t, TR_KEY_secondsSeeding, &i) && (i > 0))
1004                printf ("  Seeding Time:     %s\n", tr_strltime (buf, i, sizeof (buf)));
1005            printf ("\n");
1006
1007            printf ("ORIGINS\n");
1008            if (tr_variantDictFindInt (t, TR_KEY_dateCreated, &i) && i)
1009            {
1010                const time_t tt = i;
1011                printf ("  Date created: %s", ctime (&tt));
1012            }
1013            if (tr_variantDictFindBool (t, TR_KEY_isPrivate, &boolVal))
1014                printf ("  Public torrent: %s\n", (boolVal ? "No" : "Yes"));
1015            if (tr_variantDictFindStr (t, TR_KEY_comment, &str, NULL) && str && *str)
1016                printf ("  Comment: %s\n", str);
1017            if (tr_variantDictFindStr (t, TR_KEY_creator, &str, NULL) && str && *str)
1018                printf ("  Creator: %s\n", str);
1019            if (tr_variantDictFindInt (t, TR_KEY_pieceCount, &i))
1020                printf ("  Piece Count: %" PRId64 "\n", i);
1021            if (tr_variantDictFindInt (t, TR_KEY_pieceSize, &i))
1022                printf ("  Piece Size: %s\n", strlmem (buf, i, sizeof (buf)));
1023            printf ("\n");
1024
1025            printf ("LIMITS & BANDWIDTH\n");
1026            if (tr_variantDictFindBool (t, TR_KEY_downloadLimited, &boolVal)
1027                && tr_variantDictFindInt (t, TR_KEY_downloadLimit, &i))
1028            {
1029                printf ("  Download Limit: ");
1030                if (boolVal)
1031                    printf ("%s\n", tr_formatter_speed_KBps (buf, i, sizeof (buf)));
1032                else
1033                    printf ("Unlimited\n");
1034            }
1035            if (tr_variantDictFindBool (t, TR_KEY_uploadLimited, &boolVal)
1036                && tr_variantDictFindInt (t, TR_KEY_uploadLimit, &i))
1037            {
1038                printf ("  Upload Limit: ");
1039                if (boolVal)
1040                    printf ("%s\n", tr_formatter_speed_KBps (buf, i, sizeof (buf)));
1041                else
1042                    printf ("Unlimited\n");
1043            }
1044            if (tr_variantDictFindInt (t, TR_KEY_seedRatioMode, &i))
1045            {
1046                switch (i) {
1047                    case TR_RATIOLIMIT_GLOBAL:
1048                        printf ("  Ratio Limit: Default\n");
1049                        break;
1050                    case TR_RATIOLIMIT_SINGLE:
1051                        if (tr_variantDictFindReal (t, TR_KEY_seedRatioLimit, &d))
1052                            printf ("  Ratio Limit: %s\n", strlratio2 (buf, d, sizeof(buf)));
1053                        break;
1054                    case TR_RATIOLIMIT_UNLIMITED:
1055                        printf ("  Ratio Limit: Unlimited\n");
1056                        break;
1057                    default: break;
1058                }
1059            }
1060            if (tr_variantDictFindBool (t, TR_KEY_honorsSessionLimits, &boolVal))
1061                printf ("  Honors Session Limits: %s\n", (boolVal ? "Yes" : "No"));
1062            if (tr_variantDictFindInt (t, TR_KEY_peer_limit, &i))
1063                printf ("  Peer limit: %" PRId64 "\n", i);
1064            if (tr_variantDictFindInt (t, TR_KEY_bandwidthPriority, &i))
1065                printf ("  Bandwidth Priority: %s\n",
1066                        bandwidthPriorityNames[ (i + 1) & 3]);
1067
1068            printf ("\n");
1069        }
1070    }
1071}
1072
1073static void
1074printFileList (tr_variant * top)
1075{
1076    tr_variant *args, *torrents;
1077
1078    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args))
1079      && (tr_variantDictFindList (args, TR_KEY_torrents, &torrents)))
1080    {
1081        int i, in;
1082        for (i = 0, in = tr_variantListSize (torrents); i < in; ++i)
1083        {
1084            tr_variant *    d = tr_variantListChild (torrents, i);
1085            tr_variant *    files, *priorities, *wanteds;
1086            const char * name;
1087            if (tr_variantDictFindStr (d, TR_KEY_name, &name, NULL)
1088              && tr_variantDictFindList (d, TR_KEY_files, &files)
1089              && tr_variantDictFindList (d, TR_KEY_priorities, &priorities)
1090              && tr_variantDictFindList (d, TR_KEY_wanted, &wanteds))
1091            {
1092                int j = 0, jn = tr_variantListSize (files);
1093                printf ("%s (%d files):\n", name, jn);
1094                printf ("%3s  %4s %8s %3s %9s  %s\n", "#", "Done",
1095                        "Priority", "Get", "Size",
1096                        "Name");
1097                for (j = 0, jn = tr_variantListSize (files); j < jn; ++j)
1098                {
1099                    int64_t      have;
1100                    int64_t      length;
1101                    int64_t      priority;
1102                    int64_t      wanted;
1103                    const char * filename;
1104                    tr_variant *    file = tr_variantListChild (files, j);
1105                    if (tr_variantDictFindInt (file, TR_KEY_length, &length)
1106                      && tr_variantDictFindStr (file, TR_KEY_name, &filename, NULL)
1107                      && tr_variantDictFindInt (file, TR_KEY_bytesCompleted, &have)
1108                      && tr_variantGetInt (tr_variantListChild (priorities, j), &priority)
1109                      && tr_variantGetInt (tr_variantListChild (wanteds, j), &wanted))
1110                    {
1111                        char         sizestr[64];
1112                        double       percent = (double)have / length;
1113                        const char * pristr;
1114                        strlsize (sizestr, length, sizeof (sizestr));
1115                        switch (priority)
1116                        {
1117                            case TR_PRI_LOW:
1118                                pristr = "Low"; break;
1119
1120                            case TR_PRI_HIGH:
1121                                pristr = "High"; break;
1122
1123                            default:
1124                                pristr = "Normal"; break;
1125                        }
1126                        printf ("%3d: %3.0f%% %-8s %-3s %9s  %s\n",
1127                                j,
1128                                floor (100.0 * percent),
1129                                pristr,
1130                              (wanted ? "Yes" : "No"),
1131                                sizestr,
1132                                filename);
1133                    }
1134                }
1135            }
1136        }
1137    }
1138}
1139
1140static void
1141printPeersImpl (tr_variant * peers)
1142{
1143  int i, n;
1144  printf ("%-20s  %-12s  %-5s %-6s  %-6s  %s\n",
1145          "Address", "Flags", "Done", "Down", "Up", "Client");
1146
1147  for (i=0, n=tr_variantListSize(peers); i<n; ++i)
1148    {
1149      double progress;
1150      const char * address, * client, * flagstr;
1151      int64_t rateToClient, rateToPeer;
1152      tr_variant * d = tr_variantListChild (peers, i);
1153
1154      if  (tr_variantDictFindStr  (d, TR_KEY_address, &address, NULL)
1155        && tr_variantDictFindStr  (d, TR_KEY_clientName, &client, NULL)
1156        && tr_variantDictFindReal (d, TR_KEY_progress, &progress)
1157        && tr_variantDictFindStr  (d, TR_KEY_flagStr, &flagstr, NULL)
1158        && tr_variantDictFindInt  (d, TR_KEY_rateToClient, &rateToClient)
1159        && tr_variantDictFindInt  (d, TR_KEY_rateToPeer, &rateToPeer))
1160        {
1161          printf ("%-20s  %-12s  %-5.1f %6.1f  %6.1f  %s\n",
1162                  address, flagstr, (progress*100.0),
1163                  rateToClient / (double)tr_speed_K,
1164                  rateToPeer / (double)tr_speed_K,
1165                  client);
1166        }
1167    }
1168}
1169
1170static void
1171printPeers (tr_variant * top)
1172{
1173  tr_variant *args, *torrents;
1174
1175  if (tr_variantDictFindDict (top, TR_KEY_arguments, &args)
1176      && tr_variantDictFindList (args, TR_KEY_torrents, &torrents))
1177    {
1178      int i, n;
1179      for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
1180        {
1181          tr_variant * peers;
1182          tr_variant * torrent = tr_variantListChild (torrents, i);
1183          if (tr_variantDictFindList (torrent, TR_KEY_peers, &peers))
1184            {
1185              printPeersImpl (peers);
1186              if (i+1<n)
1187                printf ("\n");
1188            }
1189        }
1190    }
1191}
1192
1193static void
1194printPiecesImpl (const uint8_t * raw, size_t rawlen, int64_t j)
1195{
1196    int i, k, len;
1197    char * str = tr_base64_decode (raw, rawlen, &len);
1198    printf ("  ");
1199    for (i=k=0; k<len; ++k) {
1200        int e;
1201        for (e=0; i<j && e<8; ++e, ++i)
1202            printf ("%c", str[k] & (1<< (7-e)) ? '1' : '0');
1203        printf (" ");
1204        if (! (i%64))
1205            printf ("\n  ");
1206    }
1207    printf ("\n");
1208    tr_free (str);
1209}
1210
1211static void
1212printPieces (tr_variant * top)
1213{
1214    tr_variant *args, *torrents;
1215
1216    if (tr_variantDictFindDict (top, TR_KEY_arguments, &args)
1217      && tr_variantDictFindList (args, TR_KEY_torrents, &torrents))
1218    {
1219        int i, n;
1220        for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
1221        {
1222            int64_t j;
1223            const uint8_t * raw;
1224            size_t       rawlen;
1225            tr_variant * torrent = tr_variantListChild (torrents, i);
1226            if (tr_variantDictFindRaw (torrent, TR_KEY_pieces, &raw, &rawlen) &&
1227                tr_variantDictFindInt (torrent, TR_KEY_pieceCount, &j)) {
1228                printPiecesImpl (raw, rawlen, j);
1229                if (i+1<n)
1230                    printf ("\n");
1231            }
1232        }
1233    }
1234}
1235
1236static void
1237printPortTest (tr_variant * top)
1238{
1239    tr_variant *args;
1240    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args)))
1241    {
1242        bool      boolVal;
1243
1244        if (tr_variantDictFindBool (args, TR_KEY_port_is_open, &boolVal))
1245            printf ("Port is open: %s\n", (boolVal ? "Yes" : "No"));
1246    }
1247}
1248
1249static void
1250printTorrentList (tr_variant * top)
1251{
1252    tr_variant *args, *list;
1253
1254    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args))
1255      && (tr_variantDictFindList (args, TR_KEY_torrents, &list)))
1256    {
1257        int i, n;
1258        int64_t total_size=0;
1259        double total_up=0, total_down=0;
1260        char haveStr[32];
1261
1262        printf ("%-4s   %-4s  %9s  %-8s  %6s  %6s  %-5s  %-11s  %s\n",
1263                "ID", "Done", "Have", "ETA", "Up", "Down", "Ratio", "Status",
1264                "Name");
1265
1266        for (i = 0, n = tr_variantListSize (list); i < n; ++i)
1267        {
1268            int64_t      id, eta, status, up, down;
1269            int64_t      sizeWhenDone, leftUntilDone;
1270            double       ratio;
1271            const char * name;
1272            tr_variant *   d = tr_variantListChild (list, i);
1273            if  (tr_variantDictFindInt  (d, TR_KEY_eta, &eta)
1274              && tr_variantDictFindInt  (d, TR_KEY_id, &id)
1275              && tr_variantDictFindInt  (d, TR_KEY_leftUntilDone, &leftUntilDone)
1276              && tr_variantDictFindStr  (d, TR_KEY_name, &name, NULL)
1277              && tr_variantDictFindInt  (d, TR_KEY_rateDownload, &down)
1278              && tr_variantDictFindInt  (d, TR_KEY_rateUpload, &up)
1279              && tr_variantDictFindInt  (d, TR_KEY_sizeWhenDone, &sizeWhenDone)
1280              && tr_variantDictFindInt  (d, TR_KEY_status, &status)
1281              && tr_variantDictFindReal (d, TR_KEY_uploadRatio, &ratio))
1282            {
1283                char etaStr[16];
1284                char statusStr[64];
1285                char ratioStr[32];
1286                char doneStr[8];
1287                int64_t error;
1288                char errorMark;
1289
1290                if (sizeWhenDone)
1291                    tr_snprintf (doneStr, sizeof (doneStr), "%d%%", (int)(100.0 * (sizeWhenDone - leftUntilDone) / sizeWhenDone));
1292                else
1293                    tr_strlcpy (doneStr, "n/a", sizeof (doneStr));
1294
1295                strlsize (haveStr, sizeWhenDone - leftUntilDone, sizeof (haveStr));
1296
1297                if (leftUntilDone || eta != -1)
1298                    etaToString (etaStr, sizeof (etaStr), eta);
1299                else
1300                    tr_snprintf (etaStr, sizeof (etaStr), "Done");
1301                if (tr_variantDictFindInt (d, TR_KEY_error, &error) && error)
1302                    errorMark = '*';
1303                else
1304                    errorMark = ' ';
1305                printf (
1306                    "%4d%c  %4s  %9s  %-8s  %6.1f  %6.1f  %5s  %-11s  %s\n",
1307                  (int)id, errorMark,
1308                    doneStr,
1309                    haveStr,
1310                    etaStr,
1311                    up/ (double)tr_speed_K,
1312                    down/ (double)tr_speed_K,
1313                    strlratio2 (ratioStr, ratio, sizeof (ratioStr)),
1314                    getStatusString (d, statusStr, sizeof (statusStr)),
1315                    name);
1316
1317                total_up += up;
1318                total_down += down;
1319                total_size += sizeWhenDone - leftUntilDone;
1320            }
1321        }
1322
1323        printf ("Sum:         %9s            %6.1f  %6.1f\n",
1324                strlsize (haveStr, total_size, sizeof (haveStr)),
1325                total_up/ (double)tr_speed_K,
1326                total_down/ (double)tr_speed_K);
1327    }
1328}
1329
1330static void
1331printTrackersImpl (tr_variant * trackerStats)
1332{
1333    int i;
1334    char         buf[512];
1335    tr_variant * t;
1336
1337    for (i=0; ((t = tr_variantListChild (trackerStats, i))); ++i)
1338    {
1339        int64_t downloadCount;
1340        bool hasAnnounced;
1341        bool hasScraped;
1342        const char * host;
1343        int64_t id;
1344        bool isBackup;
1345        int64_t lastAnnouncePeerCount;
1346        const char * lastAnnounceResult;
1347        int64_t lastAnnounceStartTime;
1348        bool lastAnnounceSucceeded;
1349        int64_t lastAnnounceTime;
1350        bool lastAnnounceTimedOut;
1351        const char * lastScrapeResult;
1352        bool lastScrapeSucceeded;
1353        int64_t lastScrapeStartTime;
1354        int64_t lastScrapeTime;
1355        bool lastScrapeTimedOut;
1356        int64_t leecherCount;
1357        int64_t nextAnnounceTime;
1358        int64_t nextScrapeTime;
1359        int64_t seederCount;
1360        int64_t tier;
1361        int64_t announceState;
1362        int64_t scrapeState;
1363
1364        if (tr_variantDictFindInt  (t, TR_KEY_downloadCount, &downloadCount) &&
1365            tr_variantDictFindBool (t, TR_KEY_hasAnnounced, &hasAnnounced) &&
1366            tr_variantDictFindBool (t, TR_KEY_hasScraped, &hasScraped) &&
1367            tr_variantDictFindStr  (t, TR_KEY_host, &host, NULL) &&
1368            tr_variantDictFindInt  (t, TR_KEY_id, &id) &&
1369            tr_variantDictFindBool (t, TR_KEY_isBackup, &isBackup) &&
1370            tr_variantDictFindInt  (t, TR_KEY_announceState, &announceState) &&
1371            tr_variantDictFindInt  (t, TR_KEY_scrapeState, &scrapeState) &&
1372            tr_variantDictFindInt  (t, TR_KEY_lastAnnouncePeerCount, &lastAnnouncePeerCount) &&
1373            tr_variantDictFindStr  (t, TR_KEY_lastAnnounceResult, &lastAnnounceResult, NULL) &&
1374            tr_variantDictFindInt  (t, TR_KEY_lastAnnounceStartTime, &lastAnnounceStartTime) &&
1375            tr_variantDictFindBool (t, TR_KEY_lastAnnounceSucceeded, &lastAnnounceSucceeded) &&
1376            tr_variantDictFindInt  (t, TR_KEY_lastAnnounceTime, &lastAnnounceTime) &&
1377            tr_variantDictFindBool (t, TR_KEY_lastAnnounceTimedOut, &lastAnnounceTimedOut) &&
1378            tr_variantDictFindStr  (t, TR_KEY_lastScrapeResult, &lastScrapeResult, NULL) &&
1379            tr_variantDictFindInt  (t, TR_KEY_lastScrapeStartTime, &lastScrapeStartTime) &&
1380            tr_variantDictFindBool (t, TR_KEY_lastScrapeSucceeded, &lastScrapeSucceeded) &&
1381            tr_variantDictFindInt  (t, TR_KEY_lastScrapeTime, &lastScrapeTime) &&
1382            tr_variantDictFindBool (t, TR_KEY_lastScrapeTimedOut, &lastScrapeTimedOut) &&
1383            tr_variantDictFindInt  (t, TR_KEY_leecherCount, &leecherCount) &&
1384            tr_variantDictFindInt  (t, TR_KEY_nextAnnounceTime, &nextAnnounceTime) &&
1385            tr_variantDictFindInt  (t, TR_KEY_nextScrapeTime, &nextScrapeTime) &&
1386            tr_variantDictFindInt  (t, TR_KEY_seederCount, &seederCount) &&
1387            tr_variantDictFindInt  (t, TR_KEY_tier, &tier))
1388        {
1389            const time_t now = time (NULL);
1390
1391            printf ("\n");
1392            printf ("  Tracker %d: %s\n", (int)(id), host);
1393            if (isBackup)
1394                printf ("  Backup on tier %d\n", (int)tier);
1395            else
1396                printf ("  Active in tier %d\n", (int)tier);
1397
1398            if (!isBackup)
1399            {
1400                if (hasAnnounced && announceState != TR_TRACKER_INACTIVE)
1401                {
1402                    tr_strltime (buf, now - lastAnnounceTime, sizeof (buf));
1403                    if (lastAnnounceSucceeded)
1404                        printf ("  Got a list of %d peers %s ago\n",
1405                              (int)lastAnnouncePeerCount, buf);
1406                    else if (lastAnnounceTimedOut)
1407                        printf ("  Peer list request timed out; will retry\n");
1408                    else
1409                        printf ("  Got an error \"%s\" %s ago\n",
1410                                lastAnnounceResult, buf);
1411                }
1412
1413                switch (announceState)
1414                {
1415                    case TR_TRACKER_INACTIVE:
1416                        printf ("  No updates scheduled\n");
1417                        break;
1418                    case TR_TRACKER_WAITING:
1419                        tr_strltime (buf, nextAnnounceTime - now, sizeof (buf));
1420                        printf ("  Asking for more peers in %s\n", buf);
1421                        break;
1422                    case TR_TRACKER_QUEUED:
1423                        printf ("  Queued to ask for more peers\n");
1424                        break;
1425                    case TR_TRACKER_ACTIVE:
1426                        tr_strltime (buf, now - lastAnnounceStartTime, sizeof (buf));
1427                        printf ("  Asking for more peers now... %s\n", buf);
1428                        break;
1429                }
1430
1431                if (hasScraped)
1432                {
1433                    tr_strltime (buf, now - lastScrapeTime, sizeof (buf));
1434                    if (lastScrapeSucceeded)
1435                        printf ("  Tracker had %d seeders and %d leechers %s ago\n",
1436                              (int)seederCount, (int)leecherCount, buf);
1437                    else if (lastScrapeTimedOut)
1438                        printf ("  Tracker scrape timed out; will retry\n");
1439                    else
1440                        printf ("  Got a scrape error \"%s\" %s ago\n",
1441                                lastScrapeResult, buf);
1442                }
1443
1444                switch (scrapeState)
1445                {
1446                    case TR_TRACKER_INACTIVE:
1447                        break;
1448                    case TR_TRACKER_WAITING:
1449                        tr_strltime (buf, nextScrapeTime - now, sizeof (buf));
1450                        printf ("  Asking for peer counts in %s\n", buf);
1451                        break;
1452                    case TR_TRACKER_QUEUED:
1453                        printf ("  Queued to ask for peer counts\n");
1454                        break;
1455                    case TR_TRACKER_ACTIVE:
1456                        tr_strltime (buf, now - lastScrapeStartTime, sizeof (buf));
1457                        printf ("  Asking for peer counts now... %s\n", buf);
1458                        break;
1459                }
1460            }
1461        }
1462    }
1463}
1464
1465static void
1466printTrackers (tr_variant * top)
1467{
1468  tr_variant *args, *torrents;
1469
1470  if (tr_variantDictFindDict (top, TR_KEY_arguments, &args)
1471      && tr_variantDictFindList (args, TR_KEY_torrents, &torrents))
1472    {
1473      int i, n;
1474      for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
1475        {
1476          tr_variant * trackerStats;
1477          tr_variant * torrent = tr_variantListChild (torrents, i);
1478
1479          if (tr_variantDictFindList (torrent, TR_KEY_trackerStats, &trackerStats))
1480            {
1481              printTrackersImpl (trackerStats);
1482
1483              if (i+1<n)
1484                printf ("\n");
1485            }
1486        }
1487    }
1488}
1489
1490static void
1491printSession (tr_variant * top)
1492{
1493  tr_variant *args;
1494  if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args)))
1495    {
1496      int64_t i;
1497      char buf[64];
1498      bool boolVal;
1499      const char * str;
1500
1501      printf ("VERSION\n");
1502      if (tr_variantDictFindStr (args, TR_KEY_version, &str, NULL))
1503        printf ("  Daemon version: %s\n", str);
1504      if (tr_variantDictFindInt (args, TR_KEY_rpc_version, &i))
1505        printf ("  RPC version: %" PRId64 "\n", i);
1506      if (tr_variantDictFindInt (args, TR_KEY_rpc_version_minimum, &i))
1507        printf ("  RPC minimum version: %" PRId64 "\n", i);
1508      printf ("\n");
1509
1510      printf ("CONFIG\n");
1511      if (tr_variantDictFindStr (args, TR_KEY_config_dir, &str, NULL))
1512        printf ("  Configuration directory: %s\n", str);
1513      if (tr_variantDictFindStr (args,  TR_KEY_download_dir, &str, NULL))
1514        printf ("  Download directory: %s\n", str);
1515      if (tr_variantDictFindInt (args, TR_KEY_peer_port, &i))
1516        printf ("  Listenport: %" PRId64 "\n", i);
1517      if (tr_variantDictFindBool (args, TR_KEY_port_forwarding_enabled, &boolVal))
1518        printf ("  Portforwarding enabled: %s\n", (boolVal ? "Yes" : "No"));
1519      if (tr_variantDictFindBool (args, TR_KEY_utp_enabled, &boolVal))
1520        printf ("  uTP enabled: %s\n", (boolVal ? "Yes" : "No"));
1521      if (tr_variantDictFindBool (args, TR_KEY_dht_enabled, &boolVal))
1522        printf ("  Distributed hash table enabled: %s\n", (boolVal ? "Yes" : "No"));
1523      if (tr_variantDictFindBool (args, TR_KEY_lpd_enabled, &boolVal))
1524        printf ("  Local peer discovery enabled: %s\n", (boolVal ? "Yes" : "No"));
1525      if (tr_variantDictFindBool (args, TR_KEY_pex_enabled, &boolVal))
1526        printf ("  Peer exchange allowed: %s\n", (boolVal ? "Yes" : "No"));
1527      if (tr_variantDictFindStr (args,  TR_KEY_encryption, &str, NULL))
1528        printf ("  Encryption: %s\n", str);
1529      if (tr_variantDictFindInt (args, TR_KEY_cache_size_mb, &i))
1530        printf ("  Maximum memory cache size: %s\n", tr_formatter_mem_MB (buf, i, sizeof (buf)));
1531      printf ("\n");
1532
1533        {
1534            bool altEnabled, altTimeEnabled, upEnabled, downEnabled, seedRatioLimited;
1535            int64_t altDown, altUp, altBegin, altEnd, altDay, upLimit, downLimit, peerLimit;
1536            double seedRatioLimit;
1537
1538            if (tr_variantDictFindInt  (args, TR_KEY_alt_speed_down, &altDown) &&
1539                tr_variantDictFindBool (args, TR_KEY_alt_speed_enabled, &altEnabled) &&
1540                tr_variantDictFindInt  (args, TR_KEY_alt_speed_time_begin, &altBegin) &&
1541                tr_variantDictFindBool (args, TR_KEY_alt_speed_time_enabled, &altTimeEnabled) &&
1542                tr_variantDictFindInt  (args, TR_KEY_alt_speed_time_end, &altEnd) &&
1543                tr_variantDictFindInt  (args, TR_KEY_alt_speed_time_day, &altDay) &&
1544                tr_variantDictFindInt  (args, TR_KEY_alt_speed_up, &altUp) &&
1545                tr_variantDictFindInt  (args, TR_KEY_peer_limit_global, &peerLimit) &&
1546                tr_variantDictFindInt  (args, TR_KEY_speed_limit_down, &downLimit) &&
1547                tr_variantDictFindBool (args, TR_KEY_speed_limit_down_enabled, &downEnabled) &&
1548                tr_variantDictFindInt  (args, TR_KEY_speed_limit_up, &upLimit) &&
1549                tr_variantDictFindBool (args, TR_KEY_speed_limit_up_enabled, &upEnabled) &&
1550                tr_variantDictFindReal (args, TR_KEY_seedRatioLimit, &seedRatioLimit) &&
1551                tr_variantDictFindBool (args, TR_KEY_seedRatioLimited, &seedRatioLimited))
1552            {
1553                char buf[128];
1554                char buf2[128];
1555                char buf3[128];
1556
1557                printf ("LIMITS\n");
1558                printf ("  Peer limit: %" PRId64 "\n", peerLimit);
1559
1560                if (seedRatioLimited)
1561                    strlratio2 (buf, seedRatioLimit, sizeof(buf));
1562                else
1563                    tr_strlcpy (buf, "Unlimited", sizeof (buf));
1564                printf ("  Default seed ratio limit: %s\n", buf);
1565
1566                if (altEnabled)
1567                    tr_formatter_speed_KBps (buf, altUp, sizeof (buf));
1568                else if (upEnabled)
1569                    tr_formatter_speed_KBps (buf, upLimit, sizeof (buf));
1570                else
1571                    tr_strlcpy (buf, "Unlimited", sizeof (buf));
1572                printf ("  Upload speed limit: %s (%s limit: %s; %s turtle limit: %s)\n",
1573                        buf,
1574                        upEnabled ? "Enabled" : "Disabled",
1575                        tr_formatter_speed_KBps (buf2, upLimit, sizeof (buf2)),
1576                        altEnabled ? "Enabled" : "Disabled",
1577                        tr_formatter_speed_KBps (buf3, altUp, sizeof (buf3)));
1578
1579                if (altEnabled)
1580                    tr_formatter_speed_KBps (buf, altDown, sizeof (buf));
1581                else if (downEnabled)
1582                    tr_formatter_speed_KBps (buf, downLimit, sizeof (buf));
1583                else
1584                    tr_strlcpy (buf, "Unlimited", sizeof (buf));
1585                printf ("  Download speed limit: %s (%s limit: %s; %s turtle limit: %s)\n",
1586                        buf,
1587                        downEnabled ? "Enabled" : "Disabled",
1588                        tr_formatter_speed_KBps (buf2, downLimit, sizeof (buf2)),
1589                        altEnabled ? "Enabled" : "Disabled",
1590                        tr_formatter_speed_KBps (buf3, altDown, sizeof (buf3)));
1591
1592                if (altTimeEnabled) {
1593                    printf ("  Turtle schedule: %02d:%02d - %02d:%02d  ",
1594                          (int)(altBegin/60), (int)(altBegin%60),
1595                          (int)(altEnd/60), (int)(altEnd%60));
1596                    if (altDay & TR_SCHED_SUN)   printf ("Sun ");
1597                    if (altDay & TR_SCHED_MON)   printf ("Mon ");
1598                    if (altDay & TR_SCHED_TUES)  printf ("Tue ");
1599                    if (altDay & TR_SCHED_WED)   printf ("Wed ");
1600                    if (altDay & TR_SCHED_THURS) printf ("Thu ");
1601                    if (altDay & TR_SCHED_FRI)   printf ("Fri ");
1602                    if (altDay & TR_SCHED_SAT)   printf ("Sat ");
1603                    printf ("\n");
1604                }
1605            }
1606        }
1607        printf ("\n");
1608
1609        printf ("MISC\n");
1610        if (tr_variantDictFindBool (args, TR_KEY_start_added_torrents, &boolVal))
1611            printf ("  Autostart added torrents: %s\n", (boolVal ? "Yes" : "No"));
1612        if (tr_variantDictFindBool (args, TR_KEY_trash_original_torrent_files, &boolVal))
1613            printf ("  Delete automatically added torrents: %s\n", (boolVal ? "Yes" : "No"));
1614    }
1615}
1616
1617static void
1618printSessionStats (tr_variant * top)
1619{
1620  tr_variant *args, *d;
1621  if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args)))
1622    {
1623      char buf[512];
1624      int64_t up, down, secs, sessions;
1625
1626      if (tr_variantDictFindDict (args, TR_KEY_current_stats, &d)
1627          && tr_variantDictFindInt (d, TR_KEY_uploadedBytes, &up)
1628          && tr_variantDictFindInt (d, TR_KEY_downloadedBytes, &down)
1629          && tr_variantDictFindInt (d, TR_KEY_secondsActive, &secs))
1630        {
1631          printf ("\nCURRENT SESSION\n");
1632          printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
1633          printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
1634          printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
1635          printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
1636        }
1637
1638      if (tr_variantDictFindDict (args, TR_KEY_cumulative_stats, &d)
1639            && tr_variantDictFindInt (d, TR_KEY_sessionCount, &sessions)
1640            && tr_variantDictFindInt (d, TR_KEY_uploadedBytes, &up)
1641            && tr_variantDictFindInt (d, TR_KEY_downloadedBytes, &down)
1642            && tr_variantDictFindInt (d, TR_KEY_secondsActive, &secs))
1643        {
1644          printf ("\nTOTAL\n");
1645          printf ("  Started %lu times\n", (unsigned long)sessions);
1646          printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
1647          printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
1648          printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
1649          printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
1650        }
1651    }
1652}
1653
1654static char id[4096];
1655
1656static int
1657processResponse (const char * rpcurl, const void * response, size_t len)
1658{
1659    tr_variant top;
1660    int status = EXIT_SUCCESS;
1661
1662    if (debug)
1663        fprintf (stderr, "got response (len %d):\n--------\n%*.*s\n--------\n",
1664               (int)len, (int)len, (int)len, (const char*) response);
1665
1666    if (tr_variantFromJson (&top, response, len))
1667    {
1668        tr_logAddNamedError (MY_NAME, "Unable to parse response \"%*.*s\"", (int)len,
1669               (int)len, (char*)response);
1670        status |= EXIT_FAILURE;
1671    }
1672    else
1673    {
1674        int64_t      tag = -1;
1675        const char * str;
1676
1677        if (tr_variantDictFindStr (&top, TR_KEY_result, &str, NULL))
1678        {
1679            if (strcmp (str, "success"))
1680            {
1681                printf ("Error: %s\n", str);
1682                status |= EXIT_FAILURE;
1683            }
1684            else
1685            {
1686        tr_variantDictFindInt (&top, TR_KEY_tag, &tag);
1687
1688        switch (tag)
1689        {
1690            case TAG_SESSION:
1691                printSession (&top); break;
1692
1693            case TAG_STATS:
1694                printSessionStats (&top); break;
1695
1696            case TAG_DETAILS:
1697                printDetails (&top); break;
1698
1699            case TAG_FILES:
1700                printFileList (&top); break;
1701
1702            case TAG_LIST:
1703                printTorrentList (&top); break;
1704
1705            case TAG_PEERS:
1706                printPeers (&top); break;
1707
1708            case TAG_PIECES:
1709                printPieces (&top); break;
1710
1711            case TAG_PORTTEST:
1712                printPortTest (&top); break;
1713
1714            case TAG_TRACKERS:
1715                printTrackers (&top); break;
1716
1717            case TAG_TORRENT_ADD: {
1718                int64_t i;
1719                tr_variant * b = &top;
1720                if (tr_variantDictFindDict (&top, ARGUMENTS, &b)
1721                        && tr_variantDictFindDict (b, TR_KEY_torrent_added, &b)
1722                        && tr_variantDictFindInt (b, TR_KEY_id, &i))
1723                    tr_snprintf (id, sizeof (id), "%"PRId64, i);
1724                /* fall-through to default: to give success or failure msg */
1725            }
1726            default:
1727                if (!tr_variantDictFindStr (&top, TR_KEY_result, &str, NULL))
1728                    status |= EXIT_FAILURE;
1729                else {
1730                    printf ("%s responded: \"%s\"\n", rpcurl, str);
1731                    if (strcmp (str, "success"))
1732                        status |= EXIT_FAILURE;
1733                }
1734        }
1735
1736        tr_variantFree (&top);
1737    }
1738        }
1739        else
1740            status |= EXIT_FAILURE;
1741    }
1742
1743    return status;
1744}
1745
1746static CURL*
1747tr_curl_easy_init (struct evbuffer * writebuf)
1748{
1749    CURL * curl = curl_easy_init ();
1750    curl_easy_setopt (curl, CURLOPT_USERAGENT, MY_NAME "/" LONG_VERSION_STRING);
1751    curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, writeFunc);
1752    curl_easy_setopt (curl, CURLOPT_WRITEDATA, writebuf);
1753    curl_easy_setopt (curl, CURLOPT_HEADERFUNCTION, parseResponseHeader);
1754    curl_easy_setopt (curl, CURLOPT_POST, 1);
1755    curl_easy_setopt (curl, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
1756    curl_easy_setopt (curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
1757    curl_easy_setopt (curl, CURLOPT_VERBOSE, debug);
1758    curl_easy_setopt (curl, CURLOPT_ENCODING, ""); /* "" tells curl to fill in the blanks with what it was compiled to support */
1759    if (netrc)
1760        curl_easy_setopt (curl, CURLOPT_NETRC_FILE, netrc);
1761    if (auth)
1762        curl_easy_setopt (curl, CURLOPT_USERPWD, auth);
1763    if (UseSSL)
1764    {
1765        curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0); /* do not verify subject/hostname */
1766        curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0); /* since most certs will be self-signed, do not verify against CA */               
1767    }
1768    if (sessionId) {
1769        char * h = tr_strdup_printf ("%s: %s", TR_RPC_SESSION_ID_HEADER, sessionId);
1770        struct curl_slist * custom_headers = curl_slist_append (NULL, h);
1771        curl_easy_setopt (curl, CURLOPT_HTTPHEADER, custom_headers);
1772        /* fixme: leaks */
1773    }
1774    return curl;
1775}
1776
1777static int
1778flush (const char * rpcurl, tr_variant ** benc)
1779{
1780    CURLcode res;
1781    CURL * curl;
1782    int status = EXIT_SUCCESS;
1783    struct evbuffer * buf = evbuffer_new ();
1784    char * json = tr_variantToStr (*benc, TR_VARIANT_FMT_JSON_LEAN, NULL);
1785    char *rpcurl_http =  tr_strdup_printf (UseSSL? "https://%s" : "http://%s", rpcurl);
1786
1787    curl = tr_curl_easy_init (buf);
1788    curl_easy_setopt (curl, CURLOPT_URL, rpcurl_http);
1789    curl_easy_setopt (curl, CURLOPT_POSTFIELDS, json);
1790    curl_easy_setopt (curl, CURLOPT_TIMEOUT, getTimeoutSecs (json));
1791
1792    if (debug)
1793        fprintf (stderr, "posting:\n--------\n%s\n--------\n", json);
1794
1795    if ((res = curl_easy_perform (curl)))
1796    {
1797        tr_logAddNamedError (MY_NAME, " (%s) %s", rpcurl_http, curl_easy_strerror (res));
1798        status |= EXIT_FAILURE;
1799    }
1800    else
1801    {
1802        long response;
1803        curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &response);
1804        switch (response) {
1805            case 200:
1806                status |= processResponse (rpcurl, (const char*) evbuffer_pullup (buf, -1), evbuffer_get_length (buf));
1807                break;
1808            case 409:
1809                /* Session id failed. Our curl header func has already
1810                 * pulled the new session id from this response's headers,
1811                 * build a new CURL* and try again */
1812                curl_easy_cleanup (curl);
1813                curl = NULL;
1814                status |= flush (rpcurl, benc);
1815                benc = NULL;
1816                break;
1817            default:
1818                fprintf (stderr, "Unexpected response: %s\n", evbuffer_pullup (buf, -1));
1819                status |= EXIT_FAILURE;
1820                break;
1821        }
1822    }
1823
1824    /* cleanup */
1825    tr_free (rpcurl_http);
1826    tr_free (json);
1827    evbuffer_free (buf);
1828    if (curl != 0)
1829        curl_easy_cleanup (curl);
1830    if (benc != NULL) {
1831        tr_variantFree (*benc);
1832        *benc = 0;
1833    }
1834    return status;
1835}
1836
1837static tr_variant*
1838ensure_sset (tr_variant ** sset)
1839{
1840    tr_variant * args;
1841
1842    if (*sset)
1843        args = tr_variantDictFind (*sset, ARGUMENTS);
1844    else {
1845        *sset = tr_new0 (tr_variant, 1);
1846        tr_variantInitDict (*sset, 3);
1847        tr_variantDictAddStr (*sset, TR_KEY_method, "session-set");
1848        args = tr_variantDictAddDict (*sset, ARGUMENTS, 0);
1849    }
1850
1851    return args;
1852}
1853
1854static tr_variant*
1855ensure_tset (tr_variant ** tset)
1856{
1857    tr_variant * args;
1858
1859    if (*tset)
1860        args = tr_variantDictFind (*tset, ARGUMENTS);
1861    else {
1862        *tset = tr_new0 (tr_variant, 1);
1863        tr_variantInitDict (*tset, 3);
1864        tr_variantDictAddStr (*tset, TR_KEY_method, "torrent-set");
1865        args = tr_variantDictAddDict (*tset, ARGUMENTS, 1);
1866    }
1867
1868    return args;
1869}
1870
1871static int
1872processArgs (const char * rpcurl, int argc, const char ** argv)
1873{
1874    int c;
1875    int status = EXIT_SUCCESS;
1876    const char * optarg;
1877    tr_variant *sset = 0;
1878    tr_variant *tset = 0;
1879    tr_variant *tadd = 0;
1880
1881    *id = '\0';
1882
1883    while ((c = tr_getopt (getUsage (), argc, argv, opts, &optarg)))
1884    {
1885        const int stepMode = getOptMode (c);
1886
1887        if (!stepMode) /* meta commands */
1888        {
1889            switch (c)
1890            {
1891                case 'a': /* add torrent */
1892                    if (sset != 0) status |= flush (rpcurl, &sset);
1893                    if (tadd != 0) status |= flush (rpcurl, &tadd);
1894                    if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id, NULL); status |= flush (rpcurl, &tset); }
1895                    tadd = tr_new0 (tr_variant, 1);
1896                    tr_variantInitDict (tadd, 3);
1897                    tr_variantDictAddStr (tadd, TR_KEY_method, "torrent-add");
1898                    tr_variantDictAddInt (tadd, TR_KEY_tag, TAG_TORRENT_ADD);
1899                    tr_variantDictAddDict (tadd, ARGUMENTS, 0);
1900                    break;
1901
1902                case 'b': /* debug */
1903                    debug = true;
1904                    break;
1905
1906                case 'n': /* auth */
1907                    auth = tr_strdup (optarg);
1908                    break;
1909
1910                case 810: /* authenv */
1911                    auth = tr_env_get_string ("TR_AUTH", NULL);
1912                    if (auth == NULL)
1913                    {
1914                        fprintf (stderr, "The TR_AUTH environment variable is not set\n");
1915                        exit (0);
1916                    }
1917                    break;
1918
1919                case 'N': /* netrc */
1920                    netrc = tr_strdup (optarg);
1921                    break;
1922
1923                case 820: /* UseSSL */
1924                    UseSSL = true;
1925                    break;
1926
1927                case 't': /* set current torrent */
1928                    if (tadd != 0) status |= flush (rpcurl, &tadd);
1929                    if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id, NULL); status |= flush (rpcurl, &tset); }
1930                    tr_strlcpy (id, optarg, sizeof (id));
1931                    break;
1932
1933                case 'V': /* show version number */
1934                    fprintf (stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
1935                    exit (0);
1936                    break;
1937
1938                case TR_OPT_ERR:
1939                    fprintf (stderr, "invalid option\n");
1940                    showUsage ();
1941                    status |= EXIT_FAILURE;
1942                    break;
1943
1944                case TR_OPT_UNK:
1945                    if (tadd) {
1946                        tr_variant * args = tr_variantDictFind (tadd, ARGUMENTS);
1947                        char * tmp = getEncodedMetainfo (optarg);
1948                        if (tmp)
1949                            tr_variantDictAddStr (args, TR_KEY_metainfo, tmp);
1950                        else
1951                            tr_variantDictAddStr (args, TR_KEY_filename, optarg);
1952                        tr_free (tmp);
1953                    } else {
1954                        fprintf (stderr, "Unknown option: %s\n", optarg);
1955                        status |= EXIT_FAILURE;
1956                    }
1957                    break;
1958            }
1959        }
1960        else if (stepMode == MODE_TORRENT_GET)
1961        {
1962            size_t i, n;
1963            tr_variant * top = tr_new0 (tr_variant, 1);
1964            tr_variant * args;
1965            tr_variant * fields;
1966            tr_variantInitDict (top, 3);
1967            tr_variantDictAddStr (top, TR_KEY_method, "torrent-get");
1968            args = tr_variantDictAddDict (top, ARGUMENTS, 0);
1969            fields = tr_variantDictAddList (args, TR_KEY_fields, 0);
1970
1971            if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id, NULL); status |= flush (rpcurl, &tset); }
1972
1973            switch (c)
1974            {
1975                case 'i': tr_variantDictAddInt (top, TR_KEY_tag, TAG_DETAILS);
1976                          n = TR_N_ELEMENTS (details_keys);
1977                          for (i=0; i<n; ++i) tr_variantListAddQuark (fields, details_keys[i]);
1978                          addIdArg (args, id, NULL);
1979                          break;
1980                case 'l': tr_variantDictAddInt (top, TR_KEY_tag, TAG_LIST);
1981                          n = TR_N_ELEMENTS (list_keys);
1982                          for (i=0; i<n; ++i) tr_variantListAddQuark (fields, list_keys[i]);
1983                          addIdArg (args, id, "all");
1984                          break;
1985                case 940: tr_variantDictAddInt (top, TR_KEY_tag, TAG_FILES);
1986                          n = TR_N_ELEMENTS (files_keys);
1987                          for (i=0; i<n; ++i) tr_variantListAddQuark (fields, files_keys[i]);
1988                          addIdArg (args, id, NULL);
1989                          break;
1990                case 941: tr_variantDictAddInt (top, TR_KEY_tag, TAG_PEERS);
1991                          tr_variantListAddStr (fields, "peers");
1992                          addIdArg (args, id, NULL);
1993                          break;
1994                case 942: tr_variantDictAddInt (top, TR_KEY_tag, TAG_PIECES);
1995                          tr_variantListAddStr (fields, "pieces");
1996                          tr_variantListAddStr (fields, "pieceCount");
1997                          addIdArg (args, id, NULL);
1998                          break;
1999                case 943: tr_variantDictAddInt (top, TR_KEY_tag, TAG_TRACKERS);
2000                          tr_variantListAddStr (fields, "trackerStats");
2001                          addIdArg (args, id, NULL);
2002                          break;
2003                default:  assert ("unhandled value" && 0);
2004            }
2005
2006            status |= flush (rpcurl, &top);
2007        }
2008        else if (stepMode == MODE_SESSION_SET)
2009        {
2010            tr_variant * args = ensure_sset (&sset);
2011
2012            switch (c)
2013            {
2014                case 800: tr_variantDictAddStr (args, TR_KEY_script_torrent_done_filename, optarg);
2015                          tr_variantDictAddBool (args, TR_KEY_script_torrent_done_enabled, true);
2016                          break;
2017                case 801: tr_variantDictAddBool (args, TR_KEY_script_torrent_done_enabled, false);
2018                          break;
2019                case 970: tr_variantDictAddBool (args, TR_KEY_alt_speed_enabled, true);
2020                          break;
2021                case 971: tr_variantDictAddBool (args, TR_KEY_alt_speed_enabled, false);
2022                          break;
2023                case 972: tr_variantDictAddInt (args, TR_KEY_alt_speed_down, numarg (optarg));
2024                          break;
2025                case 973: tr_variantDictAddInt (args, TR_KEY_alt_speed_up, numarg (optarg));
2026                          break;
2027                case 974: tr_variantDictAddBool (args, TR_KEY_alt_speed_time_enabled, true);
2028                          break;
2029                case 975: tr_variantDictAddBool (args, TR_KEY_alt_speed_time_enabled, false);
2030                          break;
2031                case 976: addTime (args, TR_KEY_alt_speed_time_begin, optarg);
2032                          break;
2033                case 977: addTime (args, TR_KEY_alt_speed_time_end, optarg);
2034                          break;
2035                case 978: addDays (args, TR_KEY_alt_speed_time_day, optarg);
2036                          break;
2037                case 'c': tr_variantDictAddStr (args, TR_KEY_incomplete_dir, optarg);
2038                          tr_variantDictAddBool (args, TR_KEY_incomplete_dir_enabled, true);
2039                          break;
2040                case 'C': tr_variantDictAddBool (args, TR_KEY_incomplete_dir_enabled, false);
2041                          break;
2042                case 'e': tr_variantDictAddInt (args, TR_KEY_cache_size_mb, atoi (optarg));
2043                          break;
2044                case 910: tr_variantDictAddStr (args, TR_KEY_encryption, "required");
2045                          break;
2046                case 911: tr_variantDictAddStr (args, TR_KEY_encryption, "preferred");
2047                          break;
2048                case 912: tr_variantDictAddStr (args, TR_KEY_encryption, "tolerated");
2049                          break;
2050                case 'm': tr_variantDictAddBool (args, TR_KEY_port_forwarding_enabled, true);
2051                          break;
2052                case 'M': tr_variantDictAddBool (args, TR_KEY_port_forwarding_enabled, false);
2053                          break;
2054                case 'o': tr_variantDictAddBool (args, TR_KEY_dht_enabled, true);
2055                          break;
2056                case 'O': tr_variantDictAddBool (args, TR_KEY_dht_enabled, false);
2057                          break;
2058                case 830: tr_variantDictAddBool (args, TR_KEY_utp_enabled, true);
2059                          break;
2060                case 831: tr_variantDictAddBool (args, TR_KEY_utp_enabled, false);
2061                          break;
2062                case 'p': tr_variantDictAddInt (args, TR_KEY_peer_port, numarg (optarg));
2063                          break;
2064                case 'P': tr_variantDictAddBool (args, TR_KEY_peer_port_random_on_start, true);
2065                          break;
2066                case 'x': tr_variantDictAddBool (args, TR_KEY_pex_enabled, true);
2067                          break;
2068                case 'X': tr_variantDictAddBool (args, TR_KEY_pex_enabled, false);
2069                          break;
2070                case 'y': tr_variantDictAddBool (args, TR_KEY_lpd_enabled, true);
2071                          break;
2072                case 'Y': tr_variantDictAddBool (args, TR_KEY_lpd_enabled, false);
2073                          break;
2074                case 953: tr_variantDictAddReal (args, TR_KEY_seedRatioLimit, atof (optarg));
2075                          tr_variantDictAddBool (args, TR_KEY_seedRatioLimited, true);
2076                          break;
2077                case 954: tr_variantDictAddBool (args, TR_KEY_seedRatioLimited, false);
2078                          break;
2079                case 990: tr_variantDictAddBool (args, TR_KEY_start_added_torrents, false);
2080                          break;
2081                case 991: tr_variantDictAddBool (args, TR_KEY_start_added_torrents, true);
2082                          break;
2083                case 992: tr_variantDictAddBool (args, TR_KEY_trash_original_torrent_files, true);
2084                          break;
2085                case 993: tr_variantDictAddBool (args, TR_KEY_trash_original_torrent_files, false);
2086                          break;
2087                default:  assert ("unhandled value" && 0);
2088                          break;
2089            }
2090        }
2091        else if (stepMode == (MODE_SESSION_SET | MODE_TORRENT_SET))
2092        {
2093            tr_variant * targs = 0;
2094            tr_variant * sargs = 0;
2095
2096            if (*id)
2097                targs = ensure_tset (&tset);
2098            else
2099                sargs = ensure_sset (&sset);
2100
2101            switch (c)
2102            {
2103                case 'd': if (targs) {
2104                              tr_variantDictAddInt (targs, TR_KEY_downloadLimit, numarg (optarg));
2105                              tr_variantDictAddBool (targs, TR_KEY_downloadLimited, true);
2106                          } else {
2107                              tr_variantDictAddInt (sargs, TR_KEY_speed_limit_down, numarg (optarg));
2108                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_down_enabled, true);
2109                          }
2110                          break;
2111                case 'D': if (targs)
2112                              tr_variantDictAddBool (targs, TR_KEY_downloadLimited, false);
2113                          else
2114                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_down_enabled, false);
2115                          break;
2116                case 'u': if (targs) {
2117                              tr_variantDictAddInt (targs, TR_KEY_uploadLimit, numarg (optarg));
2118                              tr_variantDictAddBool (targs, TR_KEY_uploadLimited, true);
2119                          } else {
2120                              tr_variantDictAddInt (sargs, TR_KEY_speed_limit_up, numarg (optarg));
2121                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_up_enabled, true);
2122                          }
2123                          break;
2124                case 'U': if (targs)
2125                              tr_variantDictAddBool (targs, TR_KEY_uploadLimited, false);
2126                          else
2127                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_up_enabled, false);
2128                          break;
2129                case 930: if (targs)
2130                              tr_variantDictAddInt (targs, TR_KEY_peer_limit, atoi (optarg));
2131                          else
2132                              tr_variantDictAddInt (sargs, TR_KEY_peer_limit_global, atoi (optarg));
2133                          break;
2134                default:  assert ("unhandled value" && 0);
2135                          break;
2136            }
2137        }
2138        else if (stepMode == MODE_TORRENT_SET)
2139        {
2140            tr_variant * args = ensure_tset (&tset);
2141
2142            switch (c)
2143            {
2144                case 712: tr_variantListAddInt (tr_variantDictAddList (args, TR_KEY_trackerRemove, 1), atoi (optarg));
2145                          break;
2146                case 950: tr_variantDictAddReal (args, TR_KEY_seedRatioLimit, atof (optarg));
2147                          tr_variantDictAddInt (args, TR_KEY_seedRatioMode, TR_RATIOLIMIT_SINGLE);
2148                          break;
2149                case 951: tr_variantDictAddInt (args, TR_KEY_seedRatioMode, TR_RATIOLIMIT_GLOBAL);
2150                          break;
2151                case 952: tr_variantDictAddInt (args, TR_KEY_seedRatioMode, TR_RATIOLIMIT_UNLIMITED);
2152                          break;
2153                case 984: tr_variantDictAddBool (args, TR_KEY_honorsSessionLimits, true);
2154                          break;
2155                case 985: tr_variantDictAddBool (args, TR_KEY_honorsSessionLimits, false);
2156                          break;
2157                default:  assert ("unhandled value" && 0);
2158                          break;
2159            }
2160        }
2161        else if (stepMode == (MODE_TORRENT_SET | MODE_TORRENT_ADD))
2162        {
2163            tr_variant * args;
2164
2165            if (tadd)
2166                args = tr_variantDictFind (tadd, ARGUMENTS);
2167            else
2168                args = ensure_tset (&tset);
2169
2170            switch (c)
2171            {
2172                case 'g': addFiles (args, TR_KEY_files_wanted, optarg);
2173                          break;
2174                case 'G': addFiles (args, TR_KEY_files_unwanted, optarg);
2175                          break;
2176                case 900: addFiles (args, TR_KEY_priority_high, optarg);
2177                          break;
2178                case 901: addFiles (args, TR_KEY_priority_normal, optarg);
2179                          break;
2180                case 902: addFiles (args, TR_KEY_priority_low, optarg);
2181                          break;
2182                case 700: tr_variantDictAddInt (args, TR_KEY_bandwidthPriority,  1);
2183                          break;
2184                case 701: tr_variantDictAddInt (args, TR_KEY_bandwidthPriority,  0);
2185                          break;
2186                case 702: tr_variantDictAddInt (args, TR_KEY_bandwidthPriority, -1);
2187                          break;
2188                case 710: tr_variantListAddStr (tr_variantDictAddList (args, TR_KEY_trackerAdd, 1), optarg);
2189                          break;
2190                default:  assert ("unhandled value" && 0);
2191                          break;
2192            }
2193        }
2194        else if (c == 961) /* set location */
2195        {
2196            if (tadd)
2197            {
2198                tr_variant * args = tr_variantDictFind (tadd, ARGUMENTS);
2199                tr_variantDictAddStr (args, TR_KEY_download_dir, optarg);
2200            }
2201            else
2202            {
2203                tr_variant * args;
2204                tr_variant * top = tr_new0 (tr_variant, 1);
2205                tr_variantInitDict (top, 2);
2206                tr_variantDictAddStr (top, TR_KEY_method, "torrent-set-location");
2207                args = tr_variantDictAddDict (top, ARGUMENTS, 3);
2208                tr_variantDictAddStr (args, TR_KEY_location, optarg);
2209                tr_variantDictAddBool (args, TR_KEY_move, false);
2210                addIdArg (args, id, NULL);
2211                status |= flush (rpcurl, &top);
2212                break;
2213            }
2214        }
2215        else switch (c)
2216        {
2217            case 920: /* session-info */
2218            {
2219                tr_variant * top = tr_new0 (tr_variant, 1);
2220                tr_variantInitDict (top, 2);
2221                tr_variantDictAddStr (top, TR_KEY_method, "session-get");
2222                tr_variantDictAddInt (top, TR_KEY_tag, TAG_SESSION);
2223                status |= flush (rpcurl, &top);
2224                break;
2225            }
2226            case 's': /* start */
2227            {
2228                if (tadd)
2229                    tr_variantDictAddBool (tr_variantDictFind (tadd, TR_KEY_arguments), TR_KEY_paused, false);
2230                else {
2231                    tr_variant * top = tr_new0 (tr_variant, 1);
2232                    tr_variantInitDict (top, 2);
2233                    tr_variantDictAddStr (top, TR_KEY_method, "torrent-start");
2234                    addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id, NULL);
2235                    status |= flush (rpcurl, &top);
2236                }
2237                break;
2238            }
2239            case 'S': /* stop */
2240            {
2241                if (tadd)
2242                    tr_variantDictAddBool (tr_variantDictFind (tadd, TR_KEY_arguments), TR_KEY_paused, true);
2243                else {
2244                    tr_variant * top = tr_new0 (tr_variant, 1);
2245                    tr_variantInitDict (top, 2);
2246                    tr_variantDictAddStr (top, TR_KEY_method, "torrent-stop");
2247                    addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id, NULL);
2248                    status |= flush (rpcurl, &top);
2249                }
2250                break;
2251            }
2252            case 'w':
2253            {
2254                char * path = absolutify (optarg);
2255                if (tadd)
2256                    tr_variantDictAddStr (tr_variantDictFind (tadd, TR_KEY_arguments), TR_KEY_download_dir, path);
2257                else {
2258                    tr_variant * args = ensure_sset (&sset);
2259                    tr_variantDictAddStr (args, TR_KEY_download_dir, path);
2260                }
2261                tr_free (path);
2262                break;
2263            }
2264            case 850:
2265            {
2266                tr_variant * top = tr_new0 (tr_variant, 1);
2267                tr_variantInitDict (top, 1);
2268                tr_variantDictAddStr (top, TR_KEY_method, "session-close");
2269                status |= flush (rpcurl, &top);
2270                break;
2271            }
2272            case 963:
2273            {
2274                tr_variant * top = tr_new0 (tr_variant, 1);
2275                tr_variantInitDict (top, 1);
2276                tr_variantDictAddStr (top, TR_KEY_method, "blocklist-update");
2277                status |= flush (rpcurl, &top);
2278                break;
2279            }
2280            case 921:
2281            {
2282                tr_variant * top = tr_new0 (tr_variant, 1);
2283                tr_variantInitDict (top, 2);
2284                tr_variantDictAddStr (top, TR_KEY_method, "session-stats");
2285                tr_variantDictAddInt (top, TR_KEY_tag, TAG_STATS);
2286                status |= flush (rpcurl, &top);
2287                break;
2288            }
2289            case 962:
2290            {
2291                tr_variant * top = tr_new0 (tr_variant, 1);
2292                tr_variantInitDict (top, 2);
2293                tr_variantDictAddStr (top, TR_KEY_method, "port-test");
2294                tr_variantDictAddInt (top, TR_KEY_tag, TAG_PORTTEST);
2295                status |= flush (rpcurl, &top);
2296                break;
2297            }
2298            case 600:
2299            {
2300                tr_variant * top;
2301                if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id, NULL); status |= flush (rpcurl, &tset); }
2302                top = tr_new0 (tr_variant, 1);
2303                tr_variantInitDict (top, 2);
2304                tr_variantDictAddStr (top, TR_KEY_method, "torrent-reannounce");
2305                addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id, NULL);
2306                status |= flush (rpcurl, &top);
2307                break;
2308            }
2309            case 'v':
2310            {
2311                tr_variant * top;
2312                if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id, NULL); status |= flush (rpcurl, &tset); }
2313                top = tr_new0 (tr_variant, 1);
2314                tr_variantInitDict (top, 2);
2315                tr_variantDictAddStr (top, TR_KEY_method, "torrent-verify");
2316                addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id, NULL);
2317                status |= flush (rpcurl, &top);
2318                break;
2319            }
2320            case 'r':
2321            case 'R':
2322            {
2323                tr_variant * args;
2324                tr_variant * top = tr_new0 (tr_variant, 1);
2325                tr_variantInitDict (top, 2);
2326                tr_variantDictAddStr (top, TR_KEY_method, "torrent-remove");
2327                args = tr_variantDictAddDict (top, ARGUMENTS, 2);
2328                tr_variantDictAddBool (args, TR_KEY_delete_local_data, c=='R');
2329                addIdArg (args, id, NULL);
2330                status |= flush (rpcurl, &top);
2331                break;
2332            }
2333            case 960:
2334            {
2335                tr_variant * args;
2336                tr_variant * top = tr_new0 (tr_variant, 1);
2337                tr_variantInitDict (top, 2);
2338                tr_variantDictAddStr (top, TR_KEY_method, "torrent-set-location");
2339                args = tr_variantDictAddDict (top, ARGUMENTS, 3);
2340                tr_variantDictAddStr (args, TR_KEY_location, optarg);
2341                tr_variantDictAddBool (args, TR_KEY_move, true);
2342                addIdArg (args, id, NULL);
2343                status |= flush (rpcurl, &top);
2344                break;
2345            }
2346            default:
2347            {
2348                fprintf (stderr, "got opt [%d]\n", c);
2349                showUsage ();
2350                break;
2351            }
2352        }
2353    }
2354
2355    if (tadd != 0) status |= flush (rpcurl, &tadd);
2356    if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id, NULL); status |= flush (rpcurl, &tset); }
2357    if (sset != 0) status |= flush (rpcurl, &sset);
2358    return status;
2359}
2360
2361/* [host:port] or [host] or [port] or [http (s?)://host:port/transmission/] */
2362static void
2363getHostAndPortAndRpcUrl (int * argc, char ** argv,
2364                         char ** host, int * port, char ** rpcurl)
2365{
2366    if (*argv[1] != '-')
2367    {
2368        int          i;
2369        const char * s = argv[1];
2370        const char * delim = strchr (s, ':');
2371        if (!strncmp (s, "http://", 7))   /* user passed in http rpc url */
2372        {
2373            *rpcurl = tr_strdup_printf ("%s/rpc/", s + 7);
2374        }
2375        else if (!strncmp (s, "https://", 8)) /* user passed in https rpc url */
2376        {
2377            UseSSL = true;
2378            *rpcurl = tr_strdup_printf ("%s/rpc/", s + 8);
2379        }
2380        else if (delim)   /* user passed in both host and port */
2381        {
2382            *host = tr_strndup (s, delim - s);
2383            *port = atoi (delim + 1);
2384        }
2385        else
2386        {
2387            char *    end;
2388            const int i = strtol (s, &end, 10);
2389            if (!*end) /* user passed in a port */
2390                *port = i;
2391            else /* user passed in a host */
2392                *host = tr_strdup (s);
2393        }
2394
2395        *argc -= 1;
2396        for (i = 1; i < *argc; ++i)
2397            argv[i] = argv[i + 1];
2398    }
2399}
2400
2401int
2402main (int argc, char ** argv)
2403{
2404    int port = DEFAULT_PORT;
2405    char * host = NULL;
2406    char * rpcurl = NULL;
2407    int exit_status = EXIT_SUCCESS;
2408
2409    if (argc < 2) {
2410        showUsage ();
2411        return EXIT_FAILURE;
2412    }
2413
2414    tr_formatter_mem_init (MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR);
2415    tr_formatter_size_init (DISK_K,DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR);
2416    tr_formatter_speed_init (SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR);
2417
2418    getHostAndPortAndRpcUrl (&argc, argv, &host, &port, &rpcurl);
2419    if (host == NULL)
2420        host = tr_strdup (DEFAULT_HOST);
2421    if (rpcurl == NULL)
2422        rpcurl = tr_strdup_printf ("%s:%d%s", host, port, DEFAULT_URL);
2423
2424    exit_status = processArgs (rpcurl, argc, (const char**)argv);
2425
2426    tr_free (host);
2427    tr_free (rpcurl);
2428    return exit_status;
2429}
Note: See TracBrowser for help on using the repository browser.