/* Copyright (c) 2014-2018, Michael Santos * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "alcove.h" #include static int alcove_signal_init(); static int alcove_rlimit_init(); static int alcove_fd_init(char *fifo); static int alcove_fdmove(int fd, int dst); static void usage(void); extern char *__progname; int main(int argc, char *argv[]) { alcove_state_t *ap = NULL; int ch = 0; char *fifo = NULL; int boot = 1; struct rlimit maxfd = {0}; #ifndef HAVE_SETPROCTITLE spt_init(argc, argv); #endif ap = calloc(1, sizeof(alcove_state_t)); if (ap == NULL) exit(ENOMEM); ALCOVE_SETOPT(ap, alcove_opt_termsig, 1); ALCOVE_SETOPT(ap, alcove_opt_exit_status, 1); if (getrlimit(RLIMIT_NOFILE, &maxfd) < 0) exit(errno); ap->maxfd = maxfd.rlim_cur; ap->fdsetsize = ALCOVE_MAXCHILD(ap->maxfd); ap->maxforkdepth = MAXFORKDEPTH; ap->signaloneof = SIGTERM; while ( (ch = getopt(argc, argv, "c:d:h")) != -1) { switch (ch) { case 'c': if (fifo) free(fifo); fifo = strdup(optarg); if (fifo == NULL) exit(ENOMEM); break; case 'd': boot = 0; ap->depth = (u_int16_t)atoi(optarg); if (ap->depth > UINT8_MAX) exit(EAGAIN); break; case 'h': default: usage(); } } ap->child = calloc(ap->fdsetsize, sizeof(alcove_child_t)); if (ap->child == NULL) exit(ENOMEM); if (boot) { if (alcove_signal_init() < 0) exit(errno); if (alcove_rlimit_init() < 0) exit(errno); if (alcove_fd_init(fifo) < 0) exit(errno); } free(fifo); alcove_event_init(ap); exit(0); } static int alcove_signal_init() { struct sigaction act = {0}; int sig = 0; act.sa_handler = SIG_DFL; (void)sigfillset(&act.sa_mask); for (sig = 1; sig < NSIG; sig++) { if (sigaction(sig, &act, NULL) < 0) { if (errno == EINVAL) continue; return -1; } } act.sa_flags |= SA_SIGINFO; act.sa_sigaction = alcove_sig_info; if (sigaction(SIGCHLD, &act, NULL) < 0) return -1; return 0; } static int alcove_rlimit_init() { struct rlimit stack_size = {0}; if (getrlimit(RLIMIT_STACK, &stack_size) < 0) return -1; /* Reset an unlimited stack size to a default value. The default is * set to 8Mb, the default for linux (_STK_LIM in linux/resources.h). * * The current value of RLIMIT_STACK is used for allocating the * stack of cloned processes. * */ if (stack_size.rlim_cur == RLIM_INFINITY) { stack_size.rlim_cur = 8 * 1024 * 1024; if (setrlimit(RLIMIT_STACK, &stack_size) < 0) return -1; } return 0; } static int alcove_fd_init(char *fifo) { int sigpipe[2] = {0}; int fdctl = 0; if (!fifo) return -1; /* The fd may have been opened by another program. For example, * valgrind will use the first available fd for the log file. */ if (alcove_fdmove(ALCOVE_SIGREAD_FILENO, 8) < 0) return -1; if (alcove_fdmove(ALCOVE_SIGWRITE_FILENO, 8) < 0) return -1; if (alcove_fdmove(ALCOVE_FDCTL_FILENO, 8) < 0) return -1; if (pipe(sigpipe) < 0) return -1; /* XXX fd's will overlap */ if (sigpipe[0] != ALCOVE_SIGREAD_FILENO) { if (dup2(sigpipe[0], ALCOVE_SIGREAD_FILENO) < 0) return -1; if (close(sigpipe[0]) < 0) return -1; } if (sigpipe[1] != ALCOVE_SIGWRITE_FILENO) { if (dup2(sigpipe[1], ALCOVE_SIGWRITE_FILENO) < 0) return -1; if (close(sigpipe[1]) < 0) return -1; } if ( (alcove_setfd(ALCOVE_SIGREAD_FILENO, FD_CLOEXEC|O_NONBLOCK) < 0) || (alcove_setfd(ALCOVE_SIGWRITE_FILENO, FD_CLOEXEC|O_NONBLOCK) < 0)) return -1; /* The control fd used to signal that the port has called exec(). The * control fd is a fifo. beam opens the fd in read-only mode. When all * the writers of a fifo call close(), the reader receives EOF. * * If the fifo is opened O_WRONLY, the port will deadlock: the open * call in the port will block for a reader and the erlang side will * be blocked waiting for the port. * * Some OS'es (e.g., Linux, see fifo(7)) allow a fifo to be opened * in non-blocking mode but the behaviour is unspecified. In practice: * * - opening the fifo read-only returns immediately * * - opening the fifo write-only fifo returns ENXIO * * - opening the fifo read-write with or without O_NONBLOCK will * return immediately but the control fd cannot be used for sending * data because each of the readers will race to receive any writes * */ if (mkfifo(fifo, S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH) < 0) return -1; fdctl = open(fifo, O_RDWR|O_CLOEXEC|O_NONBLOCK); if (fdctl < 0) return -1; if (fdctl != ALCOVE_FDCTL_FILENO) { if (dup2(fdctl, ALCOVE_FDCTL_FILENO) < 0) return -1; if (close(fdctl) < 0) return -1; } return 0; } static int alcove_fdmove(int fd, int dst) { int flags = 0; flags = fcntl(fd, F_GETFD); if (flags < 0) return 0; if (fcntl(fd, F_DUPFD, dst) < 0) return -1; /* According to fcntl(2) on FreeBSD, the close-on-exec flag is reset * by F_DUPFD: * * The close-on-exec flag FD_CLOEXEC associated * with the new file descriptor is cleared, so the * file descriptor is to remain open across * execve(2) system calls. * * Restore the flag if it was set: * */ return fcntl(dst, F_SETFD, flags); } static void usage() { (void)fprintf(stderr, "%s %s\n", __progname, ALCOVE_VERSION); (void)fprintf(stderr, "usage: %s -c []\n", __progname ); exit (ENOTSUP); }