* 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)
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;
return feof(call_sock) || errno==ECONNRESET;
}
+// Does protocol exchange. Returns 0 if OK, error msg if peer was garbage.
+static const char *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 "initial monitor process quit";
+ 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), or 0 to mean "is garbage"
// find_socket_path must have been called
static FILE *connect_existing(void) {
call_sock = call_sock_from_fd(fd);
fd = -1;
- char ack;
- size_t sr = fread(&ack, sizeof(ack), 1, call_sock);
- if (sr != 1) {
- if (was_eof(call_sock)) goto x_garbage;
- 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);
+ if (protocol_exchange(call_sock))
+ goto x_garbage;
return call_sock;
close(fake_pair[0]);
int call_fd = fake_pair[1];
- int fd0_save = dup(0); if (fd0_save < 0) diee("dup stdin");
- int fd1_save = dup(1); if (fd1_save < 0) diee("dup stdin");
-
int null_0 = open("/dev/null", O_RDONLY); if (null_0 < 0) diee("open null");
if (dup2(null_0, 0)) diee("dup2 /dev/null onto stdin");
if (dup2(2, 1) != 1) die("dup2 stderr onto stdout");
- putenv(m_asprintf("PREFORK_INTERP=%d,%d,%d,%d,%s",
- sfd, call_fd, fd0_save, fd1_save, socket_path));
+ putenv(m_asprintf("PREFORK_INTERP=%d,%d,%s",
+ sfd, call_fd, socket_path));
execvp(executor_argv[0], (char**)executor_argv);
diee("execute %s", executor_argv[0]);
close(fake_pair[1]);
close(sfd);
+ call_sock = call_sock_from_fd(fake_pair[0]);
+ const char *emsg = protocol_exchange(call_sock);
+ if (emsg) die("setup failed: %s", emsg);
+
int status;
pid_t got = waitpid(setup_pid, &status, 0);
if (got == (pid_t)-1) diee("waitpid setup [%ld]", (long)setup_pid);
if (status != 0) propagate_exit_status(status, "setup");
close(lockfd);
- return call_sock_from_fd(fake_pair[0]);
+ return call_sock;
}
static void make_executor_argv(const char *const *argv) {
+ switch (laundering) {
+ case 'U': break;
+ default: die("need -U (specifying unlaundered argument handling)");
+ }
+
const char *arg;
#define EACH_NEW_ARG(EACH) { \
arg = interp; { EACH } \
~ian / chiark-utils.git / blobdiff