You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

709 lines
17 KiB

/*
* Helper to submit via JSON-RPC and get back response.
*/
#include "config.h"
#include <assert.h>
#include <ccan/asort/asort.h>
#include <ccan/err/err.h>
#include <ccan/json_escape/json_escape.h>
#include <ccan/opt/opt.h>
#include <ccan/read_write_all/read_write_all.h>
#include <ccan/str/str.h>
#include <ccan/tal/path/path.h>
#include <ccan/tal/str/str.h>
#include <common/configdir.h>
#include <common/json.h>
#include <common/json_command.h>
#include <common/memleak.h>
#include <common/utils.h>
#include <common/version.h>
#include <libgen.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <unistd.h>
#define NO_ERROR 0
#define ERROR_FROM_LIGHTNINGD 1
#define ERROR_TALKING_TO_LIGHTNINGD 2
#define ERROR_USAGE 3
struct netaddr;
/* Returns number of tokens digested */
static size_t human_readable(const char *buffer, const jsmntok_t *t, char term)
{
size_t i, n;
switch (t->type) {
case JSMN_PRIMITIVE:
case JSMN_STRING:
for (i = t->start; i < t->end; i++) {
/* We only translate \n and \t. */
if (buffer[i] == '\\' && i + 1 < t->end) {
if (buffer[i+1] == 'n') {
fputc('\n', stdout);
i++;
continue;
} else if (buffer[i+1] == 't') {
fputc('\t', stdout);
i++;
continue;
}
}
fputc(buffer[i], stdout);
}
fputc(term, stdout);
return 1;
case JSMN_ARRAY:
n = 1;
for (i = 0; i < t->size; i++)
n += human_readable(buffer, t + n, '\n');
return n;
case JSMN_OBJECT:
/* Elide single-field objects */
if (t->size == 1)
return human_readable(buffer, t + 2, '\n') + 3;
n = 1;
for (i = 0; i < t->size; i++) {
n += human_readable(buffer, t + n, '=');
n += human_readable(buffer, t + n, '\n');
}
return n;
case JSMN_UNDEFINED:
break;
}
abort();
}
/* Returns number of tokens digested */
static size_t flat_json(const char *prefix,
const char *buffer, const jsmntok_t *t)
{
size_t i, n;
char *p;
switch (t->type) {
case JSMN_PRIMITIVE:
case JSMN_STRING:
printf("%s=%.*s\n",
prefix, t->end - t->start, buffer + t->start);
return 1;
case JSMN_ARRAY:
n = 1;
for (i = 0; i < t->size; i++) {
p = tal_fmt(NULL, "%s[%zi]", prefix, i);
n += flat_json(p, buffer, t + n);
tal_free(p);
}
return n;
case JSMN_OBJECT:
n = 1;
for (i = 0; i < t->size; i++) {
if (streq(prefix, ""))
p = tal_fmt(NULL, "%.*s",
t[n].end - t[n].start,
buffer + t[n].start);
else
p = tal_fmt(NULL, "%s.%.*s", prefix,
t[n].end - t[n].start,
buffer + t[n].start);
n++;
n += flat_json(p, buffer, t + n);
tal_free(p);
}
return n;
case JSMN_UNDEFINED:
break;
}
abort();
}
static int compare_tok(const jsmntok_t *a, const jsmntok_t *b,
const char *buffer)
{
int a_len = a->end - a->start, b_len = b->end - b->start, min_len, cmp;
if (a_len > b_len)
min_len = b_len;
else
min_len = a_len;
cmp = memcmp(buffer + a->start, buffer + b->start, min_len);
if (cmp != 0)
return cmp;
/* If equal, shorter one wins. */
return a_len - b_len;
}
static int compare_help(const jsmntok_t *const *a,
const jsmntok_t *const *b,
char *buffer)
{
const jsmntok_t *cat_a, *cat_b;
bool a_is_developer, b_is_developer;
int cmp;
cat_a = json_get_member(buffer, *a, "category");
cat_b = json_get_member(buffer, *b, "category");
/* Just in case it's an older lightningd! */
if (!cat_a)
goto same_category;
/* We always tweak "developer" category to last. */
a_is_developer = json_tok_streq(buffer, cat_a, "developer");
b_is_developer = json_tok_streq(buffer, cat_b, "developer");
if (a_is_developer && b_is_developer)
cmp = 0;
else if (a_is_developer)
cmp = 1;
else if (b_is_developer)
cmp = -1;
else
/* Otherwise we order category alphabetically. */
cmp = compare_tok(cat_a, cat_b, buffer);
if (cmp != 0)
return cmp;
/* After category, we order by name */
same_category:
return compare_tok(json_get_member(buffer, *a, "command"),
json_get_member(buffer, *b, "command"),
buffer);
}
static void human_help(char *buffer, const jsmntok_t *result)
{
unsigned int i;
/* `curr` is used as a temporary token */
const jsmntok_t *curr;
const char *prev_cat;
/* Contains all commands objects, which have the following structure :
* {
* "command": "The command name and usage",
* "category": "The command category",
* "description": "The command's description",
* "verbose": "The command's detailed description"
* }
*/
const jsmntok_t * help_array = json_get_member(buffer, result, "help");
const jsmntok_t **help = tal_arr(NULL, const jsmntok_t *,
help_array->size);
/* Populate an array for easy sorting with asort */
json_for_each_arr(i, curr, help_array)
help[i] = curr;
asort(help, tal_count(help), compare_help, buffer);
prev_cat = "";
for (i = 0; i < tal_count(help); i++) {
const jsmntok_t *category, *command, *desc;
category = json_get_member(buffer, help[i], "category");
if (category && !json_tok_streq(buffer, category, prev_cat)) {
prev_cat = json_strdup(help, buffer, category);
printf("=== %s ===\n\n", prev_cat);
}
command = json_get_member(buffer, help[i], "command");
desc = json_get_member(buffer, help[i], "description");
printf("%.*s\n",
command->end - command->start, buffer + command->start);
printf(" %.*s\n\n",
desc->end - desc->start, buffer + desc->start);
}
tal_free(help);
printf("---\nrun `lightning-cli help <command>` for more information on a specific command\n");
}
enum format {
JSON,
HUMAN,
HELPLIST,
FLAT,
DEFAULT_FORMAT,
RAW
};
static char *opt_set_human(enum format *format)
{
*format = HUMAN;
return NULL;
}
static char *opt_set_flat(enum format *format)
{
*format = FLAT;
return NULL;
}
static char *opt_set_json(enum format *format)
{
*format = JSON;
return NULL;
}
static char *opt_set_raw(enum format *format)
{
*format = RAW;
return NULL;
}
enum input {
KEYWORDS,
ORDERED,
DEFAULT_INPUT
};
static char *opt_set_keywords(enum input *input)
{
*input = KEYWORDS;
return NULL;
}
static char *opt_set_ordered(enum input *input)
{
*input = ORDERED;
return NULL;
}
static bool is_literal(const char *arg)
{
size_t arglen = strlen(arg);
if (arglen == 0) {
return false;
}
return strspn(arg, "0123456789") == arglen
|| streq(arg, "true")
|| streq(arg, "false")
|| streq(arg, "null")
|| (arg[0] == '{' && arg[arglen - 1] == '}')
|| (arg[0] == '[' && arg[arglen - 1] == ']')
|| (arg[0] == '"' && arg[arglen - 1] == '"');
}
static void add_input(char **cmd, const char *input,
int i, int argc)
{
/* Numbers, bools, objects and arrays are left unquoted,
* and quoted things left alone. */
if (is_literal(input))
tal_append_fmt(cmd, "%s", input);
else
tal_append_fmt(cmd, "\"%s\"", json_escape(*cmd, input)->s);
if (i != argc - 1)
tal_append_fmt(cmd, ", ");
}
static void
try_exec_man (const char *page, char *relative_to) {
int status;
switch (fork()) {
case -1:
err(1, "Forking man command");
case 0:
/* child, run man command. */
if (relative_to != NULL) {
page = tal_fmt(page, "%s/../doc/%s.7", relative_to, page);
execlp("man", "man", "-l", page, (char *)NULL);
}
else {
execlp("man", "man", page, (char *)NULL);
}
err(1, "Running man command");
default:
break;
}
wait(&status);
if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
exit(0);
}
static void print_json(const char *str, const jsmntok_t *tok, const char *indent)
{
size_t i;
const jsmntok_t *t;
bool first;
char next_indent[strlen(indent) + 3 + 1];
memset(next_indent, ' ', sizeof(next_indent)-1);
next_indent[sizeof(next_indent)-1] = '\0';
switch (tok->type) {
case JSMN_PRIMITIVE:
case JSMN_STRING:
printf("%.*s", json_tok_full_len(tok), json_tok_full(str, tok));
return;
case JSMN_ARRAY:
first = true;
json_for_each_arr(i, t, tok) {
if (first)
printf("[\n%s", next_indent);
else
printf(",\n%s", next_indent);
print_json(str, t, next_indent);
first = false;
}
if (first)
printf("[]");
else
printf("\n%s]", indent);
return;
case JSMN_OBJECT:
first = true;
json_for_each_obj(i, t, tok) {
if (first)
printf("{\n%s", next_indent);
else
printf(",\n%s", next_indent);
print_json(str, t, next_indent);
printf(": ");
print_json(str, t + 1, next_indent);
first = false;
}
if (first)
printf("{}");
else
printf("\n%s}", indent);
return;
case JSMN_UNDEFINED:
break;
}
abort();
}
/* Always returns a positive number < len. len must be > 0! */
static size_t read_nofail(int fd, void *buf, size_t len)
{
ssize_t i;
assert(len > 0);
i = read(fd, buf, len);
if (i == 0)
errx(ERROR_TALKING_TO_LIGHTNINGD,
"reading response: socket closed");
else if (i < 0)
err(ERROR_TALKING_TO_LIGHTNINGD, "reading response");
return i;
}
/* We rely on the fact that lightningd terminates all JSON RPC responses with
* "\n\n", so we can stream even if we can't parse. */
static void oom_dump(int fd, char *resp, size_t off)
{
warnx("Out of memory: sending raw output");
/* Note: resp does not already end in '\n\n', and resp_len is > 0 */
do {
/* Keep last char, to avoid splitting \n\n */
write_all(STDOUT_FILENO, resp, off-1);
resp[0] = resp[off-1];
off = 1 + read_nofail(fd, resp + 1, tal_bytelen(resp) - 1);
} while (resp[off-2] != '\n' || resp[off-1] != '\n');
write_all(STDOUT_FILENO, resp, off-1);
/* We assume giant answer means "success" */
exit(0);
}
/* We want to return failure if tal_resize fails */
static void tal_error(const char *msg)
{
if (streq(msg, "Reallocation failure"))
return;
abort();
}
static enum format delete_format_hint(const char *resp, jsmntok_t **toks)
{
const jsmntok_t *result = json_get_member(resp, *toks, "result");
const jsmntok_t *hint;
enum format format = JSON;
if (!result)
return format;
hint = json_get_member(resp, result, "format-hint");
if (!hint)
return format;
if (json_tok_streq(resp, hint, "simple"))
format = HUMAN;
/* Don't let hint appear in the output! */
/* Note the aritmetic on *toks for const-washing */
json_tok_remove(toks, *toks + (result - *toks), hint-1, 1);
return format;
}
static enum format choose_format(const char *resp,
jsmntok_t **toks,
const char *method,
const char *command,
enum format format)
{
/* If they specify a format, that's what we use. */
if (format != DEFAULT_FORMAT) {
/* But humans don't want to see the format hint! */
if (format == HUMAN)
delete_format_hint(resp, toks);
return format;
}
/* This works best when we order it. */
if (streq(method, "help") && command == NULL)
format = HELPLIST;
else
format = delete_format_hint(resp, toks);
return format;
}
int main(int argc, char *argv[])
{
setup_locale();
int fd, i;
size_t off;
const char *method;
char *cmd, *resp, *idstr;
struct sockaddr_un addr;
jsmntok_t *toks;
const jsmntok_t *result, *error, *id;
const tal_t *ctx = tal(NULL, char);
char *config_filename, *lightning_dir, *net_dir, *rpc_filename;
jsmn_parser parser;
int parserr;
enum format format = DEFAULT_FORMAT;
enum input input = DEFAULT_INPUT;
char *command = NULL;
err_set_progname(argv[0]);
jsmn_init(&parser);
tal_set_backend(NULL, NULL, NULL, tal_error);
setup_option_allocators();
initial_config_opts(ctx, argc, argv,
&config_filename, &lightning_dir, &net_dir,
&rpc_filename);
opt_register_noarg("--help|-h", opt_usage_and_exit,
"<command> [<params>...]", "Show this message. Use the command help (without hyphens -- \"lightning-cli help\") to get a list of all RPC commands");
opt_register_noarg("-H|--human-readable", opt_set_human, &format,
"Human-readable output");
opt_register_noarg("-F|--flat", opt_set_flat, &format,
"Flatten output ('x.y.x=' format)");
opt_register_noarg("-J|--json", opt_set_json, &format,
"JSON output (default unless 'help')");
opt_register_noarg("-R|--raw", opt_set_raw, &format,
"Raw, unformatted JSON output");
opt_register_noarg("-k|--keywords", opt_set_keywords, &input,
"Use format key=value for <params>");
opt_register_noarg("-o|--order", opt_set_ordered, &input,
"Use params in order for <params>");
opt_register_version();
opt_early_parse(argc, argv, opt_log_stderr_exit);
opt_parse(&argc, argv, opt_log_stderr_exit);
method = argv[1];
if (!method) {
char *usage = opt_usage(argv[0], NULL);
printf("%s\n", usage);
tal_free(usage);
printf("Querying lightningd for available RPC commands (\"lightning-cli help\"):\n\n");
method = "help";
}
/* Launch a manpage if we have a help command with an argument. We do
* not need to have lightningd running in this case. */
if (streq(method, "help") && format == DEFAULT_FORMAT && argc >= 3) {
command = argv[2];
char *page = tal_fmt(ctx, "lightning-%s", command);
try_exec_man(page, NULL);
/* Try to find the page relative to this executable.
* This handles the common scenario where lightning-cli
* was built from source and hasn't been installed yet */
try_exec_man(page, dirname(argv[0]));
tal_free(page);
}
/* If an absolute path to the RPC socket is given, it takes over other
* configuration options. */
if (path_is_abs(rpc_filename)) {
net_dir = path_dirname(ctx, rpc_filename);
rpc_filename = path_basename(ctx, rpc_filename);
}
if (chdir(net_dir) != 0)
err(ERROR_TALKING_TO_LIGHTNINGD, "Moving into '%s'",
net_dir);
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (strlen(rpc_filename) + 1 > sizeof(addr.sun_path))
errx(ERROR_USAGE, "rpc filename '%s' too long", rpc_filename);
strcpy(addr.sun_path, rpc_filename);
addr.sun_family = AF_UNIX;
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0)
err(ERROR_TALKING_TO_LIGHTNINGD,
"Connecting to '%s'", rpc_filename);
idstr = tal_fmt(ctx, "lightning-cli-%i", getpid());
cmd = tal_fmt(ctx,
"{ \"jsonrpc\" : \"2.0\", \"method\" : \"%s\", \"id\" : \"%s\", \"params\" :",
json_escape(ctx, method)->s, idstr);
if (input == DEFAULT_INPUT) {
/* Hacky autodetect; only matters if more than single arg */
if (argc > 2 && strchr(argv[2], '='))
input = KEYWORDS;
else
input = ORDERED;
}
if (input == KEYWORDS) {
tal_append_fmt(&cmd, "{ ");
for (i = 2; i < argc; i++) {
const char *eq = strchr(argv[i], '=');
if (!eq)
err(ERROR_USAGE, "Expected key=value in '%s'",
argv[i]);
tal_append_fmt(&cmd, "\"%.*s\" : ",
(int)(eq - argv[i]), argv[i]);
add_input(&cmd, eq + 1, i, argc);
}
tal_append_fmt(&cmd, "} }");
} else {
tal_append_fmt(&cmd, "[ ");
for (i = 2; i < argc; i++)
add_input(&cmd, argv[i], i, argc);
tal_append_fmt(&cmd, "] }");
}
if (!write_all(fd, cmd, strlen(cmd)))
err(ERROR_TALKING_TO_LIGHTNINGD, "Writing command");
/* Start with 1000 characters, 100 tokens. */
resp = tal_arr(ctx, char, 1000);
toks = tal_arr(ctx, jsmntok_t, 100);
off = 0;
parserr = 0;
while (parserr <= 0) {
/* Read more if parser says, or we have 0 tokens. */
if (parserr == 0 || parserr == JSMN_ERROR_PART) {
ssize_t i = read(fd, resp + off, tal_bytelen(resp) - 1 - off);
if (i == 0)
errx(ERROR_TALKING_TO_LIGHTNINGD,
"reading response: socket closed");
else if (i < 0)
err(ERROR_TALKING_TO_LIGHTNINGD,
"reading response");
off += i;
/* NUL terminate */
resp[off] = '\0';
}
/* (Continue) parsing */
parserr = jsmn_parse(&parser, resp, off, toks, tal_count(toks));
switch (parserr) {
case JSMN_ERROR_INVAL:
errx(ERROR_TALKING_TO_LIGHTNINGD,
"Malformed response '%s'", resp);
case JSMN_ERROR_NOMEM: {
/* Need more tokens, double it */
if (!tal_resize(&toks, tal_count(toks) * 2))
oom_dump(fd, resp, off);
break;
}
case JSMN_ERROR_PART:
/* Need more data: make room if necessary */
if (off == tal_bytelen(resp) - 1) {
if (!tal_resize(&resp, tal_count(resp) * 2))
oom_dump(fd, resp, off);
}
break;
}
}
if (toks->type != JSMN_OBJECT)
errx(ERROR_TALKING_TO_LIGHTNINGD,
"Non-object response '%s'", resp);
/* This can rellocate toks, so call before getting pointers to tokens */
format = choose_format(resp, &toks, method, command, format);
result = json_get_member(resp, toks, "result");
error = json_get_member(resp, toks, "error");
if (!error && !result)
errx(ERROR_TALKING_TO_LIGHTNINGD,
"Either 'result' or 'error' must be returned in response '%s'", resp);
id = json_get_member(resp, toks, "id");
if (!id)
errx(ERROR_TALKING_TO_LIGHTNINGD,
"Missing 'id' in response '%s'", resp);
if (!json_tok_streq(resp, id, idstr))
errx(ERROR_TALKING_TO_LIGHTNINGD,
"Incorrect 'id' in response: %.*s",
json_tok_full_len(id), json_tok_full(resp, id));
if (!error || json_tok_is_null(resp, error)) {
switch (format) {
case HELPLIST:
human_help(resp, result);
break;
case HUMAN:
human_readable(resp, result, '\n');
break;
case FLAT:
flat_json("", resp, result);
break;
case JSON:
print_json(resp, result, "");
printf("\n");
break;
case RAW:
printf("%.*s\n",
json_tok_full_len(result),
json_tok_full(resp, result));
break;
default:
abort();
}
tal_free(ctx);
opt_free_table();
return 0;
}
if (format == RAW)
printf("%.*s\n",
json_tok_full_len(error), json_tok_full(resp, error));
else {
print_json(resp, error, "");
printf("\n");
}
tal_free(ctx);
opt_free_table();
return 1;
}