mirrors/core-lightning
1
0
Fork 0
mirror of https://github.com/ElementsProject/lightning.git synced 2025-01-18 21:35:11 +01:00
Code Issues Projects Releases Wiki Activity

json-rpc: make commands return 'struct command_result *'.

Browse Source 
Usually, this means they return 'command_param_failed()' if param()
fails, and changing 'command_success(); return;' to 'return
command_success()'.

Occasionally, it's more complex: there's a command_its_complicated()
for the case where we can't exactly determine what the status is,
but it should be considered a last resort.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell 2018-12-16 15:22:06 +10:30
parent 1ede7bc55b
commit 68bb36b210
19 changed files with 516 additions and 539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lightningd/chaintopology.c
View File

@ -463,10 +463,10 @@ u32 feerate_to_style(u32 feerate_perkw, enum feerate_style style)
abort();
}
static void json_feerates(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_feerates(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct chain_topology *topo = cmd->ld->topology;
struct json_stream *response;
@ -477,7 +477,7 @@ static void json_feerates(struct command *cmd,
if (!param(cmd, buffer, params,
p_req("style", param_feerate_style, &style),
NULL))
return;
return command_param_failed();
missing = false;
for (size_t i = 0; i < ARRAY_SIZE(feerates); i++) {
@ -520,7 +520,7 @@ static void json_feerates(struct command *cmd,
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command feerates_command = {

48
lightningd/connect_control.c
View File

@ -65,19 +65,20 @@ static struct connect *find_connect(struct lightningd *ld,
return NULL;
}
static void connect_cmd_succeed(struct command *cmd, const struct pubkey *id)
static struct command_result *connect_cmd_succeed(struct command *cmd,
const struct pubkey *id)
{
struct json_stream *response = json_stream_success(cmd);
json_object_start(response, NULL);
json_add_pubkey(response, "id", id);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static void json_connect(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_connect(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u32 *port;
jsmntok_t *idtok;
@ -96,7 +97,7 @@ static void json_connect(struct command *cmd,
p_opt("host", param_string, &name),
p_opt("port", param_number, &port),
NULL))
return;
return command_param_failed();
/* Check for id@addrport form */
id_str = json_strdup(cmd, buffer, idtok);
@ -109,18 +110,16 @@ static void json_connect(struct command *cmd,
}
if (!json_to_pubkey(buffer, idtok, &id)) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"id %.*s not valid",
json_tok_full_len(idtok),
json_tok_full(buffer, idtok));
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"id %.*s not valid",
json_tok_full_len(idtok),
json_tok_full(buffer, idtok));
}
if (name && ataddr) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can't specify host as both xxx@yyy "
"and separate argument");
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can't specify host as both xxx@yyy "
"and separate argument");
}
/* Get parseable host if provided somehow */
@ -129,9 +128,8 @@ static void json_connect(struct command *cmd,
/* Port without host name? */
if (port && !name) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can't specify port without host");
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can't specify port without host");
}
/* If we know about peer, see if it's already connected. */
@ -141,8 +139,7 @@ static void json_connect(struct command *cmd,
if (peer->uncommitted_channel
|| (channel && channel->connected)) {
connect_cmd_succeed(cmd, &id);
return;
return connect_cmd_succeed(cmd, &id);
}
}
@ -159,9 +156,10 @@ static void json_connect(struct command *cmd,
&& !cmd->ld->pure_tor_setup,
true,
&err_msg)) {
command_fail(cmd, LIGHTNINGD, "Host %s:%u not valid: %s",
name, *port, err_msg ? err_msg : "port is 0");
return;
return command_fail(cmd, LIGHTNINGD,
"Host %s:%u not valid: %s",
name, *port,
err_msg ? err_msg : "port is 0");
}
} else
addr = NULL;
@ -171,7 +169,7 @@ static void json_connect(struct command *cmd,
/* Leave this here for peer_connected or connect_failed. */
new_connect(cmd->ld, &id, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command connect_command = {

101
lightningd/gossip_control.c
View File

@ -244,10 +244,10 @@ static void json_getnodes_reply(struct subd *gossip UNUSED, const u8 *reply,
command_success(cmd, response);
}
static void json_listnodes(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listnodes(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u8 *req;
struct pubkey *id;
@ -255,11 +255,11 @@ static void json_listnodes(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt("id", param_pubkey, &id),
NULL))
return;
return command_param_failed();
req = towire_gossip_getnodes_request(cmd, id);
subd_req(cmd, cmd->ld->gossip, req, -1, 0, json_getnodes_reply, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command listnodes_command = {
@ -289,10 +289,10 @@ static void json_getroute_reply(struct subd *gossip UNUSED, const u8 *reply, con
command_success(cmd, response);
}
static void json_getroute(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_getroute(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct lightningd *ld = cmd->ld;
struct pubkey *destination;
@ -318,7 +318,7 @@ static void json_getroute(struct command *cmd,
p_opt("seed", param_tok, &seedtok),
p_opt_def("fuzzpercent", param_percent, &fuzz, 75.0),
NULL))
return;
return command_param_failed();
/* Convert from percentage */
*fuzz = *fuzz / 100.0;
@ -338,7 +338,7 @@ static void json_getroute(struct command *cmd,
*msatoshi, *riskfactor * 1000,
*cltv, fuzz, &seed);
subd_req(ld->gossip, ld->gossip, req, -1, 0, json_getroute_reply, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command getroute_command = {
@ -399,22 +399,22 @@ static void json_listchannels_reply(struct subd *gossip UNUSED, const u8 *reply,
command_success(cmd, response);
}
static void json_listchannels(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listchannels(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u8 *req;
struct short_channel_id *id;
if (!param(cmd, buffer, params,
p_opt("short_channel_id", param_short_channel_id, &id),
NULL))
return;
return command_param_failed();
req = towire_gossip_getchannels_request(cmd, id);
subd_req(cmd->ld->gossip, cmd->ld->gossip,
req, -1, 0, json_listchannels_reply, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command listchannels_command = {
@ -450,10 +450,10 @@ static void json_scids_reply(struct subd *gossip UNUSED, const u8 *reply,
command_success(cmd, response);
}
static void json_dev_query_scids(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_dev_query_scids(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u8 *msg;
const jsmntok_t *scidstok;
@ -466,17 +466,16 @@ static void json_dev_query_scids(struct command *cmd,
p_req("id", param_pubkey, &id),
p_req("scids", param_array, &scidstok),
NULL))
return;
return command_param_failed();
scids = tal_arr(cmd, struct short_channel_id, scidstok->size);
end = json_next(scidstok);
for (i = 0, t = scidstok + 1; t < end; t = json_next(t), i++) {
if (!json_to_short_channel_id(buffer, t, &scids[i])) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"scid %zu '%.*s' is not an scid",
i, json_tok_full_len(t),
json_tok_full(buffer, t));
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"scid %zu '%.*s' is not an scid",
i, json_tok_full_len(t),
json_tok_full(buffer, t));
}
}
@ -484,7 +483,7 @@ static void json_dev_query_scids(struct command *cmd,
msg = towire_gossip_query_scids(cmd, id, scids);
subd_req(cmd->ld->gossip, cmd->ld->gossip,
take(msg), -1, 0, json_scids_reply, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command dev_query_scids_command = {
@ -494,10 +493,11 @@ static const struct json_command dev_query_scids_command = {
};
AUTODATA(json_command, &dev_query_scids_command);
static void json_dev_send_timestamp_filter(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *
json_dev_send_timestamp_filter(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u8 *msg;
struct pubkey *id;
@ -508,14 +508,14 @@ static void json_dev_send_timestamp_filter(struct command *cmd,
p_req("first", param_number, &first),
p_req("range", param_number, &range),
NULL))
return;
return command_param_failed();
log_debug(cmd->ld->log, "Setting timestamp range %u+%u", *first, *range);
/* Tell gossipd, since this is a gossip query. */
msg = towire_gossip_send_timestamp_filter(NULL, id, *first, *range);
subd_send_msg(cmd->ld->gossip, take(msg));
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command dev_send_timestamp_filter = {
@ -564,7 +564,7 @@ static void json_channel_range_reply(struct subd *gossip UNUSED, const u8 *reply
command_success(cmd, response);
}
static void json_dev_query_channel_range(struct command *cmd,
static struct command_result *json_dev_query_channel_range(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
@ -578,13 +578,13 @@ static void json_dev_query_channel_range(struct command *cmd,
p_req("first", param_number, &first),
p_req("num", param_number, &num),
NULL))
return;
return command_param_failed();
/* Tell gossipd, since this is a gossip query. */
msg = towire_gossip_query_channel_range(cmd, id, *first, *num);
subd_req(cmd->ld->gossip, cmd->ld->gossip,
take(msg), -1, 0, json_channel_range_reply, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command dev_query_channel_range_command = {
@ -594,10 +594,11 @@ static const struct json_command dev_query_channel_range_command = {
};
AUTODATA(json_command, &dev_query_channel_range_command);
static void json_dev_set_max_scids_encode_size(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *
json_dev_set_max_scids_encode_size(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u8 *msg;
u32 *max;
@ -605,12 +606,12 @@ static void json_dev_set_max_scids_encode_size(struct command *cmd,
if (!param(cmd, buffer, params,
p_req("max", param_number, &max),
NULL))
return;
return command_param_failed();
msg = towire_gossip_dev_set_max_scids_encode_size(NULL, *max);
subd_send_msg(cmd->ld->gossip, take(msg));
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command dev_set_max_scids_encode_size = {
@ -620,17 +621,17 @@ static const struct json_command dev_set_max_scids_encode_size = {
};
AUTODATA(json_command, &dev_set_max_scids_encode_size);
static void json_dev_suppress_gossip(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_dev_suppress_gossip(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
subd_send_msg(cmd->ld->gossip, take(towire_gossip_dev_suppress(NULL)));
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command dev_suppress_gossip = {

176
lightningd/invoice.c
View File

@ -62,7 +62,8 @@ static void json_add_invoice(struct json_stream *response,
json_object_end(response);
}
static void tell_waiter(struct command *cmd, const struct invoice *inv)
static struct command_result *tell_waiter(struct command *cmd,
const struct invoice *inv)
{
struct json_stream *response;
const struct invoice_details *details;
@ -71,13 +72,13 @@ static void tell_waiter(struct command *cmd, const struct invoice *inv)
if (details->state == PAID) {
response = json_stream_success(cmd);
json_add_invoice(response, details);
command_success(cmd, response);
return command_success(cmd, response);
} else {
/* FIXME: -2 should be a constant in jsonrpc_errors.h. */
response = json_stream_fail(cmd, -2,
"invoice expired during wait");
json_add_invoice(response, details);
command_failed(cmd, response);
return command_failed(cmd, response);
}
}
@ -111,9 +112,10 @@ static bool hsm_sign_b11(const u5 *u5bytes,
return true;
}
static bool parse_fallback(struct command *cmd,
const char *buffer, const jsmntok_t *fallback,
const u8 **fallback_script)
static struct command_result *parse_fallback(struct command *cmd,
const char *buffer,
const jsmntok_t *fallback,
const u8 **fallback_script)
{
enum address_parse_result fallback_parse;
@ -124,15 +126,14 @@ static bool parse_fallback(struct command *cmd,
buffer, fallback,
fallback_script);
if (fallback_parse == ADDRESS_PARSE_UNRECOGNIZED) {
command_fail(cmd, LIGHTNINGD, "Fallback address not valid");
return false;
return command_fail(cmd, LIGHTNINGD,
"Fallback address not valid");
} else if (fallback_parse == ADDRESS_PARSE_WRONG_NETWORK) {
command_fail(cmd, LIGHTNINGD,
"Fallback address does not match our network %s",
get_chainparams(cmd->ld)->network_name);
return false;
return command_fail(cmd, LIGHTNINGD,
"Fallback address does not match our network %s",
get_chainparams(cmd->ld)->network_name);
}
return true;
return NULL;
}
/* BOLT11 struct wants an array of arrays (can provide multiple routes) */
@ -291,10 +292,10 @@ static void gossipd_incoming_channels_reply(struct subd *gossipd,
command_success(info->cmd, response);
}
static void json_invoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_invoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
const jsmntok_t *fallbacks;
const jsmntok_t *preimagetok;
@ -316,23 +317,21 @@ static void json_invoice(struct command *cmd,
p_opt("fallbacks", param_array, &fallbacks),
p_opt("preimage", param_tok, &preimagetok),
NULL))
return;
return command_param_failed();
if (strlen(info->label->s) > INVOICE_MAX_LABEL_LEN) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Label '%s' over %u bytes", info->label->s,
INVOICE_MAX_LABEL_LEN);
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Label '%s' over %u bytes", info->label->s,
INVOICE_MAX_LABEL_LEN);
}
if (strlen(desc_val) >= BOLT11_FIELD_BYTE_LIMIT) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Descriptions greater than %d bytes "
"not yet supported "
"(description length %zu)",
BOLT11_FIELD_BYTE_LIMIT,
strlen(desc_val));
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Descriptions greater than %d bytes "
"not yet supported "
"(description length %zu)",
BOLT11_FIELD_BYTE_LIMIT,
strlen(desc_val));
}
if (fallbacks) {
@ -340,9 +339,11 @@ static void json_invoice(struct command *cmd,
fallback_scripts = tal_arr(cmd, const u8 *, 0);
for (i = fallbacks + 1; i < end; i = json_next(i)) {
if (!parse_fallback(cmd, buffer, i,
tal_arr_expand(&fallback_scripts)))
return;
struct command_result *r;
r = parse_fallback(cmd, buffer, i,
tal_arr_expand(&fallback_scripts));
if (r)
return r;
}
}
@ -352,9 +353,8 @@ static void json_invoice(struct command *cmd,
preimagetok->end - preimagetok->start,
&info->payment_preimage,
sizeof(info->payment_preimage))) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"preimage must be 64 hex digits");
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"preimage must be 64 hex digits");
}
} else
/* Generate random secret preimage. */
@ -381,7 +381,7 @@ static void json_invoice(struct command *cmd,
take(towire_gossip_get_incoming_channels(NULL)),
-1, 0, gossipd_incoming_channels_reply, info);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command invoice_command = {
@ -416,10 +416,10 @@ static void json_add_invoices(struct json_stream *response,
}
}
static void json_listinvoices(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listinvoices(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_escaped *label;
struct json_stream *response;
@ -427,14 +427,14 @@ static void json_listinvoices(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt("label", param_label, &label),
NULL))
return;
return command_param_failed();
response = json_stream_success(cmd);
json_object_start(response, NULL);
json_array_start(response, "invoices");
json_add_invoices(response, wallet, label);
json_array_end(response);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command listinvoices_command = {
@ -444,10 +444,10 @@ static const struct json_command listinvoices_command = {
};
AUTODATA(json_command, &listinvoices_command);
static void json_delinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_delinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct invoice i;
const struct invoice_details *details;
@ -460,11 +460,10 @@ static void json_delinvoice(struct command *cmd,
p_req("label", param_label, &label),
p_req("status", param_string, &status),
NULL))
return;
return command_param_failed();
if (!wallet_invoice_find_by_label(wallet, &i, label)) {
command_fail(cmd, LIGHTNINGD, "Unknown invoice");
return;
return command_fail(cmd, LIGHTNINGD, "Unknown invoice");
}
details = wallet_invoice_details(cmd, cmd->ld->wallet, i);
@ -473,22 +472,21 @@ static void json_delinvoice(struct command *cmd,
* might not make sense if it changed! */
actual_status = invoice_status_str(details);
if (!streq(actual_status, status)) {
command_fail(cmd, LIGHTNINGD, "Invoice status is %s not %s",
actual_status, status);
return;
return command_fail(cmd, LIGHTNINGD,
"Invoice status is %s not %s",
actual_status, status);
}
if (!wallet_invoice_delete(wallet, i)) {
log_broken(cmd->ld->log,
"Error attempting to remove invoice %"PRIu64,
i.id);
command_fail(cmd, LIGHTNINGD, "Database error");
return;
return command_fail(cmd, LIGHTNINGD, "Database error");
}
response = json_stream_success(cmd);
json_add_invoice(response, details);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command delinvoice_command = {
@ -498,10 +496,10 @@ static const struct json_command delinvoice_command = {
};
AUTODATA(json_command, &delinvoice_command);
static void json_delexpiredinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_delexpiredinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u64 *maxexpirytime;
@ -509,11 +507,11 @@ static void json_delexpiredinvoice(struct command *cmd,
p_opt_def("maxexpirytime", param_u64, &maxexpirytime,
time_now().ts.tv_sec),
NULL))
return;
return command_param_failed();
wallet_invoice_delete_expired(cmd->ld->wallet, *maxexpirytime);
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command delexpiredinvoice_command = {
"delexpiredinvoice",
@ -522,10 +520,10 @@ static const struct json_command delexpiredinvoice_command = {
};
AUTODATA(json_command, &delexpiredinvoice_command);
static void json_autocleaninvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_autocleaninvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u64 *cycle;
u64 *exby;
@ -534,11 +532,11 @@ static void json_autocleaninvoice(struct command *cmd,
p_opt_def("cycle_seconds", param_u64, &cycle, 3600),
p_opt_def("expired_by", param_u64, &exby, 86400),
NULL))
return;
return command_param_failed();
wallet_invoice_autoclean(cmd->ld->wallet, *cycle, *exby);
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command autocleaninvoice_command = {
"autocleaninvoice",
@ -549,10 +547,10 @@ static const struct json_command autocleaninvoice_command = {
};
AUTODATA(json_command, &autocleaninvoice_command);
static void json_waitanyinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_waitanyinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u64 *pay_index;
struct wallet *wallet = cmd->ld->wallet;
@ -560,7 +558,7 @@ static void json_waitanyinvoice(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt_def("lastpay_index", param_u64, &pay_index, 0),
NULL))
return;
return command_param_failed();
/* Set command as pending. We do not know if
* wallet_invoice_waitany will return immediately
@ -570,6 +568,8 @@ static void json_waitanyinvoice(struct command *cmd,
/* Find next paid invoice. */
wallet_invoice_waitany(cmd, wallet, *pay_index,
&wait_on_invoice, (void*) cmd);
return command_its_complicated();
}
static const struct json_command waitanyinvoice_command = {
@ -585,10 +585,10 @@ AUTODATA(json_command, &waitanyinvoice_command);
* already been received or it may add the `cmd` to the list of
* waiters, if the payment is still pending.
*/
static void json_waitinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_waitinvoice(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct invoice i;
const struct invoice_details *details;
@ -598,23 +598,22 @@ static void json_waitinvoice(struct command *cmd,
if (!param(cmd, buffer, params,
p_req("label", param_label, &label),
NULL))
return;
return command_param_failed();
if (!wallet_invoice_find_by_label(wallet, &i, label)) {
command_fail(cmd, LIGHTNINGD, "Label not found");
return;
return command_fail(cmd, LIGHTNINGD, "Label not found");
}
details = wallet_invoice_details(cmd, cmd->ld->wallet, i);
/* If paid or expired return immediately */
if (details->state == PAID || details->state == EXPIRED) {
tell_waiter(cmd, &i);
return;
return tell_waiter(cmd, &i);
} else {
/* There is an unpaid one matching, let's wait... */
command_still_pending(cmd);
wallet_invoice_waitone(cmd, wallet, i,
&wait_on_invoice, (void *) cmd);
return command_its_complicated();
}
}
@ -660,10 +659,10 @@ static void json_add_fallback(struct json_stream *response,
json_object_end(response);
}
static void json_decodepay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_decodepay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct bolt11 *b11;
struct json_stream *response;
@ -674,13 +673,12 @@ static void json_decodepay(struct command *cmd,
p_req("bolt11", param_string, &str),
p_opt("description", param_string, &desc),
NULL))
return;
return command_param_failed();
b11 = bolt11_decode(cmd, str, desc, &fail);
if (!b11) {
command_fail(cmd, LIGHTNINGD, "Invalid bolt11: %s", fail);
return;
return command_fail(cmd, LIGHTNINGD, "Invalid bolt11: %s", fail);
}
response = json_stream_success(cmd);
@ -766,7 +764,7 @@ static void json_decodepay(struct command *cmd,
type_to_string(cmd, secp256k1_ecdsa_signature,
&b11->sig));
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command decodepay_command = {

141
lightningd/jsonrpc.c
View File

@ -147,10 +147,10 @@ static void destroy_jcon(struct json_connection *jcon)
tal_free(jcon->log);
}
static void json_help(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params);
static struct command_result *json_help(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params);
static const struct json_command help_command = {
"help",
@ -166,21 +166,21 @@ static const struct json_command help_command = {
};
AUTODATA(json_command, &help_command);
static void json_stop(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_stop(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
/* This can't have closed yet! */
cmd->jcon->stop = true;
response = json_stream_success(cmd);
json_add_string(response, NULL, "Shutting down");
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command stop_command = {
@ -191,10 +191,10 @@ static const struct json_command stop_command = {
AUTODATA(json_command, &stop_command);
#if DEVELOPER
static void json_rhash(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNUSED,
const jsmntok_t *params)
static struct command_result *json_rhash(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNUSED,
const jsmntok_t *params)
{
struct json_stream *response;
struct sha256 *secret;
@ -202,7 +202,7 @@ static void json_rhash(struct command *cmd,
if (!param(cmd, buffer, params,
p_req("secret", param_sha256, &secret),
NULL))
return;
return command_param_failed();
/* Hash in place. */
sha256(secret, secret, sizeof(*secret));
@ -210,7 +210,7 @@ static void json_rhash(struct command *cmd,
json_object_start(response, NULL);
json_add_hex(response, "rhash", secret, sizeof(*secret));
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command dev_rhash_command = {
@ -231,7 +231,7 @@ static void slowcmd_finish(struct slowcmd *sc)
json_object_start(sc->js, NULL);
json_add_num(sc->js, "msec", *sc->msec);
json_object_end(sc->js);
command_success(sc->cmd, sc->js);
was_pending(command_success(sc->cmd, sc->js));
}
static void slowcmd_start(struct slowcmd *sc)
@ -241,10 +241,10 @@ static void slowcmd_start(struct slowcmd *sc)
slowcmd_finish, sc);
}
static void json_slowcmd(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNUSED,
const jsmntok_t *params)
static struct command_result *json_slowcmd(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNUSED,
const jsmntok_t *params)
{
struct slowcmd *sc = tal(cmd, struct slowcmd);
@ -252,10 +252,10 @@ static void json_slowcmd(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt_def("msec", param_number, &sc->msec, 1000),
NULL))
return;
return command_param_failed();
new_reltimer(&cmd->ld->timers, sc, time_from_msec(0), slowcmd_start, sc);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command dev_slowcmd_command = {
@ -265,13 +265,13 @@ static const struct json_command dev_slowcmd_command = {
};
AUTODATA(json_command, &dev_slowcmd_command);
static void json_crash(struct command *cmd UNUSED,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_crash(struct command *cmd UNUSED,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
fatal("Crash at user request");
}
@ -325,10 +325,10 @@ static void json_add_help_command(struct command *cmd,
}
static void json_help(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_help(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
const jsmntok_t *cmdtok;
@ -337,7 +337,7 @@ static void json_help(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt("command", param_tok, &cmdtok),
NULL))
return;
return command_param_failed();
if (cmdtok) {
for (size_t i = 0; i < tal_count(commands); i++) {
@ -347,11 +347,10 @@ static void json_help(struct command *cmd,
goto done;
}
}
command_fail(cmd, JSONRPC2_METHOD_NOT_FOUND,
"Unknown command '%.*s'",
json_tok_full_len(cmdtok),
json_tok_full(buffer, cmdtok));
return;
return command_fail(cmd, JSONRPC2_METHOD_NOT_FOUND,
"Unknown command '%.*s'",
json_tok_full_len(cmdtok),
json_tok_full(buffer, cmdtok));
}
response = json_stream_success(cmd);
@ -364,7 +363,7 @@ static void json_help(struct command *cmd,
json_object_end(response);
done:
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command *find_cmd(const struct jsonrpc *rpc,
@ -528,15 +527,19 @@ struct json_stream *json_stream_fail(struct command *cmd,
return r;
}
static void parse_request(struct json_connection *jcon, const jsmntok_t tok[])
/* We return struct command_result so command_fail return value has a natural
* sink; we don't actually use the result. */
static struct command_result *
parse_request(struct json_connection *jcon, const jsmntok_t tok[])
{
const jsmntok_t *method, *id, *params;
struct command *c;
struct command_result *res;
if (tok[0].type != JSMN_OBJECT) {
json_command_malformed(jcon, "null",
"Expected {} for json command");
return;
return NULL;
}
method = json_get_member(jcon->buffer, tok, "method");
@ -545,12 +548,12 @@ static void parse_request(struct json_connection *jcon, const jsmntok_t tok[])
if (!id) {
json_command_malformed(jcon, "null", "No id");
return;
return NULL;
}
if (id->type != JSMN_STRING && id->type != JSMN_PRIMITIVE) {
json_command_malformed(jcon, "null",
"Expected string/primitive for id");
return;
return NULL;
}
/* Allocate the command off of the `jsonrpc` object and not
@ -568,41 +571,45 @@ static void parse_request(struct json_connection *jcon, const jsmntok_t tok[])
tal_add_destructor(c, destroy_command);
if (!method || !params) {
command_fail(c, JSONRPC2_INVALID_REQUEST,
method ? "No params" : "No method");
return;
return command_fail(c, JSONRPC2_INVALID_REQUEST,
method ? "No params" : "No method");
}
if (method->type != JSMN_STRING) {
command_fail(c, JSONRPC2_INVALID_REQUEST,
"Expected string for method");
return;
return command_fail(c, JSONRPC2_INVALID_REQUEST,
"Expected string for method");
}
c->json_cmd = find_cmd(jcon->ld->jsonrpc, jcon->buffer, method);
if (!c->json_cmd) {
command_fail(c, JSONRPC2_METHOD_NOT_FOUND,
"Unknown command '%.*s'",
json_tok_full_len(method),
json_tok_full(jcon->buffer, method));
return;
return command_fail(c, JSONRPC2_METHOD_NOT_FOUND,
"Unknown command '%.*s'",
json_tok_full_len(method),
json_tok_full(jcon->buffer, method));
}
if (c->json_cmd->deprecated && !deprecated_apis) {
command_fail(c, JSONRPC2_METHOD_NOT_FOUND,
"Command '%.*s' is deprecated",
method->end - method->start,
jcon->buffer + method->start);
return;
return command_fail(c, JSONRPC2_METHOD_NOT_FOUND,
"Command '%.*s' is deprecated",
method->end - method->start,
jcon->buffer + method->start);
}
db_begin_transaction(jcon->ld->wallet->db);
c->json_cmd->dispatch(c, jcon->buffer, tok, params);
res = c->json_cmd->dispatch(c, jcon->buffer, tok, params);
db_commit_transaction(jcon->ld->wallet->db);
assert(res == &param_failed
|| res == &complete
|| res == &pending
|| res == &unknown);
/* If they didn't complete it, they must call command_still_pending.
* If they completed it, it's freed already. */
if (res == &pending)
assert(c->pending);
list_for_each(&jcon->commands, c, list)
assert(c->pending);
return res;
}
/* Mutual recursion */
@ -1002,10 +1009,10 @@ static void destroy_command_canary(struct command *cmd, bool *failed)
*failed = true;
}
static void json_check(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_check(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
jsmntok_t *mod_params;
const jsmntok_t *name_tok;
@ -1022,7 +1029,7 @@ static void json_check(struct command *cmd,
p_req("command_to_check", param_command, &name_tok),
p_opt_any(),
NULL))
return;
return command_param_failed();
/* Point name_tok to the name, not the value */
if (params->type == JSMN_OBJECT)
@ -1036,13 +1043,13 @@ static void json_check(struct command *cmd,
cmd->json_cmd->dispatch(cmd, buffer, mod_params, mod_params);
if (failed)
return;
return command_its_complicated();
response = json_stream_success(cmd);
json_object_start(response, NULL);
json_add_string(response, "command_to_check", cmd->json_cmd->name);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command check_command = {

8
lightningd/jsonrpc.h
View File

@ -49,10 +49,10 @@ struct command_result;
struct json_command {
const char *name;
void (*dispatch)(struct command *,
const char *buffer,
const jsmntok_t *obj,
const jsmntok_t *params);
struct command_result *(*dispatch)(struct command *,
const char *buffer,
const jsmntok_t *obj,
const jsmntok_t *params);
const char *description;
bool deprecated;
const char *verbose;

12
lightningd/log.c
View File

@ -728,10 +728,10 @@ struct command_result *param_loglevel(struct command *cmd,
return NULL;
}
static void json_getlog(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t * params)
static struct command_result *json_getlog(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t * params)
{
struct json_stream *response;
enum log_level *minlevel;
@ -740,7 +740,7 @@ static void json_getlog(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt_def("level", param_loglevel, &minlevel, LOG_INFORM),
NULL))
return;
return command_param_failed();
response = json_stream_success(cmd);
json_object_start(response, NULL);
@ -749,7 +749,7 @@ static void json_getlog(struct command *cmd,
json_add_num(response, "bytes_max", (unsigned int) log_max_mem(lr));
json_add_log(response, lr, *minlevel);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command getlog_command = {

29
lightningd/memdump.c
View File

@ -62,20 +62,20 @@ static void add_memdump(struct json_stream *response,
json_array_end(response);
}
static void json_memdump(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_memdump(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
response = json_stream_success(cmd);
add_memdump(response, NULL, NULL, cmd);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command dev_memdump_command = {
@ -284,18 +284,17 @@ void opening_memleak_done(struct command *cmd, struct subd *leaker)
}
}
static void json_memleak(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_memleak(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
if (!getenv("LIGHTNINGD_DEV_MEMLEAK")) {
command_fail(cmd, LIGHTNINGD,
"Leak detection needs $LIGHTNINGD_DEV_MEMLEAK");
return;
return command_fail(cmd, LIGHTNINGD,
"Leak detection needs $LIGHTNINGD_DEV_MEMLEAK");
}
/* For simplicity, we mark pending, though an error may complete it
@ -304,6 +303,8 @@ static void json_memleak(struct command *cmd,
/* This calls opening_memleak_done() async when all done. */
opening_dev_memleak(cmd);
return command_its_complicated();
}
static const struct json_command dev_memleak_command = {

38
lightningd/opening_control.c
View File

@ -762,10 +762,10 @@ void opening_peer_no_active_channels(struct peer *peer)
/**
* json_fund_channel - Entrypoint for funding a channel
*/
static void json_fund_channel(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_fund_channel(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct command_result *res;
const jsmntok_t *sattok;
@ -787,47 +787,43 @@ static void json_fund_channel(struct command *cmd,
p_opt("feerate", param_feerate, &feerate_per_kw),
p_opt_def("announce", param_bool, &announce_channel, true),
NULL))
return;
return command_param_failed();
res = param_wtx(&fc->wtx, buffer, sattok, max_funding_satoshi);
if (res)
return;
return res;
if (!feerate_per_kw) {
feerate_per_kw = tal(cmd, u32);
*feerate_per_kw = opening_feerate(cmd->ld->topology);
if (!*feerate_per_kw) {
command_fail(cmd, LIGHTNINGD, "Cannot estimate fees");
return;
return command_fail(cmd, LIGHTNINGD,
"Cannot estimate fees");
}
}
if (*feerate_per_kw < feerate_floor()) {
command_fail(cmd, LIGHTNINGD, "Feerate below feerate floor");
return;
return command_fail(cmd, LIGHTNINGD,
"Feerate below feerate floor");
}
peer = peer_by_id(cmd->ld, id);
if (!peer) {
command_fail(cmd, LIGHTNINGD, "Unknown peer");
return;
return command_fail(cmd, LIGHTNINGD, "Unknown peer");
}
channel = peer_active_channel(peer);
if (channel) {
command_fail(cmd, LIGHTNINGD, "Peer already %s",
channel_state_name(channel));
return;
return command_fail(cmd, LIGHTNINGD, "Peer already %s",
channel_state_name(channel));
}
if (!peer->uncommitted_channel) {
command_fail(cmd, LIGHTNINGD, "Peer not connected");
return;
return command_fail(cmd, LIGHTNINGD, "Peer not connected");
}
if (peer->uncommitted_channel->fc) {
command_fail(cmd, LIGHTNINGD, "Already funding channel");
return;
return command_fail(cmd, LIGHTNINGD, "Already funding channel");
}
/* FIXME: Support push_msat? */
@ -842,7 +838,7 @@ static void json_fund_channel(struct command *cmd,
res = wtx_select_utxos(&fc->wtx, *feerate_per_kw,
BITCOIN_SCRIPTPUBKEY_P2WSH_LEN);
if (res)
return;
return res;
assert(fc->wtx.amount <= max_funding_satoshi);
@ -862,7 +858,7 @@ static void json_fund_channel(struct command *cmd,
/* Openingd will either succeed, or fail, or tell us the other side
* funded first. */
subd_send_msg(peer->uncommitted_channel->openingd, take(msg));
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command fund_channel_command = {

21
lightningd/options.c
View File

@ -1046,10 +1046,10 @@ static void add_config(struct lightningd *ld,
tal_free(name0);
}
static void json_listconfigs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listconfigs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
size_t i;
struct json_stream *response = NULL;
@ -1058,7 +1058,7 @@ static void json_listconfigs(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt("config", param_tok, &configtok),
NULL))
return;
return command_param_failed();
if (!configtok) {
response = json_stream_success(cmd);
@ -1097,14 +1097,13 @@ static void json_listconfigs(struct command *cmd,
}
if (configtok && !response) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Unknown config option '%.*s'",
json_tok_full_len(configtok),
json_tok_full(buffer, configtok));
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Unknown config option '%.*s'",
json_tok_full_len(configtok),
json_tok_full(buffer, configtok));
}
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command listconfigs_command = {

63
lightningd/pay.c
View File

@ -941,10 +941,10 @@ static void json_sendpay_on_resolve(const struct sendpay_result* r,
json_waitsendpay_on_resolve(r, cmd);
}
static void json_sendpay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_sendpay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
const jsmntok_t *routetok;
const jsmntok_t *t, *end;
@ -960,7 +960,7 @@ static void json_sendpay(struct command *cmd,
p_opt("description", param_escaped_string, &description),
p_opt("msatoshi", param_u64, &msatoshi),
NULL))
return;
return command_param_failed();
end = json_next(routetok);
n_hops = 0;
@ -978,7 +978,7 @@ static void json_sendpay(struct command *cmd,
p_req("delay", param_number, &delay),
p_req("channel", param_short_channel_id, &channel),
NULL))
return;
return command_param_failed();
tal_resize(&route, n_hops + 1);
@ -990,8 +990,7 @@ static void json_sendpay(struct command *cmd,
}
if (n_hops == 0) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS, "Empty route");
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "Empty route");
}
/* The given msatoshi is the actual payment that the payee is
@ -1002,10 +1001,9 @@ static void json_sendpay(struct command *cmd,
if (msatoshi) {
if (!(*msatoshi <= route[n_hops-1].amount &&
route[n_hops-1].amount <= 2 * *msatoshi)) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"msatoshi %"PRIu64" out of range",
*msatoshi);
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"msatoshi %"PRIu64" out of range",
*msatoshi);
}
}
@ -1013,7 +1011,8 @@ static void json_sendpay(struct command *cmd,
msatoshi ? *msatoshi : route[n_hops-1].amount,
description,
&json_sendpay_on_resolve, cmd))
command_still_pending(cmd);
return command_still_pending(cmd);
return command_its_complicated();
}
static const struct json_command sendpay_command = {
@ -1028,10 +1027,10 @@ static void waitsendpay_timeout(struct command *cmd)
command_fail(cmd, PAY_IN_PROGRESS, "Timed out while waiting");
}
static void json_waitsendpay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_waitsendpay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct sha256 *rhash;
unsigned int *timeout;
@ -1040,15 +1039,15 @@ static void json_waitsendpay(struct command *cmd,
p_req("payment_hash", param_sha256, &rhash),
p_opt("timeout", param_number, &timeout),
NULL))
return;
return command_param_failed();
if (!wait_payment(cmd, cmd->ld, rhash, &json_waitsendpay_on_resolve, cmd))
return;
return command_its_complicated();
if (timeout)
new_reltimer(&cmd->ld->timers, cmd, time_from_sec(*timeout),
&waitsendpay_timeout, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command waitsendpay_command = {
@ -1059,10 +1058,10 @@ static const struct json_command waitsendpay_command = {
};
AUTODATA(json_command, &waitsendpay_command);
static void json_listpayments(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listpayments(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
const struct wallet_payment **payments;
struct json_stream *response;
@ -1073,13 +1072,12 @@ static void json_listpayments(struct command *cmd,
p_opt("bolt11", param_string, &b11str),
p_opt("payment_hash", param_sha256, &rhash),
NULL))
return;
return command_param_failed();
if (rhash && b11str) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can only specify one of"
" {bolt11} or {payment_hash}");
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Can only specify one of"
" {bolt11} or {payment_hash}");
}
if (b11str) {
@ -1088,9 +1086,8 @@ static void json_listpayments(struct command *cmd,
b11 = bolt11_decode(cmd, b11str, NULL, &fail);
if (!b11) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Invalid bolt11: %s", fail);
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Invalid bolt11: %s", fail);
}
rhash = &b11->payment_hash;
}
@ -1109,7 +1106,7 @@ static void json_listpayments(struct command *cmd,
json_array_end(response);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command listpayments_command = {

39
lightningd/payalgo.c
View File

@ -592,10 +592,10 @@ static void json_pay_stop_retrying(struct pay *pay)
json_pay_failure(pay, sr);
}
static void json_pay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_pay(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
double *riskfactor;
double *maxfeepercent;
@ -619,13 +619,12 @@ static void json_pay(struct command *cmd,
cmd->ld->config.locktime_max),
p_opt_def("exemptfee", param_number, &exemptfee, 5000),
NULL))
return;
return command_param_failed();
b11 = bolt11_decode(pay, b11str, desc, &fail);
if (!b11) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Invalid bolt11: %s", fail);
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"Invalid bolt11: %s", fail);
}
pay->cmd = cmd;
@ -638,16 +637,14 @@ static void json_pay(struct command *cmd,
if (b11->msatoshi) {
if (msatoshi) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"msatoshi parameter unnecessary");
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"msatoshi parameter unnecessary");
}
msatoshi = b11->msatoshi;
} else {
if (!msatoshi) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"msatoshi parameter required");
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"msatoshi parameter required");
}
}
pay->msatoshi = *msatoshi;
@ -655,12 +652,11 @@ static void json_pay(struct command *cmd,
pay->maxfeepercent = *maxfeepercent;
if (*maxdelay < pay->min_final_cltv_expiry) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"maxdelay (%u) must be greater than "
"min_final_cltv_expiry (%"PRIu32") of "
"invoice",
*maxdelay, pay->min_final_cltv_expiry);
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"maxdelay (%u) must be greater than "
"min_final_cltv_expiry (%"PRIu32") of "
"invoice",
*maxdelay, pay->min_final_cltv_expiry);
}
pay->maxdelay = *maxdelay;
@ -688,11 +684,12 @@ static void json_pay(struct command *cmd,
if (json_pay_try(pay))
command_still_pending(cmd);
else
return;
return command_its_complicated();
/* Set up timeout. */
new_reltimer(&cmd->ld->timers, pay, time_from_sec(*retryfor),
&json_pay_stop_retrying, pay);
return command_its_complicated();
}
static const struct json_command pay_command = {

194
lightningd/peer_control.c
View File

@ -803,10 +803,10 @@ static void json_add_peer(struct lightningd *ld,
json_object_end(response);
}
static void json_listpeers(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listpeers(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
enum log_level *ll;
struct pubkey *specific_id;
@ -817,7 +817,7 @@ static void json_listpeers(struct command *cmd,
p_opt("id", param_pubkey, &specific_id),
p_opt("level", param_loglevel, &ll),
NULL))
return;
return command_param_failed();
response = json_stream_success(cmd);
json_object_start(response, NULL);
@ -832,7 +832,7 @@ static void json_listpeers(struct command *cmd,
}
json_array_end(response);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command listpeers_command = {
@ -891,10 +891,10 @@ command_find_channel(struct command *cmd,
}
}
static void json_close(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_close(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
const jsmntok_t *idtok;
struct peer *peer;
@ -907,7 +907,7 @@ static void json_close(struct command *cmd,
p_opt_def("force", param_bool, &force, false),
p_opt_def("timeout", param_number, &timeout, 30),
NULL))
return;
return command_param_failed();
peer = peer_from_json(cmd->ld, buffer, idtok);
if (peer)
@ -915,7 +915,7 @@ static void json_close(struct command *cmd,
else {
channel = command_find_channel(cmd, buffer, idtok);
if (!channel)
return;
return command_its_complicated();
}
if (!channel && peer) {
@ -924,12 +924,10 @@ static void json_close(struct command *cmd,
/* Easy case: peer can simply be forgotten. */
kill_uncommitted_channel(uc, "close command called");
command_success(cmd, null_response(cmd));
return;
return command_success(cmd, null_response(cmd));
}
command_fail(cmd, LIGHTNINGD,
"Peer has no active channel");
return;
return command_fail(cmd, LIGHTNINGD,
"Peer has no active channel");
}
/* Normal case.
@ -941,9 +939,8 @@ static void json_close(struct command *cmd,
channel->state != CHANNELD_AWAITING_LOCKIN &&
channel->state != CHANNELD_SHUTTING_DOWN &&
channel->state != CLOSINGD_SIGEXCHANGE) {
command_fail(cmd, LIGHTNINGD, "Channel is in state %s",
channel_state_name(channel));
return;
return command_fail(cmd, LIGHTNINGD, "Channel is in state %s",
channel_state_name(channel));
}
/* If normal or locking in, transition to shutting down
@ -963,7 +960,7 @@ static void json_close(struct command *cmd,
register_close_command(cmd->ld, cmd, channel, *timeout, *force);
/* Wait until close drops down to chain. */
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command close_command = {
@ -1035,10 +1032,10 @@ void load_channels_from_wallet(struct lightningd *ld)
htlcs_reconnect(ld, &ld->htlcs_in, &ld->htlcs_out);
}
static void json_disconnect(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_disconnect(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct pubkey *id;
struct peer *peer;
@ -1049,32 +1046,28 @@ static void json_disconnect(struct command *cmd,
p_req("id", param_pubkey, &id),
p_opt_def("force", param_bool, &force, false),
NULL))
return;
return command_param_failed();
peer = peer_by_id(cmd->ld, id);
if (!peer) {
command_fail(cmd, LIGHTNINGD, "Peer not connected");
return;
return command_fail(cmd, LIGHTNINGD, "Peer not connected");
}
channel = peer_active_channel(peer);
if (channel) {
if (*force) {
channel_fail_transient(channel,
"disconnect command force=true");
command_success(cmd, null_response(cmd));
return;
return command_success(cmd, null_response(cmd));
}
command_fail(cmd, LIGHTNINGD, "Peer is in state %s",
channel_state_name(channel));
return;
return command_fail(cmd, LIGHTNINGD, "Peer is in state %s",
channel_state_name(channel));
}
if (!peer->uncommitted_channel) {
command_fail(cmd, LIGHTNINGD, "Peer not connected");
return;
return command_fail(cmd, LIGHTNINGD, "Peer not connected");
}
kill_uncommitted_channel(peer->uncommitted_channel,
"disconnect command");
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command disconnect_command = {
@ -1084,10 +1077,10 @@ static const struct json_command disconnect_command = {
};
AUTODATA(json_command, &disconnect_command);
static void json_getinfo(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_getinfo(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
struct peer *peer;
@ -1096,7 +1089,7 @@ static void json_getinfo(struct command *cmd,
inactive_channels = 0, num_peers = 0;
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
response = json_stream_success(cmd);
json_object_start(response, NULL);
@ -1148,7 +1141,7 @@ static void json_getinfo(struct command *cmd,
json_add_u64(response, "msatoshi_fees_collected",
wallet_total_forward_fees(cmd->ld->wallet));
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command getinfo_command = {
@ -1159,10 +1152,10 @@ static const struct json_command getinfo_command = {
AUTODATA(json_command, &getinfo_command);
#if DEVELOPER
static void json_sign_last_tx(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_sign_last_tx(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct pubkey *peerid;
struct peer *peer;
@ -1173,19 +1166,17 @@ static void json_sign_last_tx(struct command *cmd,
if (!param(cmd, buffer, params,
p_req("id", param_pubkey, &peerid),
NULL))
return;
return command_param_failed();
peer = peer_by_id(cmd->ld, peerid);
if (!peer) {
command_fail(cmd, LIGHTNINGD,
"Could not find peer with that id");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not find peer with that id");
}
channel = peer_active_channel(peer);
if (!channel) {
command_fail(cmd, LIGHTNINGD,
"Could not find active channel");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not find active channel");
}
response = json_stream_success(cmd);
@ -1198,7 +1189,7 @@ static void json_sign_last_tx(struct command *cmd,
json_object_start(response, NULL);
json_add_hex_talarr(response, "tx", linear);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command dev_sign_last_tx = {
@ -1208,10 +1199,10 @@ static const struct json_command dev_sign_last_tx = {
};
AUTODATA(json_command, &dev_sign_last_tx);
static void json_dev_fail(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_dev_fail(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct pubkey *peerid;
struct peer *peer;
@ -1220,24 +1211,22 @@ static void json_dev_fail(struct command *cmd,
if (!param(cmd, buffer, params,
p_req("id", param_pubkey, &peerid),
NULL))
return;
return command_param_failed();
peer = peer_by_id(cmd->ld, peerid);
if (!peer) {
command_fail(cmd, LIGHTNINGD,
"Could not find peer with that id");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not find peer with that id");
}
channel = peer_active_channel(peer);
if (!channel) {
command_fail(cmd, LIGHTNINGD,
"Could not find active channel with peer");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not find active channel with peer");
}
channel_internal_error(channel, "Failing due to dev-fail command");
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command dev_fail_command = {
@ -1252,13 +1241,13 @@ static void dev_reenable_commit_finished(struct subd *channeld UNUSED,
const int *fds UNUSED,
struct command *cmd)
{
command_success(cmd, null_response(cmd));
was_pending(command_success(cmd, null_response(cmd)));
}
static void json_dev_reenable_commit(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_dev_reenable_commit(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct pubkey *peerid;
struct peer *peer;
@ -1268,37 +1257,33 @@ static void json_dev_reenable_commit(struct command *cmd,
if (!param(cmd, buffer, params,
p_req("id", param_pubkey, &peerid),
NULL))
return;
return command_param_failed();
peer = peer_by_id(cmd->ld, peerid);
if (!peer) {
command_fail(cmd, LIGHTNINGD,
"Could not find peer with that id");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not find peer with that id");
}
channel = peer_active_channel(peer);
if (!channel) {
command_fail(cmd, LIGHTNINGD,
"Peer has no active channel");
return;
return command_fail(cmd, LIGHTNINGD,
"Peer has no active channel");
}
if (!channel->owner) {
command_fail(cmd, LIGHTNINGD,
"Peer has no owner");
return;
return command_fail(cmd, LIGHTNINGD,
"Peer has no owner");
}
if (!streq(channel->owner->name, "lightning_channeld")) {
command_fail(cmd, LIGHTNINGD,
"Peer owned by %s", channel->owner->name);
return;
return command_fail(cmd, LIGHTNINGD,
"Peer owned by %s", channel->owner->name);
}
msg = towire_channel_dev_reenable_commit(channel);
subd_req(peer, channel->owner, take(msg), -1, 0,
dev_reenable_commit_finished, cmd);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command dev_reenable_commit = {
@ -1347,10 +1332,10 @@ static void process_dev_forget_channel(struct bitcoind *bitcoind UNUSED,
command_success(forget->cmd, response);
}
static void json_dev_forget_channel(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_dev_forget_channel(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct pubkey *peerid;
struct peer *peer;
@ -1365,14 +1350,13 @@ static void json_dev_forget_channel(struct command *cmd,
p_opt("short_channel_id", param_short_channel_id, &scid),
p_opt_def("force", param_bool, &force, false),
NULL))
return;
return command_param_failed();
forget->force = *force;
peer = peer_by_id(cmd->ld, peerid);
if (!peer) {
command_fail(cmd, LIGHTNINGD,
"Could not find channel with that peer");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not find channel with that peer");
}
forget->channel = NULL;
@ -1384,34 +1368,30 @@ static void json_dev_forget_channel(struct command *cmd,
continue;
}
if (forget->channel) {
command_fail(cmd, LIGHTNINGD,
"Multiple channels:"
" please specify short_channel_id");
return;
return command_fail(cmd, LIGHTNINGD,
"Multiple channels:"
" please specify short_channel_id");
}
forget->channel = channel;
}
if (!forget->channel) {
command_fail(cmd, LIGHTNINGD,
"No channels matching that short_channel_id");
return;
return command_fail(cmd, LIGHTNINGD,
"No channels matching that short_channel_id");
}
if (channel_has_htlc_out(forget->channel) ||
channel_has_htlc_in(forget->channel)) {
command_fail(cmd, LIGHTNINGD,
"This channel has HTLCs attached and it is "
"not safe to forget it. Please use `close` "
"or `dev-fail` instead.");
return;
return command_fail(cmd, LIGHTNINGD,
"This channel has HTLCs attached and it is "
"not safe to forget it. Please use `close` "
"or `dev-fail` instead.");
}
bitcoind_gettxout(cmd->ld->topology->bitcoind,
&forget->channel->funding_txid,
forget->channel->funding_outnum,
process_dev_forget_channel, forget);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command dev_forget_channel_command = {

29
lightningd/peer_htlcs.c
View File

@ -1792,10 +1792,10 @@ void htlcs_reconnect(struct lightningd *ld,
#if DEVELOPER
static void json_dev_ignore_htlcs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_dev_ignore_htlcs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct pubkey *peerid;
struct peer *peer;
@ -1805,17 +1805,16 @@ static void json_dev_ignore_htlcs(struct command *cmd,
p_req("id", param_pubkey, &peerid),
p_req("ignore", param_bool, &ignore),
NULL))
return;
return command_param_failed();
peer = peer_by_id(cmd->ld, peerid);
if (!peer) {
command_fail(cmd, LIGHTNINGD,
"Could not find channel with that peer");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not find channel with that peer");
}
peer->ignore_htlcs = *ignore;
command_success(cmd, null_response(cmd));
return command_success(cmd, null_response(cmd));
}
static const struct json_command dev_ignore_htlcs = {
@ -1849,22 +1848,22 @@ static void listforwardings_add_forwardings(struct json_stream *response, struct
tal_free(forwardings);
}
static void json_listforwards(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listforwards(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
response = json_stream_success(cmd);
json_object_start(response, NULL);
listforwardings_add_forwardings(response, cmd->ld->wallet);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command listforwards_command = {

22
lightningd/ping.c
View File

@ -79,10 +79,10 @@ void ping_reply(struct subd *subd, const u8 *msg)
}
}
static void json_ping(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_ping(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
u8 *msg;
unsigned int *len, *pongbytes;
@ -93,7 +93,7 @@ static void json_ping(struct command *cmd,
p_opt_def("len", param_number, &len, 128),
p_opt_def("pongbytes", param_number, &pongbytes, 128),
NULL))
return;
return command_param_failed();
/* BOLT #1:
*
@ -110,16 +110,14 @@ static void json_ping(struct command *cmd,
* * [`byteslen`:`ignored`]
*/
if (*len > 65535 - 2 - 2 - 2) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"%u would result in oversize ping", *len);
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"%u would result in oversize ping", *len);
}
/* Note that > 65531 is valid: it means "no pong reply" */
if (*pongbytes > 65535) {
command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"pongbytes %u > 65535", *pongbytes);
return;
return command_fail(cmd, JSONRPC2_INVALID_PARAMS,
"pongbytes %u > 65535", *pongbytes);
}
/* parent is cmd, so when we complete cmd, we free this. */
@ -128,7 +126,7 @@ static void json_ping(struct command *cmd,
/* gossipd handles all pinging, even if it's in another daemon. */
msg = towire_gossip_ping(NULL, id, *pongbytes, *len);
subd_send_msg(cmd->ld->gossip, take(msg));
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command ping_command = {

11
lightningd/plugin.c
View File

@ -656,9 +656,10 @@ static struct plugin *find_plugin_for_command(struct command *cmd)
abort();
}
static void plugin_rpcmethod_dispatch(struct command *cmd, const char *buffer,
const jsmntok_t *toks,
const jsmntok_t *params UNNEEDED)
static struct command_result *plugin_rpcmethod_dispatch(struct command *cmd,
const char *buffer,
const jsmntok_t *toks,
const jsmntok_t *params UNNEEDED)
{
const jsmntok_t *idtok;
struct plugin *plugin;
@ -668,7 +669,7 @@ static void plugin_rpcmethod_dispatch(struct command *cmd, const char *buffer,
if (cmd->mode == CMD_USAGE) {
/* FIXME! */
cmd->usage = "[params]";
return;
return command_param_failed();
}
plugin = find_plugin_for_command(cmd);
@ -683,7 +684,7 @@ static void plugin_rpcmethod_dispatch(struct command *cmd, const char *buffer,
json_stream_forward_change_id(req->stream, buffer, toks, idtok, id);
plugin_request_queue(plugin, req);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static bool plugin_rpcmethod_add(struct plugin *plugin,

6
lightningd/test/run-invoice-select-inchan.c
View File

@ -49,6 +49,12 @@ struct command_result *command_fail(struct command *cmd UNNEEDED, int code UNNEE
struct command_result *command_failed(struct command *cmd UNNEEDED,
struct json_stream *result UNNEEDED)
{ fprintf(stderr, "command_failed called!\n"); abort(); }
/* Generated stub for command_its_complicated */
struct command_result *command_its_complicated(void)
{ fprintf(stderr, "command_its_complicated called!\n"); abort(); }
/* Generated stub for command_param_failed */
struct command_result *command_param_failed(void)
{ fprintf(stderr, "command_param_failed called!\n"); abort(); }
/* Generated stub for command_still_pending */
struct command_result *command_still_pending(struct command *cmd UNNEEDED)
{ fprintf(stderr, "command_still_pending called!\n"); abort(); }

6
wallet/test/run-wallet.c
View File

@ -55,6 +55,12 @@ struct command_result *command_fail(struct command *cmd UNNEEDED, int code UNNEE
const char *fmt UNNEEDED, ...)
{ fprintf(stderr, "command_fail called!\n"); abort(); }
/* Generated stub for command_its_complicated */
struct command_result *command_its_complicated(void)
{ fprintf(stderr, "command_its_complicated called!\n"); abort(); }
/* Generated stub for command_param_failed */
struct command_result *command_param_failed(void)
{ fprintf(stderr, "command_param_failed called!\n"); abort(); }
/* Generated stub for command_still_pending */
struct command_result *command_still_pending(struct command *cmd UNNEEDED)
{ fprintf(stderr, "command_still_pending called!\n"); abort(); }

99
wallet/walletrpc.c
View File

@ -85,10 +85,10 @@ static void wallet_withdrawal_broadcast(struct bitcoind *bitcoind UNUSED,
* request, select coins and a change key. Then send the request to
* the HSM to generate the signatures.
*/
static void json_withdraw(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_withdraw(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
const jsmntok_t *desttok, *sattok;
struct withdrawal *withdraw = tal(cmd, struct withdrawal);
@ -105,17 +105,17 @@ static void json_withdraw(struct command *cmd,
p_req("satoshi", param_tok, &sattok),
p_opt("feerate", param_feerate, &feerate_per_kw),
NULL))
return;
return command_param_failed();
res = param_wtx(&withdraw->wtx, buffer, sattok, -1ULL);
if (res)
return;
return res;
if (!feerate_per_kw) {
res = param_feerate_estimate(cmd, &feerate_per_kw,
FEERATE_NORMAL);
if (res)
return;
return res;
}
/* Parse address. */
@ -126,22 +126,21 @@ static void json_withdraw(struct command *cmd,
/* Check that destination address could be understood. */
if (addr_parse == ADDRESS_PARSE_UNRECOGNIZED) {
command_fail(cmd, LIGHTNINGD, "Could not parse destination address");
return;
return command_fail(cmd, LIGHTNINGD,
"Could not parse destination address");
}
/* Check address given is compatible with the chain we are on. */
if (addr_parse == ADDRESS_PARSE_WRONG_NETWORK) {
command_fail(cmd, LIGHTNINGD,
"Destination address is not on network %s",
get_chainparams(cmd->ld)->network_name);
return;
return command_fail(cmd, LIGHTNINGD,
"Destination address is not on network %s",
get_chainparams(cmd->ld)->network_name);
}
res = wtx_select_utxos(&withdraw->wtx, *feerate_per_kw,
tal_count(withdraw->destination));
if (res)
return;
return res;
u8 *msg = towire_hsm_sign_withdrawal(cmd,
withdraw->wtx.amount,
@ -164,7 +163,7 @@ static void json_withdraw(struct command *cmd,
withdraw->hextx = tal_hex(withdraw, linearize_tx(cmd, tx));
bitcoind_sendrawtx(cmd->ld->topology->bitcoind, withdraw->hextx,
wallet_withdrawal_broadcast, withdraw);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command withdraw_command = {
@ -248,10 +247,10 @@ static struct command_result *param_newaddr(struct command *cmd,
name, tok->end - tok->start, buffer + tok->start);
}
static void json_newaddr(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_newaddr(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
struct ext_key ext;
@ -263,24 +262,21 @@ static void json_newaddr(struct command *cmd,
if (!param(cmd, buffer, params,
p_opt_def("addresstype", param_newaddr, &is_p2wpkh, true),
NULL))
return;
return command_param_failed();
keyidx = wallet_get_newindex(cmd->ld);
if (keyidx < 0) {
command_fail(cmd, LIGHTNINGD, "Keys exhausted ");
return;
return command_fail(cmd, LIGHTNINGD, "Keys exhausted ");
}
if (bip32_key_from_parent(cmd->ld->wallet->bip32_base, keyidx,
BIP32_FLAG_KEY_PUBLIC, &ext) != WALLY_OK) {
command_fail(cmd, LIGHTNINGD, "Keys generation failure");
return;
return command_fail(cmd, LIGHTNINGD, "Keys generation failure");
}
if (!secp256k1_ec_pubkey_parse(secp256k1_ctx, &pubkey.pubkey,
ext.pub_key, sizeof(ext.pub_key))) {
command_fail(cmd, LIGHTNINGD, "Key parsing failure");
return;
return command_fail(cmd, LIGHTNINGD, "Key parsing failure");
}
txfilter_add_derkey(cmd->ld->owned_txfilter, ext.pub_key);
@ -289,16 +285,15 @@ static void json_newaddr(struct command *cmd,
&pubkey, !*is_p2wpkh,
NULL);
if (!out) {
command_fail(cmd, LIGHTNINGD,
"p2wpkh address encoding failure.");
return;
return command_fail(cmd, LIGHTNINGD,
"p2wpkh address encoding failure.");
}
response = json_stream_success(cmd);
json_object_start(response, NULL);
json_add_string(response, "address", out);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command newaddr_command = {
@ -309,10 +304,10 @@ static const struct json_command newaddr_command = {
};
AUTODATA(json_command, &newaddr_command);
static void json_listaddrs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listaddrs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
struct ext_key ext;
@ -324,7 +319,7 @@ static void json_listaddrs(struct command *cmd,
db_get_intvar(cmd->ld->wallet->db,
"bip32_max_index", 0)),
NULL))
return;
return command_param_failed();
response = json_stream_success(cmd);
json_object_start(response, NULL);
@ -377,7 +372,7 @@ static void json_listaddrs(struct command *cmd,
}
json_array_end(response);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command listaddrs_command = {
@ -389,10 +384,10 @@ static const struct json_command listaddrs_command = {
};
AUTODATA(json_command, &listaddrs_command);
static void json_listfunds(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_listfunds(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct json_stream *response;
struct peer *p;
@ -401,7 +396,7 @@ static void json_listfunds(struct command *cmd,
struct pubkey funding_pubkey;
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
utxos = wallet_get_utxos(cmd, cmd->ld->wallet, output_state_available);
response = json_stream_success(cmd);
@ -422,9 +417,8 @@ static void json_listfunds(struct command *cmd,
utxos[i]->is_p2sh,
NULL);
if (!out) {
command_fail(cmd, LIGHTNINGD,
"p2wpkh address encoding failure.");
return;
return command_fail(cmd, LIGHTNINGD,
"p2wpkh address encoding failure.");
}
json_add_string(response, "address", out);
}
@ -464,7 +458,7 @@ static void json_listfunds(struct command *cmd,
json_array_end(response);
json_object_end(response);
command_success(cmd, response);
return command_success(cmd, response);
}
static const struct json_command listfunds_command = {
@ -517,15 +511,15 @@ static void process_utxo_result(struct bitcoind *bitcoind,
}
}
static void json_dev_rescan_outputs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
static struct command_result *json_dev_rescan_outputs(struct command *cmd,
const char *buffer,
const jsmntok_t *obj UNNEEDED,
const jsmntok_t *params)
{
struct txo_rescan *rescan = tal(cmd, struct txo_rescan);
if (!param(cmd, buffer, params, NULL))
return;
return command_param_failed();
rescan->response = json_stream_success(cmd);
rescan->cmd = cmd;
@ -537,13 +531,12 @@ static void json_dev_rescan_outputs(struct command *cmd,
if (tal_count(rescan->utxos) == 0) {
json_array_end(rescan->response);
json_object_end(rescan->response);
command_success(cmd, rescan->response);
return;
return command_success(cmd, rescan->response);
}
bitcoind_gettxout(cmd->ld->topology->bitcoind, &rescan->utxos[0]->txid,
rescan->utxos[0]->outnum, process_utxo_result,
rescan);
command_still_pending(cmd);
return command_still_pending(cmd);
}
static const struct json_command dev_rescan_output_command = {