Context Navigation

remote.c @ 14615

Visit:

Last change on this file since 14615 was 14615, checked in by jordan, 6 years ago

fix const warnings

In particular, in passing argv around as a "const char * const *"
instead of a "const char *".

Property svn:keywords set to Date Rev Author Id

File size: 90.3 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 14615 2015-12-06 22:39:14Z jordan $
8	*/
9
10	#include <assert.h>
11	#include <ctype.h> /* isspace */
12	#include <math.h>
13	#include <stdio.h>
14	#include <stdlib.h>
15	#include <string.h> /* strcmp */
16
17	#include <event2/buffer.h>
18
19	#define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
20	#include <curl/curl.h>
21
22	#include <libtransmission/transmission.h>
23	#include <libtransmission/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
67	static void
68	etaToString (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
82	static char*
83	tr_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
130	static char*
131	strlpercent (char * buf, double x, size_t buflen)
132	{
133	return tr_strpercent (buf, x, buflen);
134	}
135
136	static char*
137	strlratio2 (char * buf, double ratio, size_t buflen)
138	{
139	return tr_strratio (buf, buflen, ratio, "Inf");
140	}
141
142	static char*
143	strlratio (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
157	static char*
158	strlmem (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
168	static char*
169	strlsize (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
181	enum
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
195	static const char*
196	getUsage (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
221	static 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	{ 'R', "remove-and-delete", "Remove the current torrent(s) and delete local data", NULL, 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
311	static void
312	showUsage (void)
313	{
314	tr_getopt_usage (MY_NAME, getUsage (), opts);
315	}
316
317	static int
318	numarg (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
333	enum
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
352	static int
353	getOptMode (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 'R': /* 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
487	static bool debug = 0;
488	static char * auth = NULL;
489	static char * netrc = NULL;
490	static char * sessionId = NULL;
491	static bool UseSSL = false;
492
493	static char*
494	getEncodedMetainfo (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
508	static void
509	addIdArg (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"))
523	{
524	tr_variantDictAddStr (args, TR_KEY_ids, "recently-active");
525	}
526	else if (strcmp (id, "all"))
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
543	static void
544	addTime (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
569	static void
570	addDays (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, -1, &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
601	static void
602	addFiles (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"))
615	{
616	int i;
617	int valueCount;
618	int * values = tr_parseNumberRange (arg, -1, &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
629	static const tr_quark files_keys[] = {
630	TR_KEY_files,
631	TR_KEY_name,
632	TR_KEY_priorities,
633	TR_KEY_wanted
634	};
635
636	static 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
687	static 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
704	static size_t
705	writeFunc (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 */
713	static size_t
714	parseResponseHeader (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))
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
734	static long
735	getTimeoutSecs (const char * req)
736	{
737	if (strstr (req, "\"method\":\"blocklist-update\"") != NULL)
738	return 300L;
739
740	return 60L; /* default value */
741	}
742
743	static char*
744	getStatusString (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
812	static const char *bandwidthPriorityNames[] =
813	{ "Low", "Normal", "High", "Invalid" };
814
815	static void
816	printDetails (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
1037	static void
1038	printFileList (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
1104	static void
1105	printPeersImpl (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
1134	static void
1135	printPeers (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
1157	static void
1158	printPiecesImpl (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
1175	static void
1176	printPieces (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
1201	static void
1202	printPortTest (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
1214	static void
1215	printTorrentList (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
1295	static void
1296	printTrackersImpl (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
1430	static void
1431	printTrackers (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
1455	static void
1456	printSession (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
1582	static void
1583	printSessionStats (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
1619	static char id[4096];
1620
1621	static int
1622	processResponse (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"))
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"))
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
1711	static CURL*
1712	tr_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
1742	static int
1743	flush (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
1802	static tr_variant*
1803	ensure_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
1819	static tr_variant*
1820	ensure_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
1836	static int
1837	processArgs (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 'R':
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=='R');
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/] */
2321	static void
2322	getHostAndPortAndRpcUrl (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)) /* user passed in http rpc url */
2331	{
2332	*rpcurl = tr_strdup_printf ("%s/rpc/", s + 7);
2333	}
2334	else if (!strncmp (s, "https://", 8)) /* 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
2360	int
2361	tr_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.

Context Navigation

source: trunk/daemon/remote.c @ 14615

Download in other formats: