source: trunk/daemon/remote.c @ 14326

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

(trunk, daemon) #5743 'unknown option: -R': revert previous commit, sync manpage

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