Rusty Russell
8 years ago
7 changed files with 26 additions and 559 deletions
@ -1,415 +0,0 @@ |
|||
#include <ccan/io/fdpass/fdpass.h> |
|||
#include <ccan/io/io.h> |
|||
#include <ccan/noerr/noerr.h> |
|||
#include <ccan/tal/path/path.h> |
|||
#include <daemon/log.h> |
|||
#include <errno.h> |
|||
#include <fcntl.h> |
|||
#include <lightningd/lightningd.h> |
|||
#include <lightningd/subdaemon.h> |
|||
#include <status.h> |
|||
#include <stdarg.h> |
|||
#include <sys/socket.h> |
|||
#include <sys/stat.h> |
|||
#include <sys/types.h> |
|||
#include <sys/wait.h> |
|||
#include <unistd.h> |
|||
#include <wire/wire.h> |
|||
#include <wire/wire_io.h> |
|||
|
|||
/* A single request/response for subdaemon. */ |
|||
struct subdaemon_req { |
|||
struct subdaemon *sd; |
|||
|
|||
/* In sd->reqs */ |
|||
struct list_node list; |
|||
|
|||
/* Request message. */ |
|||
const u8 *msg_out; |
|||
int fd_out; |
|||
|
|||
/* Response */ |
|||
u8 *req_in; |
|||
int *fd_in; |
|||
|
|||
/* Callback when response comes in. */ |
|||
void (*req)(struct subdaemon *, const u8 *msg_in, void *req_data); |
|||
void *req_data; |
|||
}; |
|||
|
|||
static bool move_fd(int from, int to) |
|||
{ |
|||
if (dup2(from, to) == -1) |
|||
return false; |
|||
close(from); |
|||
return true; |
|||
} |
|||
|
|||
/* FIXME: Expose the ccan/io version? */ |
|||
static void set_blocking(int fd, bool block) |
|||
{ |
|||
int flags = fcntl(fd, F_GETFL); |
|||
|
|||
if (block) |
|||
flags &= ~O_NONBLOCK; |
|||
else |
|||
flags |= O_NONBLOCK; |
|||
|
|||
fcntl(fd, F_SETFL, flags); |
|||
} |
|||
|
|||
/* We use sockets, not pipes, because fds are bidir. */ |
|||
static int subdaemon(const char *dir, const char *name, bool debug, |
|||
int *statusfd, int *reqfd, va_list ap) |
|||
{ |
|||
int childreq[2], childstatus[2], execfail[2]; |
|||
pid_t childpid; |
|||
int err, fd; |
|||
|
|||
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, childstatus) != 0) |
|||
goto fail; |
|||
|
|||
if (reqfd) { |
|||
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, childreq) != 0) |
|||
goto close_childstatus_fail; |
|||
} else { |
|||
childreq[0] = open("/dev/null", O_RDONLY); |
|||
if (childreq[0] < 0) |
|||
goto close_childstatus_fail; |
|||
} |
|||
|
|||
if (pipe(execfail) != 0) |
|||
goto close_reqfd_fail; |
|||
|
|||
if (fcntl(execfail[1], F_SETFD, fcntl(execfail[1], F_GETFD) |
|||
| FD_CLOEXEC) < 0) |
|||
goto close_execfail_fail; |
|||
|
|||
childpid = fork(); |
|||
if (childpid < 0) |
|||
goto close_execfail_fail; |
|||
|
|||
if (childpid == 0) { |
|||
int fdnum = 3; |
|||
long max; |
|||
const char *debug_arg = NULL; |
|||
|
|||
if (reqfd) |
|||
close(childreq[0]); |
|||
close(childstatus[0]); |
|||
close(execfail[0]); |
|||
|
|||
// Status = STDOUT
|
|||
if (childstatus[1] != STDOUT_FILENO) { |
|||
if (!move_fd(childstatus[1], STDOUT_FILENO)) |
|||
goto child_errno_fail; |
|||
} |
|||
// Req = STDIN.
|
|||
if (childreq[1] != STDIN_FILENO) { |
|||
if (!move_fd(childreq[1], STDIN_FILENO)) |
|||
goto child_errno_fail; |
|||
} |
|||
/* Dup any extra fds up first. */ |
|||
while ((fd = va_arg(ap, int)) != -1) { |
|||
/* If these were stdin or stdout, dup2 closed! */ |
|||
assert(fd != STDIN_FILENO); |
|||
assert(fd != STDOUT_FILENO); |
|||
if (!move_fd(fd, fdnum)) |
|||
goto child_errno_fail; |
|||
fdnum++; |
|||
} |
|||
|
|||
/* Make (fairly!) sure all other fds are closed. */ |
|||
max = sysconf(_SC_OPEN_MAX); |
|||
for (fd = fdnum; fd < max; fd++) |
|||
close(fd); |
|||
|
|||
if (debug) |
|||
debug_arg = "--debugger"; |
|||
execl(path_join(NULL, dir, name), name, debug_arg, NULL); |
|||
|
|||
child_errno_fail: |
|||
err = errno; |
|||
/* Gcc's warn-unused-result fail. */ |
|||
if (write(execfail[1], &err, sizeof(err))) { |
|||
; |
|||
} |
|||
exit(127); |
|||
} |
|||
|
|||
if (reqfd) |
|||
close(childreq[1]); |
|||
close(childstatus[1]); |
|||
close(execfail[1]); |
|||
|
|||
while ((fd = va_arg(ap, int)) != -1) |
|||
close(fd); |
|||
|
|||
/* Child will close this without writing on successful exec. */ |
|||
if (read(execfail[0], &err, sizeof(err)) == sizeof(err)) { |
|||
close(execfail[0]); |
|||
waitpid(childpid, NULL, 0); |
|||
errno = err; |
|||
return -1; |
|||
} |
|||
close(execfail[0]); |
|||
*statusfd = childstatus[0]; |
|||
if (reqfd) |
|||
*reqfd = childreq[0]; |
|||
return childpid; |
|||
|
|||
close_execfail_fail: |
|||
close_noerr(execfail[0]); |
|||
close_noerr(execfail[1]); |
|||
close_reqfd_fail: |
|||
if (reqfd) |
|||
close_noerr(childreq[1]); |
|||
close_noerr(childreq[0]); |
|||
close_childstatus_fail: |
|||
close_noerr(childstatus[0]); |
|||
close_noerr(childstatus[1]); |
|||
fail: |
|||
return -1; |
|||
} |
|||
|
|||
static struct io_plan *status_read(struct io_conn *conn, struct subdaemon *sd); |
|||
|
|||
static struct io_plan *status_process_fd(struct io_conn *conn, |
|||
struct subdaemon *sd) |
|||
{ |
|||
const tal_t *tmpctx = tal_tmpctx(sd); |
|||
|
|||
/* Don't trust subdaemon to set it blocking. */ |
|||
set_blocking(sd->status_fd_in, true); |
|||
|
|||
/* Ensure we free it iff callback doesn't tal_steal it. */ |
|||
tal_steal(tmpctx, sd->status_in); |
|||
sd->statuscb(sd, sd->status_in, sd->status_fd_in); |
|||
tal_free(tmpctx); |
|||
sd->status_in = NULL; |
|||
return status_read(conn, sd); |
|||
} |
|||
|
|||
static struct io_plan *status_process(struct io_conn *conn, struct subdaemon *sd) |
|||
{ |
|||
int type = fromwire_peektype(sd->status_in); |
|||
const char *str; |
|||
int str_len; |
|||
const tal_t *tmpctx = tal_tmpctx(sd); |
|||
|
|||
if (type == -1) { |
|||
log_unusual(sd->log, "ERROR: Invalid status output"); |
|||
return io_close(conn); |
|||
} |
|||
|
|||
/* If not stolen, we'll free this below. */ |
|||
tal_steal(tmpctx, sd->status_in); |
|||
|
|||
/* If it's a string. */ |
|||
str_len = tal_count(sd->status_in) - sizeof(be16); |
|||
str = (const char *)sd->status_in + sizeof(be16); |
|||
|
|||
if (type == STATUS_TRACE) |
|||
log_debug(sd->log, "TRACE: %.*s", str_len, str); |
|||
else if (type & STATUS_FAIL) |
|||
log_unusual(sd->log, "FAILURE %s: %.*s", |
|||
sd->statusname(type), str_len, str); |
|||
else { |
|||
log_info(sd->log, "UPDATE %s", sd->statusname(type)); |
|||
if (sd->statuscb) { |
|||
enum subdaemon_status s = sd->statuscb(sd, |
|||
sd->status_in, |
|||
-1); |
|||
switch (s) { |
|||
case STATUS_NEED_FD: |
|||
tal_steal(sd, sd->status_in); |
|||
tal_free(tmpctx); |
|||
return io_recv_fd(conn, &sd->status_fd_in, |
|||
status_process_fd, sd); |
|||
case STATUS_COMPLETE: |
|||
break; |
|||
default: |
|||
fatal("Unknown statuscb return for %s:%s: %u", |
|||
sd->name, sd->statusname(type), s); |
|||
} |
|||
} |
|||
} |
|||
sd->status_in = NULL; |
|||
tal_free(tmpctx); |
|||
return status_read(conn, sd); |
|||
} |
|||
|
|||
static struct io_plan *status_read(struct io_conn *conn, struct subdaemon *sd) |
|||
{ |
|||
return io_read_wire(conn, sd, &sd->status_in, status_process, sd); |
|||
} |
|||
|
|||
static struct io_plan *req_next(struct io_conn *conn, struct subdaemon *sd); |
|||
|
|||
static void destroy_subdaemon(struct subdaemon *sd) |
|||
{ |
|||
int status; |
|||
|
|||
switch (waitpid(sd->pid, &status, WNOHANG)) { |
|||
case 0: |
|||
log_debug(sd->log, "Status closed, but not exited. Killing"); |
|||
kill(sd->pid, SIGKILL); |
|||
waitpid(sd->pid, &status, 0); |
|||
break; |
|||
case -1: |
|||
log_unusual(sd->log, "Status closed, but waitpid %i says %s", |
|||
sd->pid, strerror(errno)); |
|||
status = -1; |
|||
break; |
|||
} |
|||
if (sd->finished) |
|||
sd->finished(sd, status); |
|||
} |
|||
|
|||
struct subdaemon *new_subdaemon(const tal_t *ctx, |
|||
struct lightningd *ld, |
|||
const char *name, |
|||
struct peer *peer, |
|||
const char *(*statusname)(int status), |
|||
const char *(*reqname)(int req), |
|||
enum subdaemon_status (*statuscb) |
|||
(struct subdaemon *, const u8 *, int fd), |
|||
void (*finished)(struct subdaemon *, int), |
|||
...) |
|||
{ |
|||
va_list ap; |
|||
struct subdaemon *sd = tal(ctx, struct subdaemon); |
|||
int req_fd, status_fd; |
|||
bool debug; |
|||
|
|||
debug = ld->dev_debug_subdaemon && strends(name,ld->dev_debug_subdaemon); |
|||
va_start(ap, finished); |
|||
sd->pid = subdaemon(ld->daemon_dir, name, debug, &status_fd, |
|||
reqname ? &req_fd : NULL, ap); |
|||
va_end(ap); |
|||
if (sd->pid == (pid_t)-1) { |
|||
log_unusual(ld->log, "subdaemon %s failed: %s", |
|||
name, strerror(errno)); |
|||
return tal_free(sd); |
|||
} |
|||
sd->ld = ld; |
|||
sd->log = new_log(sd, ld->dstate.log_book, "%s(%u):", name, sd->pid); |
|||
sd->name = name; |
|||
sd->finished = finished; |
|||
sd->statusname = statusname; |
|||
sd->statuscb = statuscb; |
|||
list_head_init(&sd->reqs); |
|||
tal_add_destructor(sd, destroy_subdaemon); |
|||
|
|||
/* Status conn actually owns daemon: we die when it does. */ |
|||
sd->status_conn = io_new_conn(ctx, status_fd, status_read, sd); |
|||
tal_steal(sd->status_conn, sd); |
|||
|
|||
sd->reqname = reqname; |
|||
if (reqname) |
|||
sd->req_conn = io_new_conn(sd, req_fd, req_next, sd); |
|||
else |
|||
sd->req_conn = NULL; |
|||
log_info(sd->log, "pid %u, statusfd %i, reqfd %i", |
|||
sd->pid, status_fd, req_fd); |
|||
|
|||
sd->peer = tal_steal(sd, peer); |
|||
return sd; |
|||
} |
|||
|
|||
static struct io_plan *req_finished_reply(struct io_conn *conn, |
|||
struct subdaemon_req *sr) |
|||
{ |
|||
struct subdaemon *sd = sr->sd; |
|||
|
|||
/* Don't trust subdaemon to set it blocking. */ |
|||
if (sr->fd_in) |
|||
set_blocking(*sr->fd_in, true); |
|||
|
|||
sr->req(sd, sr->req_in, sr->req_data); |
|||
tal_free(sr); |
|||
return req_next(conn, sd); |
|||
} |
|||
|
|||
static struct io_plan *req_process_replymsg(struct io_conn *conn, |
|||
struct subdaemon_req *sr) |
|||
{ |
|||
int type = fromwire_peektype(sr->req_in); |
|||
|
|||
if (type == -1) { |
|||
log_unusual(sr->sd->log, "ERROR: Invalid request output"); |
|||
return io_close(conn); |
|||
} |
|||
log_debug(sr->sd->log, "Received req response %s len %zu%s", |
|||
sr->sd->reqname(type), tal_count(sr->req_in), |
|||
sr->fd_in ? " (now getting fd)" : ""); |
|||
|
|||
/* If we're supposed to recv an fd, do it now. */ |
|||
if (sr->fd_in) |
|||
return io_recv_fd(conn, sr->fd_in, req_finished_reply, sr); |
|||
return req_finished_reply(conn, sr); |
|||
} |
|||
|
|||
static struct io_plan *req_read_reply(struct io_conn *conn, |
|||
struct subdaemon_req *sr) |
|||
{ |
|||
/* No callback? Don't expect reply. */ |
|||
if (!sr->req) { |
|||
struct subdaemon *sd = sr->sd; |
|||
tal_free(sr); |
|||
return req_next(conn, sd); |
|||
} |
|||
return io_read_wire(conn, sr, &sr->req_in, req_process_replymsg, sr); |
|||
} |
|||
|
|||
static struct io_plan *req_close_fd_out(struct io_conn *conn, |
|||
struct subdaemon_req *sr) |
|||
{ |
|||
close(sr->fd_out); |
|||
return req_read_reply(conn, sr); |
|||
} |
|||
|
|||
static struct io_plan *req_sent_msg(struct io_conn *conn, |
|||
struct subdaemon_req *sr) |
|||
{ |
|||
/* If we're supposed to pass an fd, do it now. */ |
|||
if (sr->fd_out >= 0) |
|||
return io_send_fd(conn, sr->fd_out, req_close_fd_out, sr); |
|||
return req_read_reply(conn, sr); |
|||
} |
|||
|
|||
static struct io_plan *req_next(struct io_conn *conn, struct subdaemon *sd) |
|||
{ |
|||
struct subdaemon_req *sr; |
|||
|
|||
sr = list_pop(&sd->reqs, struct subdaemon_req, list); |
|||
if (!sr) |
|||
return io_wait(conn, sd, req_next, sd); |
|||
log_debug(sd->log, "Sending req %s len %zu", |
|||
sd->reqname(fromwire_peektype(sr->msg_out)), |
|||
tal_count(sr->msg_out)); |
|||
|
|||
return io_write_wire(conn, sr->msg_out, req_sent_msg, sr); |
|||
} |
|||
|
|||
void subdaemon_req_(struct subdaemon *sd, |
|||
const u8 *msg_out, int fd_out, int *fd_in, |
|||
void (*reqcb)(struct subdaemon *, const u8 *, void *), |
|||
void *reqcb_data) |
|||
{ |
|||
struct subdaemon_req *sr = tal(sd, struct subdaemon_req); |
|||
|
|||
assert(sd->req_conn); |
|||
|
|||
sr->sd = sd; |
|||
if (msg_out) |
|||
sr->msg_out = tal_dup_arr(sr, u8, msg_out, tal_count(msg_out), 0); |
|||
else |
|||
sr->msg_out = NULL; |
|||
sr->fd_out = fd_out; |
|||
sr->fd_in = fd_in; |
|||
sr->req = reqcb; |
|||
sr->req_data = reqcb_data; |
|||
list_add_tail(&sd->reqs, &sr->list); |
|||
io_wake(sd); |
|||
} |
|||
@ -1,101 +0,0 @@ |
|||
#ifndef LIGHTNING_LIGHTNINGD_SUBDAEMON_H |
|||
#define LIGHTNING_LIGHTNINGD_SUBDAEMON_H |
|||
#include "config.h" |
|||
#include <ccan/endian/endian.h> |
|||
#include <ccan/list/list.h> |
|||
#include <ccan/short_types/short_types.h> |
|||
#include <ccan/tal/tal.h> |
|||
|
|||
struct io_conn; |
|||
|
|||
enum subdaemon_status { |
|||
STATUS_NEED_FD, |
|||
STATUS_COMPLETE |
|||
}; |
|||
|
|||
/* One of our subdaemons. */ |
|||
struct subdaemon { |
|||
/* Name, like John, or "lightningd_hsm" */ |
|||
const char *name; |
|||
/* The Big Cheese. */ |
|||
struct lightningd *ld; |
|||
/* pid, for waiting for status when it dies. */ |
|||
int pid; |
|||
/* Connection for status (read, then write) */ |
|||
struct io_conn *status_conn; |
|||
/* Connection for requests if any (write, then read) */ |
|||
struct io_conn *req_conn; |
|||
|
|||
/* If we are associated with a single peer, this points to it. */ |
|||
struct peer *peer; |
|||
|
|||
/* For logging */ |
|||
struct log *log; |
|||
|
|||
/* Callback when status comes in. */ |
|||
enum subdaemon_status (*statuscb)(struct subdaemon *, const u8 *, int); |
|||
const char *(*statusname)(int status); |
|||
const char *(*reqname)(int req); |
|||
void (*finished)(struct subdaemon *sd, int status); |
|||
|
|||
/* Buffer for input. */ |
|||
u8 *status_in; |
|||
int status_fd_in; |
|||
|
|||
/* Requests queue up here. */ |
|||
struct list_head reqs; |
|||
}; |
|||
|
|||
/**
|
|||
* new_subdaemon - create a new subdaemon. |
|||
* @ctx: context to allocate from |
|||
* @ld: global state |
|||
* @name: basename of daemon |
|||
* @peer: peer to take ownership of if non-NULL; |
|||
* @statusname: function to get name from status messages |
|||
* @reqname: function to get name from request messages, or NULL if no requests. |
|||
* @statuscb: function to call when status message received (or NULL) |
|||
* @finished: function to call when it's finished (with exit status). |
|||
* @...: the fds to hand as fd 3, 4... terminated with -1. |
|||
* |
|||
* @statuscb is called with fd == -1 when a status message is |
|||
* received; if it returns STATUS_NEED_FD, we read an fd from the |
|||
* daemon and call it again with that as the third arg. |
|||
* |
|||
* If this succeeds subdaemon owns @peer. |
|||
*/ |
|||
struct subdaemon *new_subdaemon(const tal_t *ctx, |
|||
struct lightningd *ld, |
|||
const char *name, |
|||
struct peer *peer, |
|||
const char *(*statusname)(int status), |
|||
const char *(*reqname)(int req), |
|||
enum subdaemon_status (*statuscb) |
|||
(struct subdaemon *, const u8 *, int fd), |
|||
void (*finished)(struct subdaemon *, int), ...); |
|||
|
|||
/**
|
|||
* subdaemon_req - add a request to the subdaemon. |
|||
* @sd: subdaemon to request |
|||
* @msg_out: request message (can be take, can be NULL for fd passing only) |
|||
* @fd_out: if >=0 fd to pass at the end of the message (closed after) |
|||
* @fd_in: if not NULL, where to put fd read in at end of reply. |
|||
* @reqcb: callback when reply comes in |
|||
* @reqcb_data: final arg to hand to @reqcb |
|||
* |
|||
* The subdaemon must take requests. |
|||
*/ |
|||
#define subdaemon_req(sd, msg_out, fd_out, fd_in, reqcb, reqcb_data) \ |
|||
subdaemon_req_((sd), (msg_out), (fd_out), (fd_in), \ |
|||
typesafe_cb_preargs(void, void *, \ |
|||
(reqcb), (reqcb_data), \ |
|||
struct subdaemon *, \ |
|||
const u8 *), \ |
|||
(reqcb_data)) |
|||
void subdaemon_req_(struct subdaemon *sd, |
|||
const u8 *msg_out, |
|||
int fd_out, int *fd_in, |
|||
void (*reqcb)(struct subdaemon *, const u8 *, void *), |
|||
void *reqcb_data); |
|||
|
|||
#endif /* LIGHTNING_LIGHTNINGD_SUBDAEMON_H */ |
|||
Loading…
Reference in new issue