source: trunk/daemon/remote.c @ 13838

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

(remote) fix global search-and-replace damage wreaked upon the --help text, reported by Elbandi

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