#include "config.h"

#include <ccan/array_size/array_size.h>

#include <ccan/ccan/tal/grab_file/grab_file.h>

#include <ccan/crc32c/crc32c.h>

#include <ccan/io/io.h>

#include <ccan/json_escape/json_escape.h>

#include <ccan/json_out/json_out.h>

#include <ccan/pipecmd/pipecmd.h>

#include <ccan/read_write_all/read_write_all.h>

#include <ccan/tal/path/path.h>

#include <ccan/tal/str/str.h>

#include <ccan/utf8/utf8.h>

#include <common/configvar.h>

#include <common/deprecation.h>

#include <common/json_command.h>

#include <common/jsonrpc_io.h>

#include <common/memleak.h>

#include <common/plugin.h>

#include <common/timeout.h>

#include <common/version.h>

#include <connectd/connectd_wiregen.h>

#include <db/exec.h>

#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <lightningd/io_loop_with_timers.h>

#include <lightningd/notification.h>

#include <lightningd/plugin.h>

#include <lightningd/plugin_control.h>

#include <lightningd/plugin_hook.h>

#include <lightningd/subd.h>

# include <plugins/list_of_builtin_plugins_gen.h>

#define PLUGIN_STARTUP_TIMEOUT 120

static void memleak_help_pending_requests(struct htable *memtable,

struct plugin *plugin)

{

memleak_scan_strmap(memtable, &plugin->pending_requests);

}

static const char *state_desc(const struct plugin *plugin)

{

switch (plugin->plugin_state) {

case UNCONFIGURED:

return "unconfigured";

case AWAITING_GETMANIFEST_RESPONSE:

return "before replying to getmanifest";

case NEEDS_INIT:

return "before we sent init";

case AWAITING_INIT_RESPONSE:

return "before replying to init";

case INIT_COMPLETE:

return "during normal operation";

}

fatal("Invalid plugin state %i for %s",

plugin->plugin_state, plugin->cmd);

}

struct plugins *plugins_new(const tal_t *ctx, struct log_book *log_book,

struct lightningd *ld)

{

struct plugins *p;

p = tal(ctx, struct plugins);

list_head_init(&p->plugins);

p->log = new_logger(p, log_book, NULL, "plugin-manager");

p->ld = ld;

p->startup = true;

p->plugin_cmds = tal_arr(p, struct plugin_command *, 0);

p->blacklist = tal_arr(p, const char *, 0);

p->plugin_idx = 0;

p->dev_builtin_plugins_unimportant = false;

p->want_db_transaction = true;

p->dev_save_io = NULL;

p->subscriptions = tal(p, struct plugin_subscription_htable);

plugin_subscription_htable_init(p->subscriptions);

return p;

}

static void plugin_check_subscriptions(struct plugins *plugins,

struct plugin *plugin)

{

for (size_t i = 0; i < tal_count(plugin->subscriptions); i++) {

struct plugin_subscription *sub = &plugin->subscriptions[i];

if (!streq(sub->topic, "*")

&& !notifications_have_topic(plugins, sub->topic))

log_unusual(

plugin->log,

"topic '%s' is not a known notification topic",

sub->topic);

}

}

static bool plugins_any_in_state(const struct plugins *plugins,

enum plugin_state state)

{

const struct plugin *p;

list_for_each(&plugins->plugins, p, list) {

if (p->plugin_state == state)

return true;

}

return false;

}

static bool plugins_all_in_state(const struct plugins *plugins,

enum plugin_state state)

{

const struct plugin *p;

list_for_each(&plugins->plugins, p, list) {

if (p->plugin_state != state)

return false;

}

return true;

}

static void check_plugins_manifests(struct plugins *plugins,

struct logger *log)

{

struct plugin *plugin;

struct plugin **depfail;

if (plugins_any_in_state(plugins, AWAITING_GETMANIFEST_RESPONSE))

return;

/* Now things are settled, try to order hooks. */

depfail = plugin_hooks_make_ordered(tmpctx, log);

for (size_t i = 0; i < tal_count(depfail); i++) {

/* Only complain and free plugins! */

if (depfail[i]->plugin_state != NEEDS_INIT)

continue;

plugin_kill(depfail[i], LOG_UNUSUAL,

"Cannot meet required hook dependencies");

}

/* Check that all the subscriptions are matched with real

list_for_each(&plugins->plugins, plugin, list) {

plugin_check_subscriptions(plugin->plugins, plugin);

}

/* As startup, we break out once all getmanifest are returned */

if (plugins->startup) {

log_debug(plugins->ld->log, "io_break: %s", __func__);

io_break(plugins);

} else

/* Otherwise we go straight into configuring them */

plugins_config(plugins);

}

static void check_plugins_initted(struct plugins *plugins)

{

struct plugin_command **plugin_cmds;

if (!plugins_all_in_state(plugins, INIT_COMPLETE))

return;

/* Clear commands first, in case callbacks add new ones.

plugin_cmds = plugins->plugin_cmds;

plugins->plugin_cmds = tal_arr(plugins, struct plugin_command *, 0);

for (size_t i = 0; i < tal_count(plugin_cmds); i++)

plugin_cmd_all_complete(plugins, plugin_cmds[i]);

tal_free(plugin_cmds);

if (plugins->startup)

io_break(plugins);

}

struct command_result *plugin_register_all_complete(struct lightningd *ld,

struct plugin_command *pcmd)

{

if (plugins_all_in_state(ld->plugins, INIT_COMPLETE))

return plugin_cmd_all_complete(ld->plugins, pcmd);

tal_arr_expand(&ld->plugins->plugin_cmds, pcmd);

return NULL;

}

static void tell_connectd_custommsgs(struct plugins *plugins)

{

struct plugin *p;

u16 *all_msgs = tal_arr(tmpctx, u16, 0);

/* Not when shutting down */

if (!plugins->ld->connectd)

return;

/* Gather from all plugins. */

list_for_each(&plugins->plugins, p, list)

tal_arr_append(&all_msgs, p->custom_msgs);

/* Don't bother sorting or uniquifying. If plugins are dumb, they deserve it. */

subd_send_msg(plugins->ld->connectd,

take(towire_connectd_set_custommsgs(NULL, all_msgs)));

}

static bool request_add(const char *reqid, struct jsonrpc_request *req,

struct jsonrpc_request ***reqs)

{

tal_arr_expand(reqs, tal_steal(*reqs, req));

/* Keep iterating */

return true;

}

static void plugin_response_handle(struct plugin *plugin,

const char *buffer,

const jsmntok_t *toks,

const jsmntok_t *idtok);

static void plugin_terminated_fail_req(struct plugin *plugin,

struct jsonrpc_request *req)

{

jsmntok_t *toks = toks_alloc(plugin);

const jsmntok_t *idtok;

const char *buf;

jsmn_parser parser;

bool complete;

buf = tal_fmt(plugin,

"{\"jsonrpc\": \"2.0\","

"\"id\": %s,"

"\"error\":"

" {\"code\":%i, \"message\":\"%s\"}"

"}\n\n",

req->id,

PLUGIN_TERMINATED,

"Plugin terminated before replying to RPC call.");

jsmn_init(&parser);

if (!json_parse_input(&parser, &toks, buf, strlen(buf), &complete))

abort();

assert(complete);

idtok = json_get_member(buf, toks, "id");

plugin_response_handle(plugin, buf, toks, idtok);

}

static void destroy_plugin(struct plugin *p)

{

struct jsonrpc_request **reqs;

list_del(&p->list);

/* Don't have p->conn destructor run. */

if (p->stdout_conn)

io_set_finish(p->stdout_conn, NULL, NULL);

/* Gather all pending RPC calls (we can't iterate as we delete!) */

reqs = tal_arr(NULL, struct jsonrpc_request *, 0);

strmap_iterate(&p->pending_requests, request_add, &reqs);

/* Don't fail requests if we're exiting anyway! */

if (p->plugins->ld->state != LD_STATE_SHUTDOWN) {

for (size_t i = 0; i < tal_count(reqs); i++)

plugin_terminated_fail_req(p, reqs[i]);

}

/* Now free all the requests */

tal_free(reqs);

/* Remove any topics from the hash table */

for (size_t i = 0; i < tal_count(p->subscriptions); i++) {

plugin_subscription_htable_del(p->plugins->subscriptions,

&p->subscriptions[i]);

}

/* If this was last one manifests were waiting for, handle deps */

if (p->plugin_state == AWAITING_GETMANIFEST_RESPONSE)

check_plugins_manifests(p->plugins, p->plugins->ld->log);

/* Daemon shutdown overrules plugin's importance; aborts init checks */

if (p->plugins->ld->state == LD_STATE_SHUTDOWN) {

/* But return if this was the last plugin! */

if (list_empty(&p->plugins->plugins)) {

log_debug(p->plugins->ld->log, "io_break: %s", __func__);

io_break(destroy_plugin);

}

return;

}

/* If this was the last one init was waiting for, handle cmd replies */

if (p->plugin_state == AWAITING_INIT_RESPONSE)

check_plugins_initted(p->plugins);

/* Now check if the dying plugin is important. */

if (p->important) {

log_broken(p->log,

"Plugin marked as important, "

"shutting down lightningd!");

lightningd_exit(p->plugins->ld, 1);

}

if (tal_count(p->custom_msgs))

tell_connectd_custommsgs(p->plugins);

notify_plugin_stopped(p->plugins->ld, p);

}

static u32 file_checksum(struct lightningd *ld, const char *path)

{

char *content;

u32 crc;

if (ld->dev_no_plugin_checksum)

return 0;

content = grab_file_raw(tmpctx, path);

crc = crc32c(0, content, tal_count(content));

/* We could leave this around, but we checksum many files in a loop,

tal_free(content);

return crc;

}

struct plugin *plugin_register(struct plugins *plugins, const char* path TAKES,

struct plugin_command *start_cmd, bool important,

const char *parambuf STEALS,

const jsmntok_t *params STEALS)

{

struct plugin *p, *p_temp;

char* abspath;

u32 chksum;

abspath = path_canon(tmpctx, path);

if (!abspath) {

return NULL;

}

/* Don't register an already registered plugin */

list_for_each(&plugins->plugins, p_temp, list) {

if (streq(abspath, p_temp->cmd)) {

/* If added as "important", upgrade to "important". */

if (important)

p_temp->important = true;

/* stop and restart plugin on different checksum */

chksum = file_checksum(plugins->ld, path);

if (p_temp->checksum != chksum && !p_temp->important) {

plugin_kill(p_temp, LOG_INFORM,

"Plugin changed, needs restart.");

break;

}

tal_free_if_taken(path);

return NULL;

}

}

p = tal(plugins, struct plugin);

p->plugins = plugins;

p->cmd = tal_steal(p, abspath);

p->checksum = file_checksum(plugins->ld, p->cmd);

p->shortname = path_basename(p, p->cmd);

p->start_cmd = start_cmd;

p->can_check = false;

p->plugin_state = UNCONFIGURED;

list_head_init(&p->jsouts);

p->notification_topics = tal_arr(p, const char *, 0);

p->subscriptions = NULL;

p->dynamic = false;

p->index = plugins->plugin_idx++;

p->stdout_conn = NULL;

p->log = new_logger(p, plugins->ld->log_book, NULL, "plugin-%s", p->shortname);

p->methods = tal_arr(p, const char *, 0);

list_head_init(&p->plugin_opts);

list_add_tail(&plugins->plugins, &p->list);

tal_add_destructor(p, destroy_plugin);

strmap_init(&p->pending_requests);

memleak_add_helper(p, memleak_help_pending_requests);

p->important = important;

p->parambuf = tal_steal(p, parambuf);

p->params = tal_steal(p, params);

p->custom_msgs = NULL;

return p;

}

bool plugin_paths_match(const char *cmd, const char *name)

{

if (strchr(name, PATH_SEP)) {

const char *cmd_canon, *name_canon;

if (streq(cmd, name))

return true;

/* These return NULL path doesn't exist */

cmd_canon = path_canon(tmpctx, cmd);

name_canon = path_canon(tmpctx, name);

return cmd_canon && name_canon && streq(name_canon, cmd_canon);

} else {

/* No path separator means a basename match. */

const char *base = path_basename(tmpctx, cmd);

return streq(base, name);

}

}

void plugin_blacklist(struct plugins *plugins, const char *name)

{

struct plugin *p, *next;

log_debug(plugins->log, "blacklist for %s", name);

list_for_each_safe(&plugins->plugins, p, next, list) {

if (plugin_paths_match(p->cmd, name)) {

log_info(plugins->log, "%s: disabled via disable-plugin",

p->cmd);

list_del_from(&plugins->plugins, &p->list);

/* disable-plugin overrides important-plugin. */

p->important = false;

tal_free(p);

}

}

tal_arr_expand(&plugins->blacklist,

tal_strdup(plugins->blacklist, name));

}

bool plugin_blacklisted(struct plugins *plugins, const char *name)

{

for (size_t i = 0; i < tal_count(plugins->blacklist); i++)

if (plugin_paths_match(name, plugins->blacklist[i]))

return true;

return false;

}

void plugin_kill(struct plugin *plugin, enum log_level loglevel,

const char *fmt, ...)

{

va_list ap;

const char *msg;

va_start(ap, fmt);

msg = tal_vfmt(tmpctx, fmt, ap);

va_end(ap);

log_(plugin->log, loglevel,

NULL, loglevel >= LOG_UNUSUAL,

"Killing plugin: %s", msg);

/* Unless, maybe, plugin was *really* important? */

assert(plugin->pid != -1);

kill(plugin->pid, SIGKILL);

if (plugin->start_cmd) {

plugin_cmd_killed(plugin->start_cmd, plugin, msg);

plugin->start_cmd = NULL;

}

tal_free(plugin);

}

static void plugin_send(struct plugin *plugin, struct json_stream *stream)

{

tal_steal(plugin, stream);

list_add_tail(&plugin->jsouts, &stream->list);

io_wake(plugin);

}

static const char *plugin_log_handle(struct plugin *plugin,

const char *buffer,

const jsmntok_t *paramstok)

WARN_UNUSED_RESULT;

static const char *plugin_log_handle(struct plugin *plugin,

const char *buffer,

const jsmntok_t *paramstok)

{

const jsmntok_t *msgtok, *leveltok;

enum log_level level;

bool call_notifier;

msgtok = json_get_member(buffer, paramstok, "message");

leveltok = json_get_member(buffer, paramstok, "level");

if (!msgtok || msgtok->type != JSMN_STRING) {

return tal_fmt(plugin, "Log notification from plugin doesn't have "

"a string \"message\" field");

}

if (!leveltok)

level = LOG_INFORM;

else if (!log_level_parse(buffer + leveltok->start,

leveltok->end - leveltok->start,

&level)

/* FIXME: Allow io logging? */

|| level == LOG_IO_IN

|| level == LOG_IO_OUT) {

return tal_fmt(plugin,

"Unknown log-level %.*s, valid values are "

"\"trace\", \"debug\", \"info\", \"warn\", or \"error\".",

json_tok_full_len(leveltok),

json_tok_full(buffer, leveltok));

}

call_notifier = (level == LOG_BROKEN || level == LOG_UNUSUAL)? true : false;

/* Only bother unescaping and splitting if it has \ */

if (memchr(buffer + msgtok->start, '\\', msgtok->end - msgtok->start)) {

const char *log_msg = json_escape_unescape_len(tmpctx,

buffer + msgtok->start,

msgtok->end - msgtok->start);

char **lines;

/* Weird \ escapes aren't handled by json_escape_unescape. This is for you, clboss! */

if (!log_msg)

goto print_raw;

lines = tal_strsplit(tmpctx, log_msg, "\n", STR_EMPTY_OK);

for (size_t i = 0; lines[i]; i++) {

/* FIXME: Let plugin specify node_id? */

log_(plugin->log, level, NULL, call_notifier, "%s", lines[i]);

}

} else {

print_raw:

log_(plugin->log, level, NULL, call_notifier, "%.*s",

msgtok->end - msgtok->start,

buffer + msgtok->start);

}

return NULL;

}

static const char *plugin_notify_handle(struct plugin *plugin,

const char *buffer,

const jsmntok_t *methodtok,

const jsmntok_t *paramstok)

{

const jsmntok_t *idtok;

struct jsonrpc_request *request;

/* id inside params tells us which id to redirect to. */

idtok = json_get_member(buffer, paramstok, "id");

if (!idtok) {

return tal_fmt(plugin,

"JSON-RPC notify \"id\"-field is not present");

}

/* Include any "" in id */

request = strmap_getn(&plugin->pending_requests,

json_tok_full(buffer, idtok),

json_tok_full_len(idtok));

if (!request) {

return NULL;

}

/* Ignore if they don't have a callback */

if (request->notify_cb)

request->notify_cb(buffer, methodtok, paramstok, idtok,

request->response_cb_arg);

return NULL;

}

static bool plugin_notification_allowed(const struct plugin *plugin, const char *topic)

{

for (size_t i=0; i<tal_count(plugin->notification_topics); i++)

if (streq(plugin->notification_topics[i], topic))

return true;

return false;

}

static const char *plugin_notification_handle(struct plugin *plugin,

const char *buffer,

const jsmntok_t *toks)

WARN_UNUSED_RESULT;

static const char *plugin_notification_handle(struct plugin *plugin,

const char *buffer,

const jsmntok_t *toks)

{

const jsmntok_t *methtok, *paramstok;

const char *methname;

struct jsonrpc_notification *n;

methtok = json_get_member(buffer, toks, "method");

paramstok = json_get_member(buffer, toks, "params");

if (!methtok || !paramstok) {

return tal_fmt(plugin,

"Malformed JSON-RPC notification missing "

"\"method\" or \"params\": %.*s",

toks->end - toks->start,

buffer + toks->start);

}

/* Dispatch incoming notifications. This is currently limited

if (json_tok_streq(buffer, methtok, "log")) {

return plugin_log_handle(plugin, buffer, paramstok);

} else if (json_tok_streq(buffer, methtok, "message")

|| json_tok_streq(buffer, methtok, "progress")) {

return plugin_notify_handle(plugin, buffer, methtok, paramstok);

}

methname = json_strdup(tmpctx, buffer, methtok);

if (!plugin_notification_allowed(plugin, methname)) {

log_unusual(plugin->log,

"Plugin attempted to send a notification to topic "

"\"%s\" it hasn't declared in its manifest, not "

"forwarding to subscribers.",

methname);

} else if (notifications_have_topic(plugin->plugins, methname)) {

n = jsonrpc_notification_start_noparams(NULL, methname);

json_add_string(n->stream, "origin", plugin->shortname);

json_add_tok(n->stream, "params", paramstok, buffer);

jsonrpc_notification_end_noparams(n);

plugins_notify(plugin->plugins, take(n));

}

return NULL;

}

struct plugin_destroyed {

const struct plugin *plugin;

};

static void mark_plugin_destroyed(const struct plugin *unused,

struct plugin_destroyed *pd)

{

pd->plugin = NULL;

}

static struct plugin_destroyed *

plugin_detect_destruction(const struct plugin *plugin)

{

struct plugin_destroyed *pd = notleak(tal(NULL, struct plugin_destroyed));

pd->plugin = plugin;

tal_add_destructor2(plugin, mark_plugin_destroyed, pd);

return pd;

}

static bool was_plugin_destroyed(struct plugin_destroyed *pd)

{

if (pd->plugin) {

tal_del_destructor2(pd->plugin, mark_plugin_destroyed, pd);

tal_free(pd);

return false;

}

tal_free(pd);

return true;

}

static void destroy_request(struct jsonrpc_request *req,

struct plugin *plugin)

{

strmap_del(&plugin->pending_requests, req->id, NULL);

}

static void plugin_response_handle(struct plugin *plugin,

const char *buffer,

const jsmntok_t *toks,

const jsmntok_t *idtok)

{

struct jsonrpc_request *request;

const tal_t *ctx;

request = strmap_getn(&plugin->pending_requests,

json_tok_full(buffer, idtok),

json_tok_full_len(idtok));

/* Can happen if request was freed before plugin responded */

if (!request) {

return;

}

/* Request callback often frees request: if not, we do. */

ctx = tal(tmpctx, char);

tal_steal(ctx, request);

/* Don't keep track of this request; we will terminate it */

tal_del_destructor2(request, destroy_request, plugin);

destroy_request(request, plugin);

request->response_cb(buffer, toks, idtok, request->response_cb_arg);

tal_free(ctx);

}

static struct io_plan *plugin_read_json(struct io_conn *conn,

struct plugin *plugin)

{

struct wallet *wallet = plugin->plugins->ld->wallet;

const char *new_bytes, *buffer;

const jsmntok_t *toks;

size_t new_bytes_len;

size_t num_responses = 0;

/* wallet is NULL in really early code */

bool want_transaction = (plugin->plugins->want_db_transaction

&& wallet != NULL);

new_bytes = jsonrpc_newly_read(plugin->json_in, &new_bytes_len);

if (new_bytes_len) {

log_io(plugin->log, LOG_IO_IN, NULL, "",

new_bytes, new_bytes_len);

}

/* Parse until we get incomplete JSON */

for (;;) {

const char *error;

const jsmntok_t *idtok;

struct plugin_destroyed *pd;

error = jsonrpc_io_parse(tmpctx, plugin->json_in,

&toks, &buffer);

if (error) {

plugin_kill(plugin, LOG_UNUSUAL, "%s", error);

/* plugin_kill frees plugin */

return io_close(NULL);

}

/* Incomplete? */

if (!toks)

break;

idtok = json_get_member(buffer, toks, "id");

/* We can be called extremely early, or as db hook, or for

if (want_transaction)

db_begin_transaction(wallet->db);

pd = plugin_detect_destruction(plugin);

if (!idtok) {

/* A Notification is a Request object without an "id"

error = plugin_notification_handle(plugin, buffer, toks);

} else {

/* When a rpc call is made, the Server MUST reply with

plugin_response_handle(plugin, buffer, toks, idtok);

error = NULL;

}

if (want_transaction)

db_commit_transaction(wallet->db);

/* If it's destroyed, conn is already freed! */

if (was_plugin_destroyed(pd))

return io_close(NULL);

if (error) {

plugin_kill(plugin, LOG_UNUSUAL, "%s", error);

/* plugin_kill frees plugin */

return io_close(NULL);

}

jsonrpc_io_parse_done(plugin->json_in);

/* Don't let it flood us with logs/responses and starve everyone else */

if (num_responses++ == 100) {

log_debug(plugin->log, "Pausing response parsing after %zu response", num_responses);

/* Call us back, as if we read nothing new */

return io_always(conn, plugin_read_json, plugin);

}

}

/* Now read more from the connection */

return jsonrpc_io_read(plugin->stdout_conn, plugin->json_in,

plugin_read_json, plugin);

}

static struct io_plan *plugin_write_json(struct io_conn *conn,

struct plugin *plugin);

static struct io_plan *plugin_stream_complete(struct io_conn *conn, struct json_stream *js, struct plugin *plugin)

{

list_del_from(&plugin->jsouts, &js->list);

/* It got dropped off the queue, free it. */

tal_free(js);

return plugin_write_json(conn, plugin);

}

static struct io_plan *plugin_write_json(struct io_conn *conn,

struct plugin *plugin)

{

struct json_stream *js;

js = list_top(&plugin->jsouts, struct json_stream, list);

if (js) {

return json_stream_output(js, plugin->stdin_conn, plugin_stream_complete, plugin);

}

return io_out_wait(conn, plugin, plugin_write_json, plugin);

}

static void plugin_conn_finish(struct io_conn *conn, struct plugin *plugin)

{

struct db *db;

/* If they die during startup (plugins_init) wallet is NULL

if (plugin->plugins->ld->wallet) {

db = plugin->plugins->ld->wallet->db;

db_begin_transaction(db);

} else

db = NULL;

/* This is expected at shutdown of course. */

plugin_kill(plugin,

plugin->plugins->ld->state == LD_STATE_SHUTDOWN

? LOG_DBG : LOG_INFORM,

"exited %s", state_desc(plugin));

if (db)

db_commit_transaction(db);

}

struct io_plan *plugin_stdin_conn_init(struct io_conn *conn,

struct plugin *plugin)

{

plugin->stdin_conn = conn;

/* We write to their stdin */

/* We don't have anything queued yet, wait for notification */

return io_wait(conn, plugin, plugin_write_json, plugin);

}

struct io_plan *plugin_stdout_conn_init(struct io_conn *conn,

struct plugin *plugin)

{

/* We read from their stdout */

plugin->stdout_conn = conn;

io_set_finish(conn, plugin_conn_finish, plugin);

return plugin_read_json(conn, plugin);

}

static char *plugin_opt_check(struct plugin_opt *popt)

{

/* Fail if this is deprecated */

if (!lightningd_deprecated_in_ok(popt->plugin->plugins->ld,

popt->plugin->plugins->log,

popt->plugin->plugins->ld->deprecated_ok,

popt->plugin->shortname,

popt->name,

popt->depr_start,

popt->depr_end, NULL))

return tal_fmt(tmpctx, "deprecated option (will be removed!)");

return NULL;

}

static bool plugin_opt_deprecated_out_ok(struct plugin_opt *popt)

{

return lightningd_deprecated_out_ok(popt->plugin->plugins->ld,

popt->plugin->plugins->ld->deprecated_ok,

popt->plugin->shortname,

/* Skip --prefix */

popt->name + 2,

popt->depr_start,

popt->depr_end);

}

static char *plugin_opt_string_check(const char *arg, struct plugin_opt *popt)

{

return plugin_opt_check(popt);

}

static char *plugin_opt_long_check(const char *arg, struct plugin_opt *popt)

{

long v;

char *ret = opt_set_longval(arg, &v);

if (ret)

return ret;

return plugin_opt_check(popt);

}

static char *plugin_opt_bool_check(const char *arg, struct plugin_opt *popt)

{

bool v;

char *ret = opt_set_bool_arg(arg, &v);

if (ret)

return ret;

return plugin_opt_check(popt);

}

static char *plugin_opt_flag_check(struct plugin_opt *popt)

{

return plugin_opt_check(popt);

}

static bool popt_show_default(char *buf, size_t len,

const struct plugin_opt *popt)

{

if (!popt->def)

return false;

strncpy(buf, popt->def, len);

return true;

}

static void destroy_plugin_opt(struct plugin_opt *opt,

struct plugin *plugin)

{

opt_unregister(opt->name);

list_del_from(&plugin->plugin_opts, &opt->list);

/* If any configvars were added on `plugin start`, remove now */

configvar_remove(&plugin->plugins->ld->configvars,

opt->name + 2, /* Skip -- */

CONFIGVAR_PLUGIN_START, NULL);

}

bool is_plugin_opt(const struct opt_table *ot)

{

if (ot->type & OPT_NOARG)

return ot->cb == (void *)plugin_opt_flag_check;

return ot->cb_arg == (void *)plugin_opt_string_check

|| ot->cb_arg == (void *)plugin_opt_long_check

|| ot->cb_arg == (void *)plugin_opt_bool_check;

}

static char *bool_setting(tal_t *ctx,

bool *ret)

{

const jsmntok_t *tok = json_get_member(buffer, opt, tokname);

if (!tok) {

*ret = false;

return NULL;

}

if (!json_to_bool(buffer, tok, ret))

return tal_fmt(ctx,

"%s: invalid \"%s\" field %.*s",

optname, tokname,

tok->end - tok->start,

buffer + tok->start);

return NULL;

}

static const char *json_parse_deprecated(const tal_t *ctx,

const char **depr_end)

{

bool is_depr;

*depr_start = *depr_end = NULL;

if (!deprtok)

return NULL;

/* Not every plugin will track deprecation cycles (and that's OK!):