source: trunk/daemon/remote.c

Last change on this file was 14718, checked in by mikedld, 5 years ago

Explicitly compare result of str(n)cmp/memcmp to signify that it's not boolean

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