2021-12-04 12:23:56 +01:00
|
|
|
#include "config.h"
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
#include <ccan/closefrom/closefrom.h>
|
2017-10-12 08:35:03 +02:00
|
|
|
#include <ccan/err/err.h>
|
2017-03-10 11:48:43 +01:00
|
|
|
#include <ccan/io/fdpass/fdpass.h>
|
2017-08-18 06:43:52 +02:00
|
|
|
#include <ccan/mem/mem.h>
|
2017-03-10 11:48:43 +01:00
|
|
|
#include <ccan/noerr/noerr.h>
|
|
|
|
|
#include <ccan/tal/path/path.h>
|
2017-05-24 12:10:16 +02:00
|
|
|
#include <ccan/tal/str/str.h>
|
2018-08-24 07:20:06 +02:00
|
|
|
#include <common/memleak.h>
|
2020-08-25 04:19:38 +02:00
|
|
|
#include <common/peer_status_wiregen.h>
|
|
|
|
|
#include <common/status_wiregen.h>
|
2021-04-08 06:43:46 +02:00
|
|
|
#include <common/version.h>
|
2017-03-10 11:48:43 +01:00
|
|
|
#include <errno.h>
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include <lightningd/lightningd.h>
|
2018-02-05 05:09:27 +01:00
|
|
|
#include <lightningd/log_status.h>
|
2022-01-11 02:13:59 +01:00
|
|
|
#include <lightningd/peer_fd.h>
|
2017-03-10 11:48:43 +01:00
|
|
|
#include <lightningd/subd.h>
|
|
|
|
|
#include <sys/socket.h>
|
|
|
|
|
#include <sys/wait.h>
|
2020-08-31 03:13:25 +02:00
|
|
|
#include <wire/common_wiregen.h>
|
2017-03-10 11:48:43 +01:00
|
|
|
#include <wire/wire_io.h>
|
|
|
|
|
|
2022-01-22 05:49:22 +01:00
|
|
|
void maybe_subd_child(struct lightningd *ld, int childpid, int wstatus)
|
|
|
|
|
{
|
|
|
|
|
struct subd *sd;
|
|
|
|
|
|
|
|
|
|
list_for_each(&ld->subds, sd, list) {
|
|
|
|
|
if (sd->pid == childpid)
|
|
|
|
|
sd->wstatus = tal_dup(sd, int, &wstatus);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
/* Carefully move fd *@from to @to: on success *from set to to */
|
|
|
|
|
static bool move_fd(int *from, int to)
|
2017-03-10 11:48:43 +01:00
|
|
|
{
|
2021-10-22 02:13:08 +02:00
|
|
|
assert(*from >= 0);
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
|
|
|
|
|
/* dup2 with same arguments may be a no-op, but
|
|
|
|
|
* the later close would make the fd invalid.
|
|
|
|
|
* Handle this edge case.
|
|
|
|
|
*/
|
2021-10-22 02:13:08 +02:00
|
|
|
if (*from == to)
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
return true;
|
|
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
if (dup2(*from, to) == -1)
|
2017-03-10 11:48:43 +01:00
|
|
|
return false;
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
|
|
|
|
|
/* dup2 does not duplicate flags, copy it here.
|
|
|
|
|
* This should be benign; the only POSIX-defined
|
|
|
|
|
* flag is FD_CLOEXEC, and we only use it rarely.
|
|
|
|
|
*/
|
2021-10-22 02:13:08 +02:00
|
|
|
if (fcntl(to, F_SETFD, fcntl(*from, F_GETFD)) < 0)
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
return false;
|
|
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
close(*from);
|
|
|
|
|
*from = to;
|
2017-03-10 11:48:43 +01:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
/* Returns index of fds which is == this fd, or -1 */
|
|
|
|
|
static int fd_used(int **fds, size_t num_fds, int fd)
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
{
|
2021-10-22 02:13:08 +02:00
|
|
|
for (size_t i = 0; i < num_fds; i++) {
|
|
|
|
|
if (*fds[i] == fd)
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
/* Move an series of fd pointers into 0, 1, ... */
|
|
|
|
|
static bool shuffle_fds(int **fds, size_t num_fds)
|
|
|
|
|
{
|
|
|
|
|
/* If we need to move an fd out the way, this is a good place to start
|
|
|
|
|
* looking */
|
|
|
|
|
size_t next_free_fd = num_fds;
|
|
|
|
|
for (size_t i = 0; i < num_fds; i++) {
|
|
|
|
|
int in_the_way;
|
|
|
|
|
|
|
|
|
|
/* Already in the right place? Great! */
|
|
|
|
|
if (*fds[i] == i)
|
|
|
|
|
continue;
|
|
|
|
|
/* Is something we care about in the way? */
|
|
|
|
|
in_the_way = fd_used(fds + i, num_fds - i, i);
|
|
|
|
|
if (in_the_way != -1) {
|
|
|
|
|
/* Find a high-numbered unused fd. */
|
|
|
|
|
while (fd_used(fds + i, num_fds - i, next_free_fd) != -1)
|
|
|
|
|
next_free_fd++;
|
|
|
|
|
/* Trick: in_the_way is offset by i! */
|
|
|
|
|
if (!move_fd(fds[i + in_the_way], next_free_fd))
|
|
|
|
|
return false;
|
|
|
|
|
next_free_fd++;
|
|
|
|
|
}
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
/* Now there should be nothing in the way. */
|
|
|
|
|
assert(fd_used(fds, num_fds, i) == -1);
|
|
|
|
|
if (!move_fd(fds[i], i))
|
|
|
|
|
return false;
|
|
|
|
|
}
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
struct subd_req {
|
|
|
|
|
struct list_node list;
|
|
|
|
|
|
|
|
|
|
/* Callback for a reply. */
|
2017-06-24 08:25:53 +02:00
|
|
|
int type;
|
2017-10-12 08:35:04 +02:00
|
|
|
void (*replycb)(struct subd *, const u8 *, const int *, void *);
|
2017-03-10 11:48:43 +01:00
|
|
|
void *replycb_data;
|
2017-03-19 21:31:30 +01:00
|
|
|
|
2017-03-19 21:31:35 +01:00
|
|
|
size_t num_reply_fds;
|
2017-04-01 12:58:30 +02:00
|
|
|
/* If non-NULL, this is here to disable replycb */
|
|
|
|
|
void *disabler;
|
2017-03-10 11:48:43 +01:00
|
|
|
};
|
|
|
|
|
|
2018-02-14 02:53:13 +01:00
|
|
|
static void destroy_subd_req(struct subd_req *sr)
|
2017-03-10 11:48:43 +01:00
|
|
|
{
|
|
|
|
|
list_del(&sr->list);
|
2017-04-01 12:58:30 +02:00
|
|
|
/* Don't disable once we're freed! */
|
|
|
|
|
if (sr->disabler)
|
|
|
|
|
tal_free(sr->disabler);
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
2017-04-01 12:58:30 +02:00
|
|
|
/* Called when the callback is disabled because caller was freed. */
|
2018-02-21 16:06:07 +01:00
|
|
|
static void ignore_reply(struct subd *sd, const u8 *msg UNUSED, const int *fds,
|
|
|
|
|
void *arg UNUSED)
|
2017-04-01 12:58:30 +02:00
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
log_debug(sd->log, "IGNORING REPLY");
|
|
|
|
|
for (i = 0; i < tal_count(fds); i++)
|
|
|
|
|
close(fds[i]);
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-21 16:06:07 +01:00
|
|
|
static void disable_cb(void *disabler UNUSED, struct subd_req *sr)
|
2017-04-01 12:58:30 +02:00
|
|
|
{
|
|
|
|
|
sr->replycb = ignore_reply;
|
|
|
|
|
sr->disabler = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void add_req(const tal_t *ctx,
|
|
|
|
|
struct subd *sd, int type, size_t num_fds_in,
|
2017-10-12 08:35:04 +02:00
|
|
|
void (*replycb)(struct subd *, const u8 *, const int *,
|
2017-03-19 21:31:30 +01:00
|
|
|
void *),
|
|
|
|
|
void *replycb_data)
|
2017-03-10 11:48:43 +01:00
|
|
|
{
|
|
|
|
|
struct subd_req *sr = tal(sd, struct subd_req);
|
|
|
|
|
|
2017-06-24 08:25:53 +02:00
|
|
|
sr->type = type;
|
2017-03-10 11:48:43 +01:00
|
|
|
sr->replycb = replycb;
|
|
|
|
|
sr->replycb_data = replycb_data;
|
2017-03-19 21:31:35 +01:00
|
|
|
sr->num_reply_fds = num_fds_in;
|
2017-04-01 12:58:30 +02:00
|
|
|
|
|
|
|
|
/* We don't allocate sr off ctx, because we still have to handle the
|
|
|
|
|
* case where ctx is freed between request and reply. Hence this
|
|
|
|
|
* trick. */
|
|
|
|
|
if (ctx) {
|
2018-08-24 07:20:06 +02:00
|
|
|
sr->disabler = notleak(tal(ctx, char));
|
2017-04-01 12:58:30 +02:00
|
|
|
tal_add_destructor2(sr->disabler, disable_cb, sr);
|
|
|
|
|
} else
|
|
|
|
|
sr->disabler = NULL;
|
2017-06-24 08:25:53 +02:00
|
|
|
assert(strends(sd->msgname(sr->type + SUBD_REPLY_OFFSET), "_REPLY"));
|
2017-03-10 11:48:43 +01:00
|
|
|
|
|
|
|
|
/* Keep in FIFO order: we sent in order, so replies will be too. */
|
|
|
|
|
list_add_tail(&sd->reqs, &sr->list);
|
2018-02-14 02:53:13 +01:00
|
|
|
tal_add_destructor(sr, destroy_subd_req);
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Caller must free. */
|
|
|
|
|
static struct subd_req *get_req(struct subd *sd, int reply_type)
|
|
|
|
|
{
|
|
|
|
|
struct subd_req *sr;
|
|
|
|
|
|
|
|
|
|
list_for_each(&sd->reqs, sr, list) {
|
2017-06-24 08:25:53 +02:00
|
|
|
if (sr->type + SUBD_REPLY_OFFSET == reply_type)
|
2017-03-10 11:48:43 +01:00
|
|
|
return sr;
|
2017-06-24 08:25:53 +02:00
|
|
|
/* If it's a fail, and that's a valid type. */
|
|
|
|
|
if (sr->type + SUBD_REPLYFAIL_OFFSET == reply_type
|
|
|
|
|
&& strends(sd->msgname(reply_type), "_REPLYFAIL")) {
|
|
|
|
|
sr->num_reply_fds = 0;
|
|
|
|
|
return sr;
|
|
|
|
|
}
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-11 11:59:50 +02:00
|
|
|
static void close_taken_fds(va_list *ap)
|
|
|
|
|
{
|
|
|
|
|
int *fd;
|
|
|
|
|
|
|
|
|
|
while ((fd = va_arg(*ap, int *)) != NULL) {
|
2018-01-08 21:09:01 +01:00
|
|
|
if (taken(fd) && *fd >= 0) {
|
2017-10-11 11:59:50 +02:00
|
|
|
close(*fd);
|
|
|
|
|
*fd = -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
/* We use sockets, not pipes, because fds are bidir. */
|
2020-02-04 01:14:13 +01:00
|
|
|
static int subd(const char *path, const char *name,
|
2018-02-05 05:09:28 +01:00
|
|
|
const char *debug_subdaemon,
|
2022-01-08 14:25:29 +01:00
|
|
|
int *msgfd,
|
2019-11-18 01:27:17 +01:00
|
|
|
bool io_logging,
|
|
|
|
|
va_list *ap)
|
2017-03-10 11:48:43 +01:00
|
|
|
{
|
|
|
|
|
int childmsg[2], execfail[2];
|
|
|
|
|
pid_t childpid;
|
2017-05-23 14:17:34 +02:00
|
|
|
int err, *fd;
|
2017-03-10 11:48:43 +01:00
|
|
|
|
|
|
|
|
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, childmsg) != 0)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
if (pipe(execfail) != 0)
|
|
|
|
|
goto close_msgfd_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) {
|
2018-02-05 05:09:28 +01:00
|
|
|
size_t num_args;
|
2022-01-08 14:25:29 +01:00
|
|
|
char *args[] = { NULL, NULL, NULL, NULL };
|
2021-10-22 02:13:08 +02:00
|
|
|
int **fds = tal_arr(tmpctx, int *, 3);
|
2021-11-16 01:07:43 +01:00
|
|
|
int stdoutfd = STDOUT_FILENO, stderrfd = STDERR_FILENO;
|
2017-03-10 11:48:43 +01:00
|
|
|
|
|
|
|
|
close(childmsg[0]);
|
|
|
|
|
close(execfail[0]);
|
|
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
/* msg = STDIN (0) */
|
|
|
|
|
fds[0] = &childmsg[1];
|
|
|
|
|
/* These are untouched */
|
2021-11-16 01:07:43 +01:00
|
|
|
fds[1] = &stdoutfd;
|
|
|
|
|
fds[2] = &stderrfd;
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2018-07-09 13:17:59 +02:00
|
|
|
while ((fd = va_arg(*ap, int *)) != NULL) {
|
2021-10-22 02:13:08 +02:00
|
|
|
assert(*fd != -1);
|
|
|
|
|
tal_arr_expand(&fds, fd);
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
/* Finally, the fd to report exec errors on */
|
|
|
|
|
tal_arr_expand(&fds, &execfail[1]);
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
|
2021-10-22 02:13:08 +02:00
|
|
|
if (!shuffle_fds(fds, tal_count(fds)))
|
*: Use new closefrom module from ccan.
This also inadvertently fixes a latent bug: before this patch, in the
`subd` function in `lightningd/subd.c`, we would close `execfail[1]`
*before* doing an `exec`.
We use an EOF on `execfail[1]` as a signal that `exec` succeeded (the
fd is marked CLOEXEC), and otherwise use it to pump `errno` to the
parent.
The intent is that this fd should be kept open until `exec`, at which
point CLOEXEC triggers and close that fd and sends the EOF, *or* if
`exec` fails we can send the `errno` to the parent process vua that
pipe-end.
However, in the previous version, we end up closing that fd *before*
reaching `exec`, either in the loop which `dup2`s passed-in fds (by
overwriting `execfail[1]` with a `dup2`) or in the "close everything"
loop, which does not guard against `execfail[1]`, only
`dev_disconnect_fd`.
2021-10-19 05:35:44 +02:00
|
|
|
goto child_errno_fail;
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
/* Make (fairly!) sure all other fds are closed. */
|
2021-12-28 00:20:09 +01:00
|
|
|
closefrom(tal_count(fds));
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2018-02-05 05:09:28 +01:00
|
|
|
num_args = 0;
|
2020-02-04 01:14:13 +01:00
|
|
|
args[num_args++] = tal_strdup(NULL, path);
|
2019-11-18 01:27:17 +01:00
|
|
|
if (io_logging)
|
|
|
|
|
args[num_args++] = "--log-io";
|
2017-10-24 04:06:14 +02:00
|
|
|
#if DEVELOPER
|
|
|
|
|
if (debug_subdaemon && strends(name, debug_subdaemon))
|
2018-02-05 05:09:28 +01:00
|
|
|
args[num_args++] = "--debugger";
|
2017-10-24 04:06:14 +02:00
|
|
|
#endif
|
2018-02-05 05:09:28 +01:00
|
|
|
execv(args[0], args);
|
2017-03-10 11:48:43 +01:00
|
|
|
|
|
|
|
|
child_errno_fail:
|
|
|
|
|
err = errno;
|
|
|
|
|
/* Gcc's warn-unused-result fail. */
|
|
|
|
|
if (write(execfail[1], &err, sizeof(err))) {
|
|
|
|
|
;
|
|
|
|
|
}
|
|
|
|
|
exit(127);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
close(childmsg[1]);
|
|
|
|
|
close(execfail[1]);
|
|
|
|
|
|
2017-10-11 11:59:50 +02:00
|
|
|
if (ap)
|
|
|
|
|
close_taken_fds(ap);
|
2017-03-10 11:48:43 +01:00
|
|
|
|
|
|
|
|
/* 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]);
|
|
|
|
|
*msgfd = childmsg[0];
|
|
|
|
|
return childpid;
|
|
|
|
|
|
|
|
|
|
close_execfail_fail:
|
|
|
|
|
close_noerr(execfail[0]);
|
|
|
|
|
close_noerr(execfail[1]);
|
|
|
|
|
close_msgfd_fail:
|
|
|
|
|
close_noerr(childmsg[0]);
|
|
|
|
|
close_noerr(childmsg[1]);
|
|
|
|
|
fail:
|
2017-10-11 11:59:50 +02:00
|
|
|
if (ap)
|
|
|
|
|
close_taken_fds(ap);
|
2017-03-10 11:48:43 +01:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct io_plan *sd_msg_read(struct io_conn *conn, struct subd *sd);
|
|
|
|
|
|
2018-02-21 16:06:07 +01:00
|
|
|
static void mark_freed(struct subd *unused UNUSED, bool *freed)
|
2017-10-12 08:35:04 +02:00
|
|
|
{
|
|
|
|
|
*freed = true;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
static struct io_plan *sd_msg_reply(struct io_conn *conn, struct subd *sd,
|
|
|
|
|
struct subd_req *sr)
|
|
|
|
|
{
|
|
|
|
|
int type = fromwire_peektype(sd->msg_in);
|
2017-10-12 08:35:04 +02:00
|
|
|
bool freed = false;
|
2017-10-12 08:35:03 +02:00
|
|
|
int *fds_in;
|
2017-03-19 21:31:30 +01:00
|
|
|
|
2018-01-15 23:47:25 +01:00
|
|
|
log_debug(sd->log, "REPLY %s with %zu fds",
|
|
|
|
|
sd->msgname(type), tal_count(sd->fds_in));
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2017-08-17 03:03:55 +02:00
|
|
|
/* Callback could free sd! Make sure destroy_subd() won't free conn */
|
|
|
|
|
sd->conn = NULL;
|
|
|
|
|
|
|
|
|
|
/* We want to free the msg_in, unless they tal_steal() it. */
|
|
|
|
|
tal_steal(tmpctx, sd->msg_in);
|
|
|
|
|
|
2017-10-12 08:35:03 +02:00
|
|
|
/* And we need to free sr after this too. */
|
2017-08-17 03:03:55 +02:00
|
|
|
tal_steal(tmpctx, sr);
|
2017-10-12 08:35:03 +02:00
|
|
|
/* In case they free sd, don't deref. */
|
|
|
|
|
list_del_init(&sr->list);
|
2017-08-17 03:03:55 +02:00
|
|
|
|
2017-10-12 08:35:03 +02:00
|
|
|
/* Free this array after, too. */
|
|
|
|
|
fds_in = tal_steal(tmpctx, sd->fds_in);
|
|
|
|
|
sd->fds_in = NULL;
|
|
|
|
|
|
2017-10-12 08:35:04 +02:00
|
|
|
/* Find out if they freed it. */
|
|
|
|
|
tal_add_destructor2(sd, mark_freed, &freed);
|
|
|
|
|
sr->replycb(sd, sd->msg_in, fds_in, sr->replycb_data);
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2017-10-12 08:35:04 +02:00
|
|
|
if (freed)
|
2017-03-10 11:48:43 +01:00
|
|
|
return io_close(conn);
|
|
|
|
|
|
2017-10-12 08:35:04 +02:00
|
|
|
tal_del_destructor2(sd, mark_freed, &freed);
|
|
|
|
|
|
2017-08-17 03:03:55 +02:00
|
|
|
/* Restore conn ptr. */
|
|
|
|
|
sd->conn = conn;
|
2017-03-10 11:48:43 +01:00
|
|
|
return io_read_wire(conn, sd, &sd->msg_in, sd_msg_read, sd);
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-19 21:31:35 +01:00
|
|
|
static struct io_plan *read_fds(struct io_conn *conn, struct subd *sd)
|
|
|
|
|
{
|
|
|
|
|
if (sd->num_fds_in_read == tal_count(sd->fds_in)) {
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
/* Don't trust subd to set it blocking. */
|
|
|
|
|
for (i = 0; i < tal_count(sd->fds_in); i++)
|
2017-07-04 02:47:02 +02:00
|
|
|
io_fd_block(sd->fds_in[i], true);
|
2017-03-19 21:31:35 +01:00
|
|
|
return sd_msg_read(conn, sd);
|
|
|
|
|
}
|
|
|
|
|
return io_recv_fd(conn, &sd->fds_in[sd->num_fds_in_read++],
|
|
|
|
|
read_fds, sd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct io_plan *sd_collect_fds(struct io_conn *conn, struct subd *sd,
|
|
|
|
|
size_t num_fds)
|
|
|
|
|
{
|
|
|
|
|
assert(!sd->fds_in);
|
|
|
|
|
sd->fds_in = tal_arr(sd, int, num_fds);
|
|
|
|
|
sd->num_fds_in_read = 0;
|
|
|
|
|
return read_fds(conn, sd);
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-12 06:55:52 +02:00
|
|
|
static void subdaemon_malformed_msg(struct subd *sd, const u8 *msg)
|
|
|
|
|
{
|
2018-02-08 02:25:12 +01:00
|
|
|
log_broken(sd->log, "%i: malformed message '%.s'",
|
2017-09-12 06:55:52 +02:00
|
|
|
fromwire_peektype(msg),
|
2018-01-10 09:46:12 +01:00
|
|
|
tal_hex(msg, msg));
|
2017-09-12 06:55:54 +02:00
|
|
|
|
2017-10-24 04:06:14 +02:00
|
|
|
#if DEVELOPER
|
2017-09-12 06:55:54 +02:00
|
|
|
if (sd->ld->dev_subdaemon_fail)
|
2018-08-02 08:49:55 +02:00
|
|
|
exit(1);
|
2017-10-24 04:06:14 +02:00
|
|
|
#endif
|
2017-09-12 06:55:52 +02:00
|
|
|
}
|
|
|
|
|
|
2018-02-08 02:25:12 +01:00
|
|
|
static bool log_status_fail(struct subd *sd, const u8 *msg)
|
2017-09-12 06:55:52 +02:00
|
|
|
{
|
2018-02-08 02:25:12 +01:00
|
|
|
const char *name = NULL;
|
|
|
|
|
enum status_failreason failreason;
|
|
|
|
|
char *desc;
|
|
|
|
|
|
2018-02-20 21:59:09 +01:00
|
|
|
if (!fromwire_status_fail(msg, msg, &failreason, &desc))
|
2018-02-08 02:25:12 +01:00
|
|
|
return false;
|
2017-09-12 06:55:52 +02:00
|
|
|
|
|
|
|
|
/* No 'default:' here so gcc gives warning if a new type added */
|
2018-02-08 02:25:12 +01:00
|
|
|
switch (failreason) {
|
2017-09-12 06:55:52 +02:00
|
|
|
case STATUS_FAIL_MASTER_IO:
|
|
|
|
|
name = "STATUS_FAIL_MASTER_IO";
|
2018-02-08 02:25:12 +01:00
|
|
|
break;
|
2017-09-12 06:55:52 +02:00
|
|
|
case STATUS_FAIL_HSM_IO:
|
|
|
|
|
name = "STATUS_FAIL_HSM_IO";
|
2018-02-08 02:25:12 +01:00
|
|
|
break;
|
2017-09-12 06:55:52 +02:00
|
|
|
case STATUS_FAIL_GOSSIP_IO:
|
|
|
|
|
name = "STATUS_FAIL_GOSSIP_IO";
|
2018-02-08 02:25:12 +01:00
|
|
|
break;
|
2017-09-12 06:55:52 +02:00
|
|
|
case STATUS_FAIL_INTERNAL_ERROR:
|
|
|
|
|
name = "STATUS_FAIL_INTERNAL_ERROR";
|
2018-02-08 02:25:12 +01:00
|
|
|
break;
|
2017-09-12 06:55:52 +02:00
|
|
|
}
|
2018-02-08 02:25:12 +01:00
|
|
|
/* fromwire_status_fail() guarantees it's one of those... */
|
2018-02-08 02:25:12 +01:00
|
|
|
assert(name);
|
2017-09-12 06:55:52 +02:00
|
|
|
|
2018-02-08 02:25:12 +01:00
|
|
|
log_broken(sd->log, "%s: %s", name, desc);
|
2017-09-12 06:55:54 +02:00
|
|
|
|
2017-10-24 04:06:14 +02:00
|
|
|
#if DEVELOPER
|
2017-09-12 06:55:54 +02:00
|
|
|
if (sd->ld->dev_subdaemon_fail)
|
2018-08-02 08:49:55 +02:00
|
|
|
exit(1);
|
2017-10-24 04:06:14 +02:00
|
|
|
#endif
|
2018-02-08 02:25:12 +01:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-08 14:29:29 +01:00
|
|
|
static bool handle_peer_error(struct subd *sd, const u8 *msg, int fds[2])
|
2018-02-08 02:25:12 +01:00
|
|
|
{
|
2018-02-18 13:59:46 +01:00
|
|
|
void *channel = sd->channel;
|
2018-02-08 02:25:12 +01:00
|
|
|
struct channel_id channel_id;
|
|
|
|
|
char *desc;
|
2022-01-11 02:13:59 +01:00
|
|
|
struct peer_fd *peer_fd;
|
2018-02-19 02:06:15 +01:00
|
|
|
u8 *err_for_them;
|
2021-02-02 13:47:01 +01:00
|
|
|
bool warning;
|
2018-02-08 02:25:12 +01:00
|
|
|
|
2018-02-20 21:59:09 +01:00
|
|
|
if (!fromwire_status_peer_error(msg, msg,
|
2021-02-02 13:47:01 +01:00
|
|
|
&channel_id, &desc, &warning,
|
2022-01-08 14:29:29 +01:00
|
|
|
&err_for_them))
|
2018-02-08 02:25:12 +01:00
|
|
|
return false;
|
2017-09-12 06:55:54 +02:00
|
|
|
|
2022-01-11 02:13:59 +01:00
|
|
|
peer_fd = new_peer_fd_arr(msg, fds);
|
2019-05-04 07:53:12 +02:00
|
|
|
|
|
|
|
|
/* Don't free sd; we may be about to free channel. */
|
2018-02-12 11:13:04 +01:00
|
|
|
sd->channel = NULL;
|
2022-01-11 02:13:59 +01:00
|
|
|
sd->errcb(channel, peer_fd, &channel_id, desc, warning, err_for_them);
|
2018-02-08 02:25:12 +01:00
|
|
|
return true;
|
2017-09-12 06:55:52 +02:00
|
|
|
}
|
|
|
|
|
|
2018-02-23 06:53:47 +01:00
|
|
|
static bool handle_set_billboard(struct subd *sd, const u8 *msg)
|
|
|
|
|
{
|
|
|
|
|
bool perm;
|
|
|
|
|
char *happenings;
|
|
|
|
|
|
|
|
|
|
if (!fromwire_status_peer_billboard(msg, msg, &perm, &happenings))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
sd->billboardcb(sd->channel, perm, happenings);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-08 06:43:46 +02:00
|
|
|
static bool handle_version(struct subd *sd, const u8 *msg)
|
|
|
|
|
{
|
|
|
|
|
char *ver;
|
|
|
|
|
|
|
|
|
|
if (!fromwire_status_version(msg, msg, &ver))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if (!streq(ver, version())) {
|
2021-04-16 06:31:24 +02:00
|
|
|
log_broken(sd->log, "version '%s' not '%s': restarting",
|
|
|
|
|
ver, version());
|
|
|
|
|
sd->ld->try_reexec = true;
|
|
|
|
|
/* Return us to toplevel lightningd.c */
|
|
|
|
|
io_break(sd->ld);
|
|
|
|
|
return false;
|
2021-04-08 06:43:46 +02:00
|
|
|
}
|
2021-04-16 06:31:26 +02:00
|
|
|
|
|
|
|
|
sd->rcvd_version = true;
|
|
|
|
|
/* In case there are outgoing msgs, we can send now. */
|
|
|
|
|
msg_wake(sd->outq);
|
|
|
|
|
|
2021-04-08 06:43:46 +02:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
static struct io_plan *sd_msg_read(struct io_conn *conn, struct subd *sd)
|
|
|
|
|
{
|
|
|
|
|
int type = fromwire_peektype(sd->msg_in);
|
|
|
|
|
struct subd_req *sr;
|
2017-11-01 02:10:48 +01:00
|
|
|
struct db *db = sd->ld->wallet->db;
|
|
|
|
|
struct io_plan *plan;
|
2018-09-20 05:06:42 +02:00
|
|
|
unsigned int i;
|
|
|
|
|
bool freed = false;
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2017-11-01 02:10:48 +01:00
|
|
|
/* Everything we do, we wrap in a database transaction */
|
|
|
|
|
db_begin_transaction(db);
|
|
|
|
|
|
|
|
|
|
if (type == -1)
|
|
|
|
|
goto malformed;
|
2017-03-10 11:48:43 +01:00
|
|
|
|
|
|
|
|
/* First, check for replies. */
|
|
|
|
|
sr = get_req(sd, type);
|
|
|
|
|
if (sr) {
|
2017-11-01 02:10:48 +01:00
|
|
|
if (sr->num_reply_fds && sd->fds_in == NULL) {
|
|
|
|
|
plan = sd_collect_fds(conn, sd, sr->num_reply_fds);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2017-03-19 21:31:35 +01:00
|
|
|
|
|
|
|
|
assert(sr->num_reply_fds == tal_count(sd->fds_in));
|
2017-11-01 02:10:48 +01:00
|
|
|
plan = sd_msg_reply(conn, sd, sr);
|
|
|
|
|
goto out;
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
2018-03-15 07:10:20 +01:00
|
|
|
/* If not stolen, we'll free this later. */
|
2017-03-10 11:48:43 +01:00
|
|
|
tal_steal(tmpctx, sd->msg_in);
|
|
|
|
|
|
2018-02-08 02:25:12 +01:00
|
|
|
/* We handle status messages ourselves. */
|
2020-08-25 04:19:38 +02:00
|
|
|
switch ((enum status_wire)type) {
|
2018-02-08 02:25:12 +01:00
|
|
|
case WIRE_STATUS_LOG:
|
|
|
|
|
case WIRE_STATUS_IO:
|
2019-11-17 12:41:33 +01:00
|
|
|
if (!log_status_msg(sd->log, sd->node_id, sd->msg_in))
|
2018-02-08 02:25:12 +01:00
|
|
|
goto malformed;
|
2017-09-12 06:55:52 +02:00
|
|
|
goto next;
|
2018-02-08 02:25:12 +01:00
|
|
|
case WIRE_STATUS_FAIL:
|
|
|
|
|
if (!log_status_fail(sd, sd->msg_in))
|
|
|
|
|
goto malformed;
|
|
|
|
|
goto close;
|
|
|
|
|
case WIRE_STATUS_PEER_CONNECTION_LOST:
|
2018-02-12 11:13:04 +01:00
|
|
|
if (!sd->channel)
|
2018-02-08 02:25:12 +01:00
|
|
|
goto malformed;
|
|
|
|
|
log_info(sd->log, "Peer connection lost");
|
|
|
|
|
goto close;
|
2018-02-23 06:53:47 +01:00
|
|
|
case WIRE_STATUS_PEER_BILLBOARD:
|
|
|
|
|
if (!sd->channel)
|
|
|
|
|
goto malformed;
|
|
|
|
|
if (!handle_set_billboard(sd, sd->msg_in))
|
|
|
|
|
goto malformed;
|
|
|
|
|
goto next;
|
2021-04-08 06:43:46 +02:00
|
|
|
case WIRE_STATUS_VERSION:
|
|
|
|
|
if (!handle_version(sd, sd->msg_in))
|
2021-04-16 06:31:24 +02:00
|
|
|
goto close;
|
2021-04-08 06:43:46 +02:00
|
|
|
goto next;
|
2018-02-19 02:06:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (sd->channel) {
|
2020-08-25 04:19:38 +02:00
|
|
|
switch ((enum peer_status_wire)type) {
|
2018-02-19 02:06:15 +01:00
|
|
|
case WIRE_STATUS_PEER_ERROR:
|
2022-01-08 14:29:29 +01:00
|
|
|
/* We expect 2 fds after this */
|
2018-02-19 02:06:15 +01:00
|
|
|
if (!sd->fds_in) {
|
|
|
|
|
/* Don't free msg_in: we go around again. */
|
|
|
|
|
tal_steal(sd, sd->msg_in);
|
2022-01-08 14:29:29 +01:00
|
|
|
plan = sd_collect_fds(conn, sd, 2);
|
2018-02-19 02:06:15 +01:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (!handle_peer_error(sd, sd->msg_in, sd->fds_in))
|
2018-02-19 02:06:15 +01:00
|
|
|
goto malformed;
|
|
|
|
|
goto close;
|
|
|
|
|
}
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
2017-09-12 06:55:52 +02:00
|
|
|
|
2018-09-20 05:06:42 +02:00
|
|
|
/* Might free sd (if returns negative); save/restore sd->conn */
|
|
|
|
|
sd->conn = NULL;
|
|
|
|
|
tal_add_destructor2(sd, mark_freed, &freed);
|
2017-10-12 08:35:04 +02:00
|
|
|
|
2018-09-20 05:06:42 +02:00
|
|
|
i = sd->msgcb(sd, sd->msg_in, sd->fds_in);
|
|
|
|
|
if (freed)
|
|
|
|
|
goto close;
|
|
|
|
|
tal_del_destructor2(sd, mark_freed, &freed);
|
2017-10-12 08:35:04 +02:00
|
|
|
|
2018-09-20 05:06:42 +02:00
|
|
|
sd->conn = conn;
|
2017-10-12 08:35:03 +02:00
|
|
|
|
2018-09-20 05:06:42 +02:00
|
|
|
if (i != 0) {
|
|
|
|
|
/* Don't ask for fds twice! */
|
|
|
|
|
assert(!sd->fds_in);
|
|
|
|
|
/* Don't free msg_in: we go around again. */
|
|
|
|
|
tal_steal(sd, sd->msg_in);
|
|
|
|
|
plan = sd_collect_fds(conn, sd, i);
|
|
|
|
|
goto out;
|
2017-09-12 06:55:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
next:
|
2017-03-10 11:48:43 +01:00
|
|
|
sd->msg_in = NULL;
|
2017-03-19 21:31:35 +01:00
|
|
|
sd->fds_in = tal_free(sd->fds_in);
|
2017-11-01 02:10:48 +01:00
|
|
|
|
|
|
|
|
plan = io_read_wire(conn, sd, &sd->msg_in, sd_msg_read, sd);
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
malformed:
|
|
|
|
|
subdaemon_malformed_msg(sd, sd->msg_in);
|
|
|
|
|
close:
|
|
|
|
|
plan = io_close(conn);
|
|
|
|
|
out:
|
|
|
|
|
db_commit_transaction(db);
|
|
|
|
|
return plan;
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
2017-11-01 02:10:48 +01:00
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
static void destroy_subd(struct subd *sd)
|
|
|
|
|
{
|
|
|
|
|
int status;
|
2019-09-12 02:24:00 +02:00
|
|
|
bool fail_if_subd_fails;
|
2017-10-24 04:06:14 +02:00
|
|
|
|
2019-09-12 02:24:00 +02:00
|
|
|
fail_if_subd_fails = IFDEV(sd->ld->dev_subdaemon_fail, false);
|
2022-01-22 05:49:22 +01:00
|
|
|
list_del_from(&sd->ld->subds, &sd->list);
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2022-01-22 05:49:22 +01:00
|
|
|
/* lightningd may have already done waitpid() */
|
|
|
|
|
if (sd->wstatus != NULL) {
|
|
|
|
|
status = *sd->wstatus;
|
|
|
|
|
} else {
|
|
|
|
|
switch (waitpid(sd->pid, &status, WNOHANG)) {
|
|
|
|
|
case 0:
|
|
|
|
|
/* If it's an essential daemon, don't kill: we want the
|
|
|
|
|
* exit status */
|
|
|
|
|
if (!sd->must_not_exit) {
|
|
|
|
|
log_debug(sd->log,
|
|
|
|
|
"Status closed, but not exited. Killing");
|
|
|
|
|
kill(sd->pid, SIGKILL);
|
|
|
|
|
}
|
|
|
|
|
waitpid(sd->pid, &status, 0);
|
|
|
|
|
fail_if_subd_fails = false;
|
|
|
|
|
break;
|
|
|
|
|
case -1:
|
|
|
|
|
log_broken(sd->log, "Status closed, but waitpid %i says %s",
|
|
|
|
|
sd->pid, strerror(errno));
|
|
|
|
|
status = -1;
|
|
|
|
|
break;
|
2017-12-11 03:53:28 +01:00
|
|
|
}
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
2017-08-18 06:43:52 +02:00
|
|
|
|
2018-08-02 08:49:55 +02:00
|
|
|
if (fail_if_subd_fails && WIFSIGNALED(status)) {
|
|
|
|
|
log_broken(sd->log, "Subdaemon %s killed with signal %i",
|
|
|
|
|
sd->name, WTERMSIG(status));
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2017-09-12 06:55:54 +02:00
|
|
|
|
2018-02-12 11:13:04 +01:00
|
|
|
/* In case we're freed manually, such as channel_fail_permanent */
|
2017-08-18 06:43:52 +02:00
|
|
|
if (sd->conn)
|
|
|
|
|
sd->conn = tal_free(sd->conn);
|
|
|
|
|
|
2017-10-12 08:35:03 +02:00
|
|
|
/* Peer still attached? */
|
2018-02-12 11:13:04 +01:00
|
|
|
if (sd->channel) {
|
2017-10-12 08:35:03 +02:00
|
|
|
/* Don't loop back when we fail it. */
|
2018-02-18 13:59:46 +01:00
|
|
|
void *channel = sd->channel;
|
2017-12-06 00:35:46 +01:00
|
|
|
struct db *db = sd->ld->wallet->db;
|
|
|
|
|
bool outer_transaction;
|
|
|
|
|
|
2018-02-23 06:53:47 +01:00
|
|
|
/* Clear any transient messages in billboard */
|
|
|
|
|
sd->billboardcb(channel, false, NULL);
|
2018-02-12 11:13:04 +01:00
|
|
|
sd->channel = NULL;
|
2017-12-06 00:35:46 +01:00
|
|
|
|
|
|
|
|
/* We can be freed both inside msg handling, or spontaneously. */
|
2019-07-23 20:45:06 +02:00
|
|
|
outer_transaction = db_in_transaction(db);
|
2017-12-06 00:35:46 +01:00
|
|
|
if (!outer_transaction)
|
|
|
|
|
db_begin_transaction(db);
|
2018-02-18 13:59:46 +01:00
|
|
|
if (sd->errcb)
|
2019-05-04 07:53:12 +02:00
|
|
|
sd->errcb(channel, NULL, NULL,
|
2018-02-18 13:59:46 +01:00
|
|
|
tal_fmt(sd, "Owning subdaemon %s died (%i)",
|
|
|
|
|
sd->name, status),
|
2019-07-26 04:11:19 +02:00
|
|
|
false, NULL);
|
2017-12-06 00:35:46 +01:00
|
|
|
if (!outer_transaction)
|
|
|
|
|
db_commit_transaction(db);
|
2017-10-12 08:35:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (sd->must_not_exit) {
|
|
|
|
|
if (WIFEXITED(status))
|
|
|
|
|
errx(1, "%s failed (exit status %i), exiting.",
|
|
|
|
|
sd->name, WEXITSTATUS(status));
|
|
|
|
|
errx(1, "%s failed (signal %u), exiting.",
|
|
|
|
|
sd->name, WTERMSIG(status));
|
|
|
|
|
}
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct io_plan *msg_send_next(struct io_conn *conn, struct subd *sd)
|
|
|
|
|
{
|
2021-04-16 06:31:26 +02:00
|
|
|
const u8 *msg;
|
2017-03-19 21:24:14 +01:00
|
|
|
int fd;
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2021-04-16 06:31:26 +02:00
|
|
|
/* Don't send if we haven't read version! */
|
|
|
|
|
if (!sd->rcvd_version)
|
|
|
|
|
return msg_queue_wait(conn, sd->outq, msg_send_next, sd);
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
/* Nothing to do? Wait for msg_enqueue. */
|
2021-04-16 06:31:26 +02:00
|
|
|
msg = msg_dequeue(sd->outq);
|
2017-03-10 11:48:43 +01:00
|
|
|
if (!msg)
|
2018-10-25 01:46:08 +02:00
|
|
|
return msg_queue_wait(conn, sd->outq, msg_send_next, sd);
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2022-01-11 02:16:18 +01:00
|
|
|
fd = msg_extract_fd(sd->outq, msg);
|
2017-03-19 21:24:14 +01:00
|
|
|
if (fd >= 0) {
|
2017-03-10 11:48:43 +01:00
|
|
|
tal_free(msg);
|
2017-03-19 21:24:14 +01:00
|
|
|
return io_send_fd(conn, fd, true, msg_send_next, sd);
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
return io_write_wire(conn, take(msg), msg_send_next, sd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct io_plan *msg_setup(struct io_conn *conn, struct subd *sd)
|
|
|
|
|
{
|
|
|
|
|
return io_duplex(conn,
|
|
|
|
|
io_read_wire(conn, sd, &sd->msg_in, sd_msg_read, sd),
|
|
|
|
|
msg_send_next(conn, sd));
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-12 08:35:03 +02:00
|
|
|
static struct subd *new_subd(struct lightningd *ld,
|
|
|
|
|
const char *name,
|
2018-02-18 13:59:46 +01:00
|
|
|
void *channel,
|
2019-11-17 12:40:33 +01:00
|
|
|
const struct node_id *node_id,
|
2018-02-18 13:59:46 +01:00
|
|
|
struct log *base_log,
|
2018-04-26 06:51:01 +02:00
|
|
|
bool talks_to_peer,
|
2017-10-12 08:35:03 +02:00
|
|
|
const char *(*msgname)(int msgtype),
|
2017-10-12 08:35:04 +02:00
|
|
|
unsigned int (*msgcb)(struct subd *,
|
|
|
|
|
const u8 *, const int *fds),
|
2018-02-18 13:59:46 +01:00
|
|
|
void (*errcb)(void *channel,
|
2022-01-11 02:13:59 +01:00
|
|
|
struct peer_fd *peer_fd,
|
2018-02-18 13:59:46 +01:00
|
|
|
const struct channel_id *channel_id,
|
|
|
|
|
const char *desc,
|
2021-02-02 13:47:01 +01:00
|
|
|
bool warning,
|
2018-02-19 02:06:15 +01:00
|
|
|
const u8 *err_for_them),
|
2018-02-23 06:53:47 +01:00
|
|
|
void (*billboardcb)(void *channel,
|
|
|
|
|
bool perm,
|
|
|
|
|
const char *happenings),
|
2017-10-12 08:35:03 +02:00
|
|
|
va_list *ap)
|
2017-03-10 11:48:43 +01:00
|
|
|
{
|
2017-09-28 05:43:19 +02:00
|
|
|
struct subd *sd = tal(ld, struct subd);
|
2017-03-10 11:48:43 +01:00
|
|
|
int msg_fd;
|
2017-10-24 04:06:14 +02:00
|
|
|
const char *debug_subd = NULL;
|
2019-11-18 01:27:17 +01:00
|
|
|
const char *shortname;
|
2017-10-24 04:06:14 +02:00
|
|
|
|
2018-03-01 11:32:38 +01:00
|
|
|
assert(name != NULL);
|
|
|
|
|
|
2019-11-18 01:27:17 +01:00
|
|
|
/* This part of the name is a bit redundant for logging */
|
|
|
|
|
if (strstarts(name, "lightning_"))
|
|
|
|
|
shortname = name + strlen("lightning_");
|
|
|
|
|
else
|
|
|
|
|
shortname = name;
|
|
|
|
|
|
|
|
|
|
if (base_log) {
|
|
|
|
|
sd->log = new_log(sd, ld->log_book, node_id,
|
|
|
|
|
"%s-%s", shortname, log_prefix(base_log));
|
|
|
|
|
} else {
|
|
|
|
|
sd->log = new_log(sd, ld->log_book, node_id, "%s", shortname);
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-24 04:06:14 +02:00
|
|
|
#if DEVELOPER
|
2018-12-08 01:30:56 +01:00
|
|
|
debug_subd = ld->dev_debug_subprocess;
|
2017-10-24 04:06:14 +02:00
|
|
|
#endif /* DEVELOPER */
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2020-02-04 01:14:13 +01:00
|
|
|
const char *path = subdaemon_path(tmpctx, ld, name);
|
|
|
|
|
|
|
|
|
|
sd->pid = subd(path, name, debug_subd,
|
2022-01-08 14:25:29 +01:00
|
|
|
&msg_fd,
|
2019-11-18 01:27:17 +01:00
|
|
|
/* We only turn on subdaemon io logging if we're going
|
|
|
|
|
* to print it: too stressful otherwise! */
|
|
|
|
|
log_print_level(sd->log) < LOG_DBG,
|
|
|
|
|
ap);
|
2017-03-10 11:48:43 +01:00
|
|
|
if (sd->pid == (pid_t)-1) {
|
|
|
|
|
log_unusual(ld->log, "subd %s failed: %s",
|
|
|
|
|
name, strerror(errno));
|
|
|
|
|
return tal_free(sd);
|
|
|
|
|
}
|
|
|
|
|
sd->ld = ld;
|
2018-01-30 01:44:08 +01:00
|
|
|
|
2019-11-18 01:27:17 +01:00
|
|
|
sd->name = shortname;
|
2017-10-12 08:35:03 +02:00
|
|
|
sd->must_not_exit = false;
|
2018-04-26 06:51:01 +02:00
|
|
|
sd->talks_to_peer = talks_to_peer;
|
2017-03-10 11:48:43 +01:00
|
|
|
sd->msgname = msgname;
|
2018-09-20 05:06:42 +02:00
|
|
|
assert(msgname);
|
2017-03-10 11:48:43 +01:00
|
|
|
sd->msgcb = msgcb;
|
2018-09-20 05:06:42 +02:00
|
|
|
assert(msgcb);
|
2018-02-18 13:59:46 +01:00
|
|
|
sd->errcb = errcb;
|
2018-02-23 06:53:47 +01:00
|
|
|
sd->billboardcb = billboardcb;
|
2017-03-19 21:31:35 +01:00
|
|
|
sd->fds_in = NULL;
|
2022-01-11 02:16:18 +01:00
|
|
|
sd->outq = msg_queue_new(sd, true);
|
2022-01-22 05:49:22 +01:00
|
|
|
sd->wstatus = NULL;
|
|
|
|
|
list_add(&ld->subds, &sd->list);
|
2017-03-10 11:48:43 +01:00
|
|
|
tal_add_destructor(sd, destroy_subd);
|
|
|
|
|
list_head_init(&sd->reqs);
|
2018-02-12 11:13:04 +01:00
|
|
|
sd->channel = channel;
|
2021-04-16 06:31:26 +02:00
|
|
|
sd->rcvd_version = false;
|
2021-12-28 00:21:09 +01:00
|
|
|
sd->node_id = tal_dup_or_null(sd, struct node_id, node_id);
|
2017-03-10 11:48:43 +01:00
|
|
|
|
|
|
|
|
/* conn actually owns daemon: we die when it does. */
|
2017-09-28 05:43:19 +02:00
|
|
|
sd->conn = io_new_conn(ld, msg_fd, msg_setup, sd);
|
2017-03-10 11:48:43 +01:00
|
|
|
tal_steal(sd->conn, sd);
|
|
|
|
|
|
2019-11-17 12:41:33 +01:00
|
|
|
log_peer_debug(sd->log, node_id, "pid %u, msgfd %i", sd->pid, msg_fd);
|
2017-03-10 11:48:43 +01:00
|
|
|
|
2018-02-23 06:53:47 +01:00
|
|
|
/* Clear any old transient message. */
|
|
|
|
|
if (billboardcb)
|
|
|
|
|
billboardcb(sd->channel, false, NULL);
|
2017-03-10 11:48:43 +01:00
|
|
|
return sd;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-12 08:35:03 +02:00
|
|
|
struct subd *new_global_subd(struct lightningd *ld,
|
|
|
|
|
const char *name,
|
|
|
|
|
const char *(*msgname)(int msgtype),
|
2017-10-12 08:35:04 +02:00
|
|
|
unsigned int (*msgcb)(struct subd *, const u8 *,
|
|
|
|
|
const int *fds),
|
2017-10-12 08:35:03 +02:00
|
|
|
...)
|
|
|
|
|
{
|
|
|
|
|
va_list ap;
|
|
|
|
|
struct subd *sd;
|
|
|
|
|
|
|
|
|
|
va_start(ap, msgcb);
|
2021-01-20 02:51:15 +01:00
|
|
|
sd = new_subd(ld, name, NULL, NULL, NULL, false,
|
2020-12-01 21:49:35 +01:00
|
|
|
msgname, msgcb, NULL, NULL, &ap);
|
2017-10-12 08:35:03 +02:00
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
|
|
sd->must_not_exit = true;
|
|
|
|
|
return sd;
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 13:59:46 +01:00
|
|
|
struct subd *new_channel_subd_(struct lightningd *ld,
|
|
|
|
|
const char *name,
|
|
|
|
|
void *channel,
|
2019-11-17 12:40:33 +01:00
|
|
|
const struct node_id *node_id,
|
2018-02-18 13:59:46 +01:00
|
|
|
struct log *base_log,
|
2018-04-26 06:51:01 +02:00
|
|
|
bool talks_to_peer,
|
2018-02-18 13:59:46 +01:00
|
|
|
const char *(*msgname)(int msgtype),
|
|
|
|
|
unsigned int (*msgcb)(struct subd *, const u8 *,
|
|
|
|
|
const int *fds),
|
|
|
|
|
void (*errcb)(void *channel,
|
2022-01-11 02:13:59 +01:00
|
|
|
struct peer_fd *peer_fd,
|
2018-02-18 13:59:46 +01:00
|
|
|
const struct channel_id *channel_id,
|
|
|
|
|
const char *desc,
|
2021-02-02 13:47:01 +01:00
|
|
|
bool warning,
|
2018-02-19 02:06:15 +01:00
|
|
|
const u8 *err_for_them),
|
2018-02-23 06:53:47 +01:00
|
|
|
void (*billboardcb)(void *channel, bool perm,
|
|
|
|
|
const char *happenings),
|
2018-02-18 13:59:46 +01:00
|
|
|
...)
|
2017-10-12 08:35:03 +02:00
|
|
|
{
|
|
|
|
|
va_list ap;
|
|
|
|
|
struct subd *sd;
|
|
|
|
|
|
2018-02-23 06:53:47 +01:00
|
|
|
va_start(ap, billboardcb);
|
2021-01-20 02:51:15 +01:00
|
|
|
sd = new_subd(ld, name, channel, node_id, base_log,
|
2020-12-01 21:49:35 +01:00
|
|
|
talks_to_peer, msgname, msgcb, errcb, billboardcb, &ap);
|
2017-10-12 08:35:03 +02:00
|
|
|
va_end(ap);
|
|
|
|
|
return sd;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
void subd_send_msg(struct subd *sd, const u8 *msg_out)
|
|
|
|
|
{
|
2019-12-04 16:21:31 +01:00
|
|
|
u16 type = fromwire_peektype(msg_out);
|
2017-09-28 01:47:11 +02:00
|
|
|
/* FIXME: We should use unique upper bits for each daemon, then
|
|
|
|
|
* have generate-wire.py add them, just assert here. */
|
2020-08-31 03:13:25 +02:00
|
|
|
assert(!strstarts(common_wire_name(type), "INVALID") ||
|
2019-12-04 16:21:31 +01:00
|
|
|
!strstarts(sd->msgname(type), "INVALID"));
|
2018-10-25 01:46:08 +02:00
|
|
|
msg_enqueue(sd->outq, msg_out);
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void subd_send_fd(struct subd *sd, int fd)
|
|
|
|
|
{
|
2018-10-25 01:46:08 +02:00
|
|
|
msg_enqueue_fd(sd->outq, fd);
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
2017-04-01 12:58:30 +02:00
|
|
|
void subd_req_(const tal_t *ctx,
|
|
|
|
|
struct subd *sd,
|
2017-03-10 11:48:43 +01:00
|
|
|
const u8 *msg_out,
|
2017-03-19 21:31:30 +01:00
|
|
|
int fd_out, size_t num_fds_in,
|
2017-10-12 08:35:04 +02:00
|
|
|
void (*replycb)(struct subd *, const u8 *, const int *, void *),
|
2017-03-10 11:48:43 +01:00
|
|
|
void *replycb_data)
|
|
|
|
|
{
|
2017-03-14 01:27:48 +01:00
|
|
|
/* Grab type now in case msg_out is taken() */
|
|
|
|
|
int type = fromwire_peektype(msg_out);
|
|
|
|
|
|
2017-03-10 11:48:43 +01:00
|
|
|
subd_send_msg(sd, msg_out);
|
|
|
|
|
if (fd_out >= 0)
|
|
|
|
|
subd_send_fd(sd, fd_out);
|
|
|
|
|
|
2017-04-01 12:58:30 +02:00
|
|
|
add_req(ctx, sd, type, num_fds_in, replycb, replycb_data);
|
2017-03-10 11:48:43 +01:00
|
|
|
}
|
|
|
|
|
|
2019-08-14 06:25:23 +02:00
|
|
|
/* SIGALRM terminates by default: we just want it to interrupt waitpid(),
|
|
|
|
|
* which is implied by "handling" it. */
|
|
|
|
|
static void discard_alarm(int sig UNNEEDED)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-30 16:54:06 +02:00
|
|
|
struct subd *subd_shutdown(struct subd *sd, unsigned int seconds)
|
2017-04-12 08:52:32 +02:00
|
|
|
{
|
2019-08-14 06:25:23 +02:00
|
|
|
struct sigaction sa, old;
|
|
|
|
|
|
2017-04-12 08:52:32 +02:00
|
|
|
log_debug(sd->log, "Shutting down");
|
|
|
|
|
|
2017-10-12 08:35:03 +02:00
|
|
|
tal_del_destructor(sd, destroy_subd);
|
|
|
|
|
|
|
|
|
|
/* This should make it exit; steal so it stays around. */
|
2017-04-12 08:52:32 +02:00
|
|
|
tal_steal(sd->ld, sd);
|
|
|
|
|
sd->conn = tal_free(sd->conn);
|
|
|
|
|
|
2019-08-14 06:25:23 +02:00
|
|
|
/* Set up alarm to wake us up if child doesn't exit. */
|
|
|
|
|
sa.sa_handler = discard_alarm;
|
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
|
|
|
sa.sa_flags = 0;
|
|
|
|
|
sigaction(SIGALRM, &sa, &old);
|
|
|
|
|
alarm(seconds);
|
|
|
|
|
|
|
|
|
|
if (waitpid(sd->pid, NULL, 0) > 0) {
|
|
|
|
|
alarm(0);
|
|
|
|
|
sigaction(SIGALRM, &old, NULL);
|
2022-01-22 05:49:22 +01:00
|
|
|
list_del_from(&sd->ld->subds, &sd->list);
|
2019-08-14 06:25:23 +02:00
|
|
|
return tal_free(sd);
|
2017-04-12 08:52:32 +02:00
|
|
|
}
|
2017-10-12 08:35:03 +02:00
|
|
|
|
2019-08-14 06:25:23 +02:00
|
|
|
sigaction(SIGALRM, &old, NULL);
|
2017-10-12 08:35:03 +02:00
|
|
|
/* Didn't die? This will kill it harder */
|
|
|
|
|
sd->must_not_exit = false;
|
|
|
|
|
destroy_subd(sd);
|
2019-08-14 06:25:23 +02:00
|
|
|
return tal_free(sd);
|
2017-10-12 08:35:03 +02:00
|
|
|
}
|
|
|
|
|
|
2021-12-28 00:21:09 +01:00
|
|
|
void subd_release_channel(struct subd *owner, const void *channel)
|
2017-10-12 08:35:03 +02:00
|
|
|
{
|
|
|
|
|
/* If owner is a per-peer-daemon, and not already freeing itself... */
|
2018-02-12 11:13:04 +01:00
|
|
|
if (owner->channel) {
|
|
|
|
|
assert(owner->channel == channel);
|
|
|
|
|
owner->channel = NULL;
|
2017-10-12 08:35:03 +02:00
|
|
|
tal_free(owner);
|
|
|
|
|
}
|
2017-04-12 08:52:32 +02:00
|
|
|
}
|
|
|
|
|
|
2017-10-24 04:06:14 +02:00
|
|
|
#if DEVELOPER
|
2017-05-24 12:10:16 +02:00
|
|
|
char *opt_subd_dev_disconnect(const char *optarg, struct lightningd *ld)
|
|
|
|
|
{
|
|
|
|
|
ld->dev_disconnect_fd = open(optarg, O_RDONLY);
|
|
|
|
|
if (ld->dev_disconnect_fd < 0)
|
|
|
|
|
return tal_fmt(ld, "Could not open --dev-disconnect=%s: %s",
|
|
|
|
|
optarg, strerror(errno));
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2017-08-18 06:43:52 +02:00
|
|
|
|
|
|
|
|
/* If test specified that this disconnection should cause permanent failure */
|
|
|
|
|
bool dev_disconnect_permanent(struct lightningd *ld)
|
|
|
|
|
{
|
|
|
|
|
char permfail[strlen("PERMFAIL")];
|
|
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
if (ld->dev_disconnect_fd == -1)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
r = read(ld->dev_disconnect_fd, permfail, sizeof(permfail));
|
|
|
|
|
if (r < 0)
|
|
|
|
|
fatal("Reading dev_disconnect file: %s", strerror(errno));
|
|
|
|
|
|
2017-10-12 02:25:28 +02:00
|
|
|
if (memeq(permfail, r, "permfail", strlen("permfail")))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
/* Nope, restore. */
|
2018-01-09 08:13:35 +01:00
|
|
|
if (lseek(ld->dev_disconnect_fd, -r, SEEK_CUR) < 0) {
|
|
|
|
|
fatal("lseek failure");
|
|
|
|
|
}
|
2017-10-12 02:25:28 +02:00
|
|
|
return false;
|
2017-08-18 06:43:52 +02:00
|
|
|
}
|
2017-10-24 04:06:14 +02:00
|
|
|
#endif /* DEVELOPER */
|
2018-09-03 05:40:00 +02:00
|
|
|
|
|
|
|
|
/* Ugly helper to get full pathname of the current binary. */
|
|
|
|
|
const char *find_my_abspath(const tal_t *ctx, const char *argv0)
|
|
|
|
|
{
|
|
|
|
|
char *me;
|
|
|
|
|
|
|
|
|
|
/* A command containing / is run relative to the current directory,
|
|
|
|
|
* not searched through the path. The shell sets argv0 to the command
|
|
|
|
|
* run, though something else could set it to a arbitrary value and
|
|
|
|
|
* this logic would be wrong. */
|
|
|
|
|
if (strchr(argv0, PATH_SEP)) {
|
|
|
|
|
const char *path;
|
|
|
|
|
/* Absolute paths are easy. */
|
|
|
|
|
if (strstarts(argv0, PATH_SEP_STR))
|
|
|
|
|
path = argv0;
|
|
|
|
|
/* It contains a '/', it's relative to current dir. */
|
|
|
|
|
else
|
|
|
|
|
path = path_join(tmpctx, path_cwd(tmpctx), argv0);
|
|
|
|
|
|
|
|
|
|
me = path_canon(ctx, path);
|
|
|
|
|
if (!me || access(me, X_OK) != 0)
|
|
|
|
|
errx(1, "I cannot find myself at %s based on my name %s",
|
|
|
|
|
path, argv0);
|
|
|
|
|
} else {
|
|
|
|
|
/* No /, search path */
|
|
|
|
|
char **pathdirs;
|
|
|
|
|
const char *pathenv = getenv("PATH");
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
/* This replicates the standard shell path search algorithm */
|
|
|
|
|
if (!pathenv)
|
|
|
|
|
errx(1, "Cannot find myself: no $PATH set");
|
|
|
|
|
|
|
|
|
|
pathdirs = tal_strsplit(tmpctx, pathenv, ":", STR_NO_EMPTY);
|
|
|
|
|
me = NULL;
|
|
|
|
|
for (i = 0; pathdirs[i]; i++) {
|
|
|
|
|
/* This returns NULL if it doesn't exist. */
|
|
|
|
|
me = path_canon(ctx,
|
|
|
|
|
path_join(tmpctx, pathdirs[i], argv0));
|
|
|
|
|
if (me && access(me, X_OK) == 0)
|
|
|
|
|
break;
|
|
|
|
|
/* Nope, try again. */
|
|
|
|
|
me = tal_free(me);
|
|
|
|
|
}
|
|
|
|
|
if (!me)
|
|
|
|
|
errx(1, "Cannot find %s in $PATH", argv0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return me;
|
|
|
|
|
}
|
