* prefork-interp [<option> ..] <interpreter> [<script> [<args> ...]]
* prefork-interp [<option>,..],<interpreter> <script> [<args> ...]
* prefork-interp '[<option> ..] <interpreter>' <script> [<args> ...]
+ *
+ * Options must specify argument laundering mode.
+ * Currently the only mode supported is:
+ * -U unlaundered: setup and executor both get all arguments and env vars
+ * ident covers only env vars specified with -E
+ * ident covers only arguments interpreter and (if present) script
*/
/*
* Process structure:
* makes new listening socket
* makes first-instance socketpair
* forks setup (script, sock fds indicated in env)
- * fd0, fd1, fd2: from-outer-caller
+ * fd0, fd1, fd2: from-outer
* other fd: call(client-end)(fake)
* reaps setup (and reports error)
* (implicitly releases lock)
*
* setup (pre-exec) fd0: null,
- * fd[12: fd2-from-outer-caller
+ * fd[12]: fd2-from-outer
* env fds: listener, call(server-end)(fake)
- * env fds: orig-fd[01]
* close fd: lockfile
+ * possibly clean env, argv
*
* setup (script) runs initialisation parts of the script
* at prefork establishment point:
* forks for server
* [2] exits
*
- # server (pm) [1] [fd0: null],
- * [fd[12: fd2-from-outer-caller]
- * right away, forks one fa-monitor
+ * server (pm) [1] [fd0: null],
+ * [fd[12]: fd2-from-outer]
+ * right away, forks init monitor
* [2] closes outer caller fds and call(fake)
* [server (pm)] fd[012]: null
* other fds: listener, syslog
* runs in loop accepting and forking,
- * reaping and limiting children (incl fa-monitor)
+ * reaping and limiting children (incl init monitor)
* reports failures of monitors to syslog
*
- * f-a monitor forks executor
- * closes fd: listener
- * [fd[12: fd2-from-outer-caller]
- * [other fds: call(server-end)(fake), syslog]
- * runs as monitor, below
- *
- *
* [client (C wrapper)] if client connect succeeds:
* now fd: call(client-end)
* sends message with: cmdline, env
* sends fds
*
- * [server (script)] accepts, forks monitor
+ * [server (script)] accepts, forks subseq monitor
*
- * monitor [1] [fd[012]: null]
- * other fds: syslog, call(server-end)
+ * monitor [1] [fd0: null]
+ * (init [fd[12]: init: fd2-from-outer; subseq: null]
+ * or errors: init: fd2; subseq: syslog
+ * subseq) other fds: syslog, call(server-end)
* sends ack byte
* receives args, env, fds
* forks executor
*
* executor sorts out fds:
- * fd0, fd1, fd2: from-outer-caller
+ * fd0, fd1, fd2: from-outer
* close fds: call(server-end)
* retained fds: syslog
*
* exits normally
*
* [monitor] [fd[012]: null]
- * [other fds: call(server-end), syslog]
+ * [fd[12]: init: fd2-from-outer; subseq: null]
+ * [errors: init: fd2; subseq: syslog]
* reaps executor
* reports status via socket
*
- * [client (C wrapper)] [fd0, fd1, fd2: from-outer-caller]
+ * [client (C wrapper)] [fd0, fd1, fd2: from-outer]
* [other fd: call(client-end)]
* receives status, exits appropriately
* (if was bad signal, reports to stderr, exits 127)
*/
-struct sockaddr_un sun;
+#include <arpa/inet.h>
+
+#include "prefork.h"
+
+const char our_name[] = "prefork-interp";
+
+struct sockaddr_un sockaddr_sun;
#define ACK_BYTE '\n'
-static struct sockaddr_unix socket_sun;
static const char *const *executor_argv;
+void fusagemessage(FILE *f) {
+ fprintf(f, "usage: #!/usr/bin/prefork-interp [<options>]\n");
+}
+
+static int laundering;
+
+const struct cmdinfo cmdinfos[]= {
+ PREFORK_CMDINFOS
+ { 0, 'U', 0, .iassignto= &laundering, .arg= 'U' },
+ { 0 }
+};
+
+void ident_addinit(void) {
+ char ident_magic[1] = { 0 };
+ sha256_update(&identsc, sizeof(ident_magic), ident_magic);
+}
+
static void propagate_exit_status(int status, const char *what) {
int r;
if (WIFSIGNALED(status)) {
int sig = WTERMSIG(status);
- char *signame = strsignal(sig);
+ const char *signame = strsignal(sig);
if (signame == 0) signame = "unknown signal";
if (! WCOREDUMP(status) &&
sigset_t sset;
sigemptyset(&sset);
sigaddset(&sset, sig);
- r = sigprocmask(SA_UNBLOCK, sset, 0);
+ r = sigprocmask(SIG_UNBLOCK, &sset, 0);
if (r) diee("failed to reset signal block while propagating %s",
signame);
signame);
}
- die("setup failed due to signal %d %s%s", sig, signame,
+ die("%s failed due to signal %d %s%s", what, sig, signame,
WCOREDUMP(status) ? " (core dumped)" : "");
}
- die("setup failed with weird wait status %d 0x%x", status, status);
+ die("%s failed with weird wait status %d 0x%x", what, status, status);
}
-static void die_data_overflow __attribute((noreturn)) {
+static __attribute((noreturn)) void die_data_overflow(void) {
die("cannot handle data with length >2^32");
}
const void *data, size_t dl) {
if (len) {
if (dl >= SIZE_MAX - *len)
- die_data_overlow();
+ die_data_overflow();
*len += dl;
}
if (buf) {
}
}
-static void prepare_length(size_t *len, char **buf, size_t dl) {
- if (dl > UINT32_MAX) die_data_overflow();
- uint32_t dl = htonl(dl);
+static void prepare_length(size_t *len, char **buf, size_t dl_sz) {
+ if (dl_sz > UINT32_MAX) die_data_overflow();
+ uint32_t dl = htonl(dl_sz);
prepare_data(len, buf, &dl, sizeof(dl));
}
-static void prepare_string(size_t *len, char **buf, const char *string) {
+static void prepare_string(size_t *len, char **buf, const char *s) {
size_t sl = strlen(s);
prepare_data(len, buf, s, sl+1);
}
static void prepare_message(size_t *len, char **buf) {
const char *s;
- const char *const *p = environ;
+ const char *const *p = (void*)environ;
while ((s = *p++)) {
if (strchr(s, '='))
prepare_string(len, buf, s);
prepare_string(len, buf, s);
}
-static void send_fd(int via_fd, int payload_fd) {
+static void send_fd(FILE *call_sock, int payload_fd) {
+ int via_fd = fileno(call_sock);
+
union {
struct cmsghdr align;
char buf[CMSG_SPACE(sizeof(payload_fd))];
- } msg;
+ } cmsg_buf;
+
struct msghdr msg;
FILLZERO(msg);
-
- struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
- cmsg->cmsg_level = SOL_SOCKET;
- cmsg->cmsg_type = SCM_RIGHTS;
- cmsg->cmsg_len = CMSG_LEN(sizeof(payload_fd));
- *(int*)CMSG_DATA(cmsg) = payload_fd;
+ FILLZERO(cmsg_buf);
char dummy_byte = 0;
-
struct iovec iov;
- FIULLZERO(iov);
+ FILLZERO(iov);
iov.iov_base = &dummy_byte;
iov.iov_len = 1;
msg.msg_name = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
- msg.msg_control = msg.buf;
- msg.msg_controllen = sizeof(msg.buf);
+ msg.msg_control = cmsg_buf.buf;
+ msg.msg_controllen = sizeof(cmsg_buf.buf);
+
+ struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
+ cmsg->cmsg_level = SOL_SOCKET;
+ cmsg->cmsg_type = SCM_RIGHTS;
+ cmsg->cmsg_len = CMSG_LEN(sizeof(payload_fd));
+ *(int*)CMSG_DATA(cmsg) = payload_fd;
+
+ msg.msg_controllen = sizeof(cmsg_buf.buf);
for (;;) {
ssize_t r = sendmsg(via_fd, &msg, 0);
if (errno == EINTR) continue;
diee("send fd");
}
- assert!(r == 1);
+ assert(r == 1);
break;
}
}
-static void send_request(int call_fd, const char *const *argv) {
+static void send_request(FILE *call_sock) {
// Sending these first makes it easier for the script to
// use buffered IO for the message.
- send_fd(call_fd, 0);
- send_fd(call_fd, 1);
- send_fd(call_fd, 2);
+ send_fd(call_sock, 0);
+ send_fd(call_sock, 1);
+ send_fd(call_sock, 2);
size_t len = 4;
- prepare_message(&len, 0, argv);
+ prepare_message(&len, 0);
char *m = malloc(len);
if (!m) diee("failed to allocate for message");
char *p = m;
prepare_length(0, &p, len - 4);
- prepare_message(0, &p, argv);
+ prepare_message(0, &p);
assert(p == m + len);
- p = m;
- while (len) {
- ssize_t r = write(call_fd, p, len);
- if (r==-1) {
- if (errno == EINTR) continue;
- diee("write request");
- }
- assert(r <= len);
- assert(r > 0);
- len -= r;
- p += r;
+ ssize_t sr = fwrite(p, len, 1, call_sock);
+ if (sr != 1) diee("write request");
+}
+
+static FILE *call_sock_from_fd(int fd) {
+ int r;
+
+ FILE *call_sock = fdopen(fd, "r+");
+ if (!call_sock) diee("fdopen socket");
+
+ r = setvbuf(call_sock, 0, _IONBF, 0);
+ if (r) die("setvbuf socket");
+
+ return call_sock;
+}
+
+static bool was_eof(FILE *call_sock) {
+ return feof(call_sock) || errno==ECONNRESET;
+}
+
+// Does protocol exchange. Returns 0 if OK, -1 if peer was garbage.
+static int protocol_exchange(FILE *call_sock) {
+ char ack;
+ size_t sr = fread(&ack, sizeof(ack), 1, call_sock);
+ if (sr != 1) {
+ if (was_eof(call_sock)) return -1;
+ diee("read() ack byte");
}
+ if (ack != '\n') die("got ack byte 0x%02x, not '\n'", ack);
+
+ // We're committed now, send the request (or bail out)
+ send_request(call_sock);
+
+ return 0;
}
-// Returns: call(client-end) fd, or -1 to mean "is garbage"
+// Returns: call(client-end), or 0 to mean "is garbage"
// find_socket_path must have been called
-static int connect_existing(void) {
+static FILE *connect_existing(void) {
int r;
int fd = -1;
-
- bool isgarbage = check_garbage();
- if (isgarbage) goto x_garbage;
+ FILE *call_sock = 0;
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd==-1) diee("socket() for client");
- salen_t salen = sizeof(sun);
- r = connect(client, (const struct sockaddr*)&socket_sun, salen);
+ socklen_t salen = sizeof(sockaddr_sun);
+ r = connect(fd, (const struct sockaddr*)&sockaddr_sun, salen);
if (r==-1) {
- if (errno==ECONNREFUSED || errno==ENOENT) goto x_garbgae;
+ if (errno==ECONNREFUSED || errno==ENOENT) goto x_garbage;
diee("connect() %s", socket_path);
}
- for (;;) {
- char ack;
- sr = read(fd, &ack, 1);
- if (sr == -1) {
- if (errno==ECONNRESET) goto x_garbage;
- if (errno==EINTR) continue;
- diee("read() ack byte");
- }
- if (sr == 0) { goto x_garbage; }
- if (ack != '\n') die("got ack byte 0x%02x, not '\n'", ack);
- break;
- }
+ call_sock = call_sock_from_fd(fd);
+ fd = -1;
- // We're committed now, send the request (or bail out)
- send_request(call, argv);
+ if (protocol_exchange(call_sock) < 0)
+ goto x_garbage;
- return fd;
+ return call_sock;
x_garbage:
+ if (call_sock) fclose(call_sock);
if (fd >= 0) close(fd);
- return -1;
+ return 0;
}
-static void become_setup(int sfd, int fake_pair[2])
- __attribute__((noreturn))
-{
+static __attribute__((noreturn))
+void become_setup(int sfd, int fake_pair[2]) {
close(fake_pair[0]);
int call_fd = fake_pair[1];
if (dup2(null_0, 0)) diee("dup2 /dev/null onto stdin");
if (dup2(2, 1) != 1) die("dup2 stderr onto stdout");
- putenv(asprintf("PREFORK_INTERP=%d,%d,%d,%d,%s",
- sfd, call_fd, fd0_save, fd1_save, socket_path));
+ putenv(m_asprintf("PREFORK_INTERP=%d,%d,%d,%d,%s",
+ sfd, call_fd, fd0_save, fd1_save, socket_path));
- execvp(executor_argv[0], executor_argv);
+ execvp(executor_argv[0], (char**)executor_argv);
diee("execute %s", executor_argv[0]);
}
-static int connect_or_spawn(void) {
- int fd = connect_existing();
- if (fd >= 0) return fd;
+static FILE *connect_or_spawn(void) {
+ int r;
+
+ FILE *call_sock = connect_existing();
+ if (call_sock) return call_sock;
int lockfd = acquire_lock();
- fd = connect_existing();
- if (fd >= 0) { close(lockfd); return fd; }
+ call_sock = connect_existing();
+ if (call_sock) { close(lockfd); return call_sock; }
// We must start a fresh one, and we hold the lock
- r = unlink(socketpath);
- if (r<0) diee("failed to remove stale socket %s", socketpath);
+ r = unlink(socket_path);
+ if (r<0 && errno!=ENOENT)
+ diee("failed to remove stale socket %s", socket_path);
int fake_pair[2];
r = socketpair(AF_UNIX, SOCK_STREAM, 0, fake_pair);
int sfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sfd<0) diee("socket() for new listener");
- salen_t salen = sizeof(sun);
- r= bind(sfd, (const struct sockaddr*)&socket_sun, saledn);
+ socklen_t salen = sizeof(sockaddr_sun);
+ r= bind(sfd, (const struct sockaddr*)&sockaddr_sun, salen);
if (r<0) diee("bind() on new listener");
- // We never want callers to get ECONNREFUSED!.
+ // We never want callers to get ECONNREFUSED. But:
// There is a race here: from my RTFM they may get ECONNREFUSED
- // if they tr between our bind() and listen(). But if they do, they'll
+ // if they try between our bind() and listen(). But if they do, they'll
// acquire the lock (serialising with us) and retry, and then it will work.
r = listen(sfd, INT_MAX);
if (r<0) diee("listen() for new listener");
if (got == (pid_t)-1) diee("waitpid setup [%ld]", (long)setup_pid);
if (got != setup_pid) diee("waitpid setup [%ld] gave [%ld]!",
(long)setup_pid, (long)got);
- if (status != 0) propagate_exit_status(status);
+ if (status != 0) propagate_exit_status(status, "setup");
close(lockfd);
- return fake_pair[0];
+ return call_sock_from_fd(fake_pair[0]);
}
static void make_executor_argv(const char *const *argv) {
- #define EACH_NEW_ARGV(EACH) { \
+ switch (laundering) {
+ case 'U': break;
+ default: die("need -U (specifying unlaundered argument handling)");
+ }
+
+ const char *arg;
+ #define EACH_NEW_ARG(EACH) { \
arg = interp; { EACH } \
if ((arg = script)) { EACH } \
const char *const *walk = argv; \
}
size_t count = 1;
- MAKE_NEW_ARGV( (void)arg; count++; );
+ EACH_NEW_ARG( (void)arg; count++; );
- executor_argv = calloc(count, sizeof(char*));
+ const char **out = calloc(count, sizeof(char*));
+ executor_argv = (const char* const*)out;
if (!executor_argv) diee("allocate for arguments");
- char **out = executor_argv;
- MAKE_NEW_ARGV( *out++ = arg; );
+ EACH_NEW_ARG( *out++ = arg; );
*out++ = 0;
}
make_executor_argv(argv);
find_socket_path();
- FILLZERO(sun);
- sun.sun_family = AF_UNIX;
- assert(strlen(socket_path) <= sizeof(sun.sun_path));
- strncpy(sun.sun_path, socket_path, sizeof(sun.sun_path));
+ FILLZERO(sockaddr_sun);
+ sockaddr_sun.sun_family = AF_UNIX;
+ assert(strlen(socket_path) <= sizeof(sockaddr_sun.sun_path));
+ strncpy(sockaddr_sun.sun_path, socket_path, sizeof(sockaddr_sun.sun_path));
+
+ FILE *call_sock = connect_or_spawn();
+ uint32_t status;
+ ssize_t sr = fread(&status, sizeof(status), 1, call_sock);
+ if (sr != 1) {
+ if (was_eof(call_sock)) die("per-call server monitor process quit");
+ diee("read status from call socket");
+ }
+
+ status = ntohl(status);
+ if (status > INT_MAX) die("status 0x%lx does not fit in an int",
+ (unsigned long)status);
- int call_fd = connect_or_spawn();
+ propagate_exit_status(status, "invocation");
}
~ian / chiark-utils.git / blobdiff