mirror of
https://github.com/ElementsProject/lightning.git
synced 2024-11-20 02:27:51 +01:00
296 lines
7.9 KiB
C
296 lines
7.9 KiB
C
#include "lightningd/plugin.h"
|
|
|
|
#include <ccan/intmap/intmap.h>
|
|
#include <ccan/io/io.h>
|
|
#include <ccan/list/list.h>
|
|
#include <ccan/pipecmd/pipecmd.h>
|
|
#include <ccan/tal/str/str.h>
|
|
#include <lightningd/json.h>
|
|
#include <unistd.h>
|
|
|
|
struct plugin {
|
|
int stdin, stdout;
|
|
pid_t pid;
|
|
char *cmd;
|
|
struct io_conn *stdin_conn, *stdout_conn;
|
|
bool stop;
|
|
struct plugins *plugins;
|
|
|
|
/* Stuff we read */
|
|
char *buffer;
|
|
size_t used, len_read;
|
|
|
|
/* Stuff we write */
|
|
struct list_head output;
|
|
const char *outbuf;
|
|
};
|
|
|
|
struct plugin_request {
|
|
u64 id;
|
|
/* Method to be called */
|
|
const char *method;
|
|
|
|
/* JSON encoded params, either a dict or an array */
|
|
const char *json_params;
|
|
const char *response;
|
|
const jsmntok_t *resulttok, *errortok;
|
|
|
|
/* The response handler to be called on success or error */
|
|
void (*cb)(const struct plugin_request *, void *);
|
|
void *arg;
|
|
};
|
|
|
|
struct plugins {
|
|
struct plugin **plugins;
|
|
size_t pending_init;
|
|
|
|
/* Currently pending requests by their request ID */
|
|
UINTMAP(struct plugin_request *) pending_requests;
|
|
};
|
|
|
|
struct json_output {
|
|
struct list_node list;
|
|
const char *json;
|
|
};
|
|
|
|
struct plugins *plugins_new(const tal_t *ctx){
|
|
struct plugins *p;
|
|
p = tal(ctx, struct plugins);
|
|
p->plugins = tal_arr(p, struct plugin *, 0);
|
|
return p;
|
|
}
|
|
|
|
void plugin_register(struct plugins *plugins, const char* path TAKES)
|
|
{
|
|
struct plugin *p;
|
|
size_t n = tal_count(plugins->plugins);
|
|
tal_resize(&plugins->plugins, n+1);
|
|
p = tal(plugins, struct plugin);
|
|
plugins->plugins[n] = p;
|
|
p->plugins = plugins;
|
|
p->cmd = tal_strdup(p, path);
|
|
}
|
|
|
|
/**
|
|
* Try to parse a complete message from the plugin's buffer.
|
|
*
|
|
* Internally calls the handler if it was able to fully parse a JSON message,
|
|
* and returns true in that case.
|
|
*/
|
|
static bool plugin_read_json_one(struct plugin *plugin)
|
|
{
|
|
jsmntok_t *toks;
|
|
bool valid;
|
|
u64 id;
|
|
const jsmntok_t *idtok, *resulttok, *errortok;
|
|
struct plugin_request *request;
|
|
|
|
/* FIXME: This could be done more efficiently by storing the
|
|
* toks and doing an incremental parse, like lightning-cli
|
|
* does. */
|
|
toks = json_parse_input(plugin->buffer, plugin->used, &valid);
|
|
if (!toks) {
|
|
if (!valid) {
|
|
/* FIXME (cdecker) Print error and kill the plugin */
|
|
return io_close(plugin->stdout_conn);
|
|
}
|
|
/* We need more. */
|
|
return false;
|
|
}
|
|
|
|
/* Empty buffer? (eg. just whitespace). */
|
|
if (tal_count(toks) == 1) {
|
|
plugin->used = 0;
|
|
return false;
|
|
}
|
|
|
|
resulttok = json_get_member(plugin->buffer, toks, "result");
|
|
errortok = json_get_member(plugin->buffer, toks, "error");
|
|
idtok = json_get_member(plugin->buffer, toks, "id");
|
|
|
|
/* FIXME(cdecker) Kill the plugin if either of these fails */
|
|
if (!idtok) {
|
|
return false;
|
|
} else if (!resulttok && !errortok) {
|
|
return false;
|
|
}
|
|
|
|
/* We only send u64 ids, so if this fails it's a critical error */
|
|
if (!json_to_u64(plugin->buffer, idtok, &id)) {
|
|
/* FIXME (cdecker) Log an error message and kill the plugin */
|
|
return false;
|
|
}
|
|
|
|
request = uintmap_get(&plugin->plugins->pending_requests, id);
|
|
|
|
if (!request) {
|
|
/* FIXME(cdecker) Log an error and kill the plugin */
|
|
return false;
|
|
}
|
|
|
|
/* We expect the request->cb to copy if needed */
|
|
request->response = plugin->buffer;
|
|
request->errortok = errortok;
|
|
request->resulttok = resulttok;
|
|
request->cb(request, request->arg);
|
|
|
|
/* Move this object out of the buffer */
|
|
memmove(plugin->buffer, plugin->buffer + toks[0].end,
|
|
tal_count(plugin->buffer) - toks[0].end);
|
|
plugin->used -= toks[0].end;
|
|
tal_free(toks);
|
|
return true;
|
|
}
|
|
|
|
static struct io_plan *plugin_read_json(struct io_conn *conn UNUSED,
|
|
struct plugin *plugin)
|
|
{
|
|
bool success;
|
|
plugin->used += plugin->len_read;
|
|
if (plugin->used == tal_count(plugin->buffer))
|
|
tal_resize(&plugin->buffer, plugin->used * 2);
|
|
|
|
/* Read and process all messages from the connection */
|
|
do {
|
|
success = plugin_read_json_one(plugin);
|
|
} while (success);
|
|
|
|
/* Now read more from the connection */
|
|
return io_read_partial(plugin->stdout_conn,
|
|
plugin->buffer + plugin->used,
|
|
tal_count(plugin->buffer) - plugin->used,
|
|
&plugin->len_read, plugin_read_json, plugin);
|
|
}
|
|
|
|
static struct io_plan *plugin_write_json(struct io_conn *conn UNUSED,
|
|
struct plugin *plugin)
|
|
{
|
|
struct json_output *out;
|
|
out = list_pop(&plugin->output, struct json_output, list);
|
|
if (!out) {
|
|
if (plugin->stop) {
|
|
return io_close(conn);
|
|
} else {
|
|
return io_out_wait(plugin->stdin_conn, plugin,
|
|
plugin_write_json, plugin);
|
|
}
|
|
}
|
|
|
|
/* We have a message we'd like to send */
|
|
plugin->outbuf = tal_steal(plugin, out->json);
|
|
tal_free(out);
|
|
return io_write(conn, plugin->outbuf, strlen(plugin->outbuf),
|
|
plugin_write_json, plugin);
|
|
}
|
|
|
|
static void plugin_request_send_(
|
|
struct plugin *plugin, const char *method TAKES, const char *params TAKES,
|
|
void (*cb)(const struct plugin_request *, void *), void *arg)
|
|
{
|
|
static u64 next_request_id = 0;
|
|
struct plugin_request *req = tal(plugin, struct plugin_request);
|
|
struct json_output *out = tal(plugin, struct json_output);
|
|
u64 request_id = next_request_id++;
|
|
|
|
req->id = request_id;
|
|
req->method = tal_strdup(req, method);
|
|
req->json_params = tal_strdup(req, params);
|
|
req->cb = cb;
|
|
req->arg = arg;
|
|
|
|
/* Add to map so we can find it later when routing the response */
|
|
uintmap_add(&plugin->plugins->pending_requests, req->id, req);
|
|
|
|
/* Wrap the request in the JSON-RPC request object */
|
|
out->json = tal_fmt(out, "{"
|
|
"\"jsonrpc\": \"2.0\", "
|
|
"\"method\": \"%s\", "
|
|
"\"params\" : %s, "
|
|
"\"id\" : %" PRIu64 " }\n",
|
|
method, params, request_id);
|
|
|
|
/* Queue and notify the writer */
|
|
list_add_tail(&plugin->output, &out->list);
|
|
io_wake(plugin);
|
|
}
|
|
|
|
#define plugin_request_send(plugin, method, params, cb, arg) \
|
|
plugin_request_send_( \
|
|
(plugin), (method), (params), \
|
|
typesafe_cb_preargs(void, void *, (cb), (arg), \
|
|
const struct plugin_request *), \
|
|
(arg))
|
|
|
|
static struct io_plan *plugin_conn_init(struct io_conn *conn,
|
|
struct plugin *plugin)
|
|
{
|
|
plugin->stop = false;
|
|
if (plugin->stdout == io_conn_fd(conn)) {
|
|
/* We read from their stdout */
|
|
plugin->stdout_conn = conn;
|
|
return io_read_partial(plugin->stdout_conn, plugin->buffer,
|
|
tal_bytelen(plugin->buffer),
|
|
&plugin->len_read, plugin_read_json,
|
|
plugin);
|
|
} else {
|
|
/* We write to their stdin */
|
|
plugin->stdin_conn = conn;
|
|
/* We don't have anything queued yet, wait for notification */
|
|
return io_wait(plugin->stdin_conn, plugin, plugin_write_json,
|
|
plugin);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Callback for the plugin_init request.
|
|
*/
|
|
static void plugin_init_cb(const struct plugin_request *req, struct plugin *plugin)
|
|
{
|
|
/* Check if all plugins are initialized, and break if they are */
|
|
plugin->plugins->pending_init--;
|
|
if (plugin->plugins->pending_init == 0)
|
|
io_break(plugin->plugins);
|
|
}
|
|
|
|
void plugins_init(struct plugins *plugins)
|
|
{
|
|
struct plugin *p;
|
|
char **cmd;
|
|
plugins->pending_init = tal_count(plugins->plugins);
|
|
uintmap_init(&plugins->pending_requests);
|
|
|
|
/* Spawn the plugin processes before entering the io_loop */
|
|
for (size_t i=0; i<tal_count(plugins->plugins); i++) {
|
|
p = plugins->plugins[i];
|
|
cmd = tal_arr(p, char *, 2);
|
|
cmd[0] = p->cmd;
|
|
cmd[1] = NULL;
|
|
p->pid = pipecmdarr(&p->stdout, &p->stdin, NULL, cmd);
|
|
|
|
list_head_init(&p->output);
|
|
p->buffer = tal_arr(p, char, 64);
|
|
p->used = 0;
|
|
|
|
/* Create two connections, one read-only on top of p->stdin, and one
|
|
* write-only on p->stdout */
|
|
io_new_conn(p, p->stdout, plugin_conn_init, p);
|
|
io_new_conn(p, p->stdin, plugin_conn_init, p);
|
|
plugin_request_send(p, "init", "[]", plugin_init_cb, p);
|
|
}
|
|
if (plugins->pending_init > 0)
|
|
io_loop(NULL, NULL);
|
|
}
|
|
|
|
void json_add_opt_plugins(struct json_stream *response,
|
|
const struct plugins *plugins)
|
|
{
|
|
struct plugin *p;
|
|
json_object_start(response, "plugin");
|
|
for (size_t i=0; i<tal_count(plugins->plugins); i++) {
|
|
p = plugins->plugins[i];
|
|
json_object_start(response, p->cmd);
|
|
json_object_end(response);
|
|
}
|
|
json_object_end(response);
|
|
}
|