diff options
Diffstat (limited to 'src/exec.c')
| -rw-r--r-- | src/exec.c | 271 |
1 files changed, 271 insertions, 0 deletions
diff --git a/src/exec.c b/src/exec.c new file mode 100644 index 0000000..d9d8e49 --- /dev/null +++ b/src/exec.c @@ -0,0 +1,271 @@ +#include "exec.h" +#include "main.h" + +#define CHILD_BUF_SIZE 1024 + +struct process_info { + pid_t pid; + int killed; + int child_pipe; + process_exit_cb_t *cb; + void *user; + struct process_info *next; + + char *read_buf; + size_t read_buf_size; +}; + +static struct process_info *procs = NULL; + +static struct process_info *find_process(pid_t pid) { + struct process_info *p = procs; + + while (p) { + if (p->pid == pid) + return p; + + p = p->next; + } + + return NULL; +} + +static void *oop_read_cb(oop_source *source, int fd, oop_event event, void *user); + +static void close_child_pipe(struct process_info *p) { + assert(p); + + if (p->read_buf_len && p->read_buf) { + *(p->read_buf + p->read_buf_len) = 0; + daemon_log(LOG_INFO, "child(%lu): %s", (unsigned long) p->pid, p->read_buf); + p->read_buf_len = 0; + } + + if (p->child_pipe >= 0) { + assert(event_source && event_source->cancel_fd); + event_source->cancel_fd(event_source, p->child_pipe, OOP_READ, oop_read_cb, p); + close(p->child_pipe); + p->child_pipe = -1; + } +} + + +static void free_process_info(struct process_info *p) { + assert (p); + close_child_pipe(p); + + if (p->read_buf) + free(p->read_buf); + free(p); +} + +static void remove_process(pid_t pid) { + struct process_info *p; + + if (!procs) + return; + + if (procs->pid == pid) { + p = procs; + procs = procs->next; + free(p); + return; + } + + p = procs; + while (p->next) { + if (p->next->pid == pid) { + struct process_info *r; + r = p->next; + p->next = p->next->next; + free_process_info(r); + } + p = p->next; + } + + return; +} + +static void *oop_sigchld_cb(oop_source *source, int sig, void *user) { + pid_t pid; + int status; + struct process_info *p; + assert(source && sig == SIGCHLD); + + if ((pid = wait(&status)) <= 0) { + daemon_log(LOG_ERR, "wait() failed: %s", strerror(errno)); + return OOP_HALT; + } + + if (!(p = find_process_by_pid(pid))) { + daemon_log(LOG_WARN, "Got SIGCHLD for unknown process, reaping"); + return OOP_CONTINUE; + } + + assert(p && p->cb); + + if (!p->killed) + p->cb(pid, status, p->user); + + remove_process(pid); + + return OOP_CONTINUE; +} + + +static void *oop_read_cb(oop_source *source, int fd, oop_event event, void *user) { + struct process_info *p; + ssize_t s; + char *c, *b, *start; + size_t i; + assert(source && event == OOP_READ); + + p = (struct process_info*) user; + assert(p && p->child_pipe == fd && fd >= 0); + + if (!p->read_buf) { + p->read_buf = malloc(CHILD_BUF_SIZE); + p->read_buf_len = 0; + } + + assert(p->read_buf); + + start = p->read_buf+p->read_buf_len; + if ((s = read(p->child_pipe, start, CHILD_BUF_SIZE-p->read_buf_len-1)) < 0) { + daemon_log(LOG_ERR, "Failed to read from child pipe: %s", strerror(errno)); + return OOP_HALT; + } + + if (s == 0) { /* EOF */ + close_child_pipe(p); + return OOP_CONTINUE; + } + + /* Escape */ + for (c = start, i = 0; i < s; i++, c++) + if (*c < 32 || *c == 127) + *c = '.'; + + + p->read_buf_len += s; + + for (c = b = p->read_buf, i = 0; i < p->read_buf_len; i++, c++) { + if (*c == '\r' || *c == '\n') { + if (c > b) { + *c = 0; + daemon_log(LOG_INFO, "child: %s", b); + } + b = c+1; + } + } + + if (b != p->read_buf) + memcpy(p->read_buf, b, p->read_buf_len = c-b); + + return OOP_CONTINUE; +} + + +pid_t child_process_create(const char *file, char *const argv[], process_exit_cb_t cb, void*user) { + pid_t pid; + int fds[2]; + + if (pipe(fds) < 0) { + daemon_log(LOG_ERR, "pipe() failed: %s", strerror(errno)); + return -1; + } + + if ((pid = fork()) < 0) { + daemon_log(LOG_ERR, "fork() failed: %s", strerror(errno)); + close(fds[0]); + close(fds[1]); + return -1; + } + + if (pid) { + /* parent */ + + struct process_info *p = malloc(sizeof(struct process_info)); + assert(p); + memset(p, 0, sizeof(struct process_info)); + + p->pid = pid; + p->cb = cb; + p->user = user; + p->next = procs; + p->killed = 0; + + p->client_pipe = fds[0]; + close(fds[1]); + + assert(event_source && event_source->on_fd); + event_source->on_fd(event_source, p->client_pipe, oop_read_cb, p); + + procs = p; + + return pid; + + } else { + /* child */ + + int fd; + + close(fds[0]); + for (fd = 0; fd <= 2; fd++) { + if (fd != fds[1]) + close(fd); + } + + if ((fds[1] != 1 && dup2(fds[1], 1) < 0) || + (fds[1] != 2 && dup2(fds[1], 2) < 0)) { + daemon_log(LOG_ERR, "dup2() failed: %s", strerror(errno)); + exit(1); + } + + if (fds[1] != 1 && fds[1] != 2) + close(fds[1]); + + if (open("/dev/null", O_RDONLY) != 0) { + daemon_log(LOG_ERR, "open(\"/dev/null\") failed: %s", strerror(errno)); + exit(1); + } + + execv(file, argv); + daemon_log(LOG_ERR, "exec() failed: %s", strerror(errno)); + exit(1); + } +} + + + +int child_process_init(void) { + assert(!procs); + assert(event_source && event_source->on_signal); + event_source->on_signal(event_source, SIGCHLD, oop_sigchld_cb, NULL); + return 0; +} + +void child_process_done(void) { + assert(event_source && event_source->cancel_signal); + event_source->cancel_signal(event_source, SIGCHLD, oop_sigchld_cb, NULL); + + while (procs) { + struct process_info *p = procs; + procs = procs->next; + free_process_info(p); + } +} + + +int child_process_kill(pid_t pid) { + struct process_info *p = find_process(pid); + assert (p); + + if (kill(p->pid, SIGTERM) < 0 && errno != ESRCH) { + daemon_log(LOG_ERR, "Failed to kill() process: %s", strerror(errno)); + return -1; + } + + p->killed = 1; + return 0; +} |