cprogs/prefork-interp.c

   1 /*
   2  * "Interpreter" that you can put in #! like this
   3  *   #!/usr/bin/prefork-interp [<options>] <interpreter>
   4  *
   5  * Usages:
   6  *   prefork-interp  [<option> ..] <interpreter>  [<script> [<args> ...]]
   7  *   prefork-interp  [<option>,..],<interpreter>   <script> [<args> ...]
   8  *   prefork-interp '[<option> ..] <interpreter>'  <script> [<args> ...]
   9  */
  10 /*
  11  * Process structure:
  12  *  client (C wrapper)        connects to server
  13  *                              (including reading ack byte)
  14  *                            if fails or garbage
  15  *                            === acquire lock ===
  16  *                               makes new listening socket
  17  *                               makes first-instance socketpair
  18  *                            forks setup (script, sock fds indicated in env)
  19  *                            fd0, fd1, fd2: from-outer-caller
  20  *                            other fd: call(client-end)(fake)
  21  *                            reaps setup (and reports error)
  22  *                            (implicitly releases lock)
  23  *
  24  *     setup (pre-exec)       fd0: null,
  25  *                            fd[12: fd2-from-outer-caller
  26  *                            env fds: listener, call(server-end)(fake)
  27  *                            env fds: orig-fd[01]
  28  *                            close fd: lockfile
  29  *
  30  *     setup (script)         runs initialisation parts of the script
  31  *                            at prefork establishment point:
  32  *     setup (pm) [1]         opens syslog
  33  *                            forks for server
  34  *                [2]         exits
  35  *
  36  #        server (pm) [1]     [fd0: null],
  37  *                            [fd[12: fd2-from-outer-caller]
  38  *                            right away, forks one fa-monitor
  39  *                    [2]     closes outer caller fds and call(fake)
  40  *        [server (pm)]       fd[012]: null
  41  *                            other fds: listener, syslog
  42  *                            runs in loop accepting and forking,
  43  *                            reaping and limiting children (incl fa-monitor)
  44  *                            reports failures of monitors to syslog
  45  *
  46  *         f-a monitor        forks executor
  47  *                            closes fd: listener
  48  *                            [fd[12: fd2-from-outer-caller]
  49  *                            [other fds: call(server-end)(fake), syslog]
  50  *                            runs as monitor, below
  51  *
  52  *
  53  *  [client (C wrapper)]      if client connect succeeds:
  54  *                            now fd: call(client-end)
  55  *                               sends message with: cmdline, env
  56  *                               sends fds
  57  *
  58  *        [server (script)]   accepts, forks monitor
  59  *
  60  *          monitor [1]       [fd[012]: null]
  61  *                            other fds: syslog, call(server-end)
  62  *                            sends ack byte
  63  *                            receives args, env, fds
  64  *                            forks executor
  65  *
  66  *            executor        sorts out fds:
  67  *                            fd0, fd1, fd2: from-outer-caller
  68  *                            close fds: call(server-end)
  69  *                            retained fds: syslog
  70  *
  71  *                            sets cmdline, env
  72  *                            runs main part of script
  73  *                            exits normally
  74  *
  75  *          [monitor]         [fd[012]: null]
  76  *                            [other fds: call(server-end), syslog]
  77  *                            reaps executor
  78  *                            reports status via socket
  79  *
  80  *    [client (C wrapper)]    [fd0, fd1, fd2: from-outer-caller]
  81  *                            [other fd: call(client-end)]
  82  *                            receives status, exits appropriately
  83  *                            (if was bad signal, reports to stderr, exits 127)
  84  */
  85
  86 #include <arpa/inet.h>
  87
  88 #include "prefork.h"
  89
  90 struct sockaddr_un sun;
  91
  92 #define ACK_BYTE '\n'
  93
  94 static struct sockaddr_unix socket_sun;
  95 static const char *const *executor_argv;
  96
  97 static void propagate_exit_status(int status, const char *what) {
  98   int r;
  99
 100   if (WIFEXITED(status)) {
 101     _exit(status);
 102   }
 103
 104   if (WIFSIGNALED(status)) {
 105     int sig = WTERMSIG(status);
 106     const char *signame = strsignal(sig);
 107     if (signame == 0) signame = "unknown signal";
 108
 109     if (! WCOREDUMP(status) &&
 110         (sig == SIGINT ||
 111          sig == SIGHUP ||
 112          sig == SIGPIPE ||
 113          sig == SIGKILL)) {
 114       struct sigaction sa;
 115       FILLZERO(sa);
 116       sa.sa_handler = SIG_DFL;
 117       r = sigaction(sig, &sa, 0);
 118       if (r) diee("failed to reset signal handler while propagating %s",
 119                   signame);
 120
 121       sigset_t sset;
 122       sigemptyset(&sset);
 123       sigaddset(&sset, sig);
 124       r = sigprocmask(SIG_UNBLOCK, &sset, 0);
 125       if (r) diee("failed to reset signal block while propagating %s",
 126                   signame);
 127
 128       raise(sig);
 129       die("unexpectedly kept running after raising (to propagate) %s",
 130           signame);
 131     }
 132
 133     die("setup failed due to signal %d %s%s", sig, signame,
 134         WCOREDUMP(status) ? " (core dumped)" : "");
 135   }
 136
 137   die("setup failed with weird wait status %d 0x%x", status, status);
 138 }
 139
 140 static __attribute((noreturn)) void die_data_overflow(void) {
 141   die("cannot handle data with length >2^32");
 142 }
 143
 144 static void prepare_data(size_t *len, char **buf,
 145                          const void *data, size_t dl) {
 146   if (len) {
 147     if (dl >= SIZE_MAX - *len)
 148       die_data_overflow();
 149     *len += dl;
 150   }
 151   if (buf) {
 152     memcpy(*buf, data, dl);
 153     *buf += dl;
 154   }
 155 }
 156
 157 static void prepare_length(size_t *len, char **buf, size_t dl_sz) {
 158   if (dl_sz > UINT32_MAX) die_data_overflow();
 159   uint32_t dl = htonl(dl_sz);
 160   prepare_data(len, buf, &dl, sizeof(dl));
 161 }
 162
 163 static void prepare_string(size_t *len, char **buf, const char *s) {
 164   size_t sl = strlen(s);
 165   prepare_data(len, buf, s, sl+1);
 166 }
 167
 168 static void prepare_message(size_t *len, char **buf) {
 169   const char *s;
 170
 171   const char *const *p = (void*)environ;
 172   while ((s = *p++)) {
 173     if (strchr(s, '='))
 174       prepare_string(len, buf, s);
 175   }
 176
 177   prepare_string(len, buf, "");
 178
 179   p = executor_argv;
 180   while ((s = *p++))
 181     prepare_string(len, buf, s);
 182 }
 183
 184 static void send_fd(int via_fd, int payload_fd) {
 185   union {
 186     struct cmsghdr align;
 187     char buf[CMSG_SPACE(sizeof(payload_fd))];
 188   } cmsg_buf;
 189
 190   struct msghdr msg;
 191   FILLZERO(msg);
 192   FILLZERO(cmsg_buf);
 193
 194   char dummy_byte = 0;
 195   struct iovec iov;
 196   FILLZERO(iov);
 197   iov.iov_base = &dummy_byte;
 198   iov.iov_len = 1;
 199
 200   msg.msg_name = 0;
 201   msg.msg_iov = &iov;
 202   msg.msg_iovlen = 1;
 203   msg.msg_control = cmsg_buf.buf;
 204   msg.msg_controllen = sizeof(cmsg_buf.buf);
 205
 206   struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
 207   cmsg->cmsg_level = SOL_SOCKET;
 208   cmsg->cmsg_type = SCM_RIGHTS;
 209   cmsg->cmsg_len = CMSG_LEN(sizeof(payload_fd));
 210   *(int*)CMSG_DATA(cmsg) = payload_fd;
 211
 212   msg.msg_controllen = sizeof(cmsg_buf.buf);
 213
 214   for (;;) {
 215     ssize_t r = sendmsg(via_fd, &msg, 0);
 216     if (r == -1) {
 217       if (errno == EINTR) continue;
 218       diee("send fd");
 219     }
 220     assert(r == 1);
 221     break;
 222   }
 223 }
 224
 225 static void send_request(int call_fd) {
 226   // Sending these first makes it easier for the script to
 227   // use buffered IO for the message.
 228   send_fd(call_fd, 0);
 229   send_fd(call_fd, 1);
 230   send_fd(call_fd, 2);
 231
 232   size_t len = 4;
 233   prepare_message(&len, 0);
 234   char *m = malloc(len);
 235   if (!m) diee("failed to allocate for message");
 236   char *p = m;
 237   prepare_length(0, &p, len - 4);
 238   prepare_message(0, &p);
 239   assert(p == m + len);
 240
 241   p = m;
 242   while (len) {
 243     ssize_t r = write(call_fd, p, len);
 244     if (r==-1) {
 245       if (errno == EINTR) continue;
 246       diee("write request");
 247     }
 248     assert(r <= len);
 249     assert(r > 0);
 250     len -= r;
 251     p += r;
 252   }
 253 }
 254
 255 // Returns: call(client-end) fd, or -1 to mean "is garbage"
 256 // find_socket_path must have been called
 257 static int connect_existing(void) {
 258   int r;
 259   int fd = -1;
 260
 261   fd = socket(AF_UNIX, SOCK_STREAM, 0);
 262   if (fd==-1) diee("socket() for client");
 263
 264   socklen_t salen = sizeof(sun);
 265   r = connect(client, (const struct sockaddr*)&socket_sun, salen);
 266   if (r==-1) {
 267     if (errno==ECONNREFUSED || errno==ENOENT) goto x_garbgae;
 268     diee("connect() %s", socket_path);
 269   }
 270
 271   for (;;) {
 272     char ack;
 273     sr = read(fd, &ack, 1);
 274     if (sr == -1) {
 275       if (errno==ECONNRESET) goto x_garbage;
 276       if (errno==EINTR) continue;
 277       diee("read() ack byte");
 278     }
 279     if (sr == 0) { goto x_garbage; }
 280     if (ack != '\n') die("got ack byte 0x%02x, not '\n'", ack);
 281     break;
 282   }
 283
 284   // We're committed now, send the request (or bail out)
 285   send_request(call, argv);
 286
 287   return fd;
 288
 289  x_garbage:
 290   if (fd >= 0) close(fd);
 291   return -1;
 292 }
 293
 294 static void become_setup(int sfd, int fake_pair[2])
 295   __attribute__((noreturn))
 296 {
 297   close(fake_pair[0]);
 298   int call_fd = fake_pair[1];
 299
 300   int fd0_save = dup(0);  if (fd0_save < 0) diee("dup stdin");
 301   int fd1_save = dup(1);  if (fd1_save < 0) diee("dup stdin");
 302
 303   int null_0 = open("/dev/null", O_RDONLY);  if (null_0 < 0) diee("open null");
 304   if (dup2(null_0, 0)) diee("dup2 /dev/null onto stdin");
 305   if (dup2(2, 1) != 1) die("dup2 stderr onto stdout");
 306
 307   putenv(asprintf("PREFORK_INTERP=%d,%d,%d,%d,%s",
 308                   sfd, call_fd, fd0_save, fd1_save, socket_path));
 309
 310   execvp(executor_argv[0], executor_argv);
 311   diee("execute %s", executor_argv[0]);
 312 }
 313
 314 static int connect_or_spawn(void) {
 315   int fd = connect_existing();
 316   if (fd >= 0) return fd;
 317
 318   int lockfd = acquire_lock();
 319   fd = connect_existing();
 320   if (fd >= 0) { close(lockfd); return fd; }
 321
 322   // We must start a fresh one, and we hold the lock
 323
 324   r = unlink(socketpath);
 325   if (r<0) diee("failed to remove stale socket %s", socketpath);
 326
 327   int fake_pair[2];
 328   r = socketpair(AF_UNIX, SOCK_STREAM, 0, fake_pair);
 329   if (r<0) diee("socketpair() for fake initial connection");
 330
 331   int sfd = socket(AF_UNIX, SOCK_STREAM, 0);
 332   if (sfd<0) diee("socket() for new listener");
 333
 334   salen_t salen = sizeof(sun);
 335   r= bind(sfd, (const struct sockaddr*)&socket_sun, saledn);
 336   if (r<0) diee("bind() on new listener");
 337
 338   // We never want callers to get ECONNREFUSED!.
 339   // There is a race here: from my RTFM they may get ECONNREFUSED
 340   // if they tr between our bind() and listen().  But if they do, they'll
 341   // acquire the lock (serialising with us) and retry, and then it will work.
 342   r = listen(sfd, INT_MAX);
 343   if (r<0) diee("listen() for new listener");
 344
 345   pid_t setup_pid = fork();
 346   if (setup_pid == (pid_t)-1) diee("fork for spawn setup");
 347   if (!setup_pid) become_setup(sfd, fake_pair);
 348   close(fake_pair[1]);
 349   close(sfd);
 350
 351   int status;
 352   pid_t got = waitpid(setup_pid, &status, 0);
 353   if (got == (pid_t)-1) diee("waitpid setup [%ld]", (long)setup_pid);
 354   if (got != setup_pid) diee("waitpid setup [%ld] gave [%ld]!",
 355                              (long)setup_pid, (long)got);
 356   if (status != 0) propagate_exit_status(status);
 357
 358   close(lockfd);
 359   return fake_pair[0];
 360 }
 361
 362 static void make_executor_argv(const char *const *argv) {
 363   #define EACH_NEW_ARGV(EACH) {                 \
 364     arg = interp; { EACH }                      \
 365     if ((arg = script)) { EACH }                \
 366     const char *const *walk = argv;             \
 367     while ((arg = *walk++)) { EACH }            \
 368   }
 369
 370   size_t count = 1;
 371   MAKE_NEW_ARGV( (void)arg; count++; );
 372
 373   executor_argv = calloc(count, sizeof(char*));
 374   if (!executor_argv) diee("allocate for arguments");
 375
 376   char **out = executor_argv;
 377   MAKE_NEW_ARGV( *out++ = arg; );
 378   *out++ = 0;
 379 }
 380
 381 int main(int argc_unused, const char *const *argv) {
 382   process_opts(&argv);
 383
 384   // Now we have
 385   //  - possibly interp
 386   //  - possibly script
 387   //  - remaining args
 388   // which ought to be passed on to the actual executor.
 389   make_executor_argv(argv);
 390
 391   find_socket_path();
 392   FILLZERO(sun);
 393   sun.sun_family = AF_UNIX;
 394   assert(strlen(socket_path) <= sizeof(sun.sun_path));
 395   strncpy(sun.sun_path, socket_path, sizeof(sun.sun_path));
 396
 397   int call_fd = connect_or_spawn();
 398 }