2 * SPDX-License-Identifier: BSD-3-Clause
4 * Copyright (c) 1999 Berkeley Software Design, Inc. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Berkeley Software Design Inc's name may not be used to endorse or
15 * promote products derived from this software without specific prior
18 * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * From BSDI: daemon.c,v 1.2 1996/08/15 01:11:09 jch Exp
33 #include <sys/cdefs.h>
34 #include <sys/param.h>
35 #include <sys/event.h>
44 #include <login_cap.h>
59 #define LBUF_SIZE 4096
62 MODE_DAEMON = 0, /* simply daemonize, no supervision */
63 MODE_SUPERVISE, /* initial supervision state */
64 MODE_TERMINATING, /* user requested termination */
65 MODE_NOCHILD, /* child is terminated, final state of the event loop */
71 const char *child_pidfile;
72 const char *parent_pidfile;
73 const char *output_filename;
74 const char *syslog_tag;
77 struct pidfh *parent_pidfh;
78 struct pidfh *child_pidfh;
79 enum daemon_mode mode;
93 static void restrict_process(const char *);
94 static int open_log(const char *);
95 static void reopen_log(struct daemon_state *);
96 static bool listen_child(int, struct daemon_state *);
97 static int get_log_mapping(const char *, const CODE *);
98 static void open_pid_files(struct daemon_state *);
99 static void do_output(const unsigned char *, size_t, struct daemon_state *);
100 static void daemon_sleep(struct daemon_state *);
101 static void daemon_state_init(struct daemon_state *);
102 static void daemon_eventloop(struct daemon_state *);
103 static void daemon_terminate(struct daemon_state *);
104 static void daemon_exec(struct daemon_state *);
105 static bool daemon_is_child_dead(struct daemon_state *);
106 static void daemon_set_child_pipe(struct daemon_state *);
108 static const char shortopts[] = "+cfHSp:P:ru:o:s:l:t:m:R:T:h";
110 static const struct option longopts[] = {
111 { "change-dir", no_argument, NULL, 'c' },
112 { "close-fds", no_argument, NULL, 'f' },
113 { "sighup", no_argument, NULL, 'H' },
114 { "syslog", no_argument, NULL, 'S' },
115 { "output-file", required_argument, NULL, 'o' },
116 { "output-mask", required_argument, NULL, 'm' },
117 { "child-pidfile", required_argument, NULL, 'p' },
118 { "supervisor-pidfile", required_argument, NULL, 'P' },
119 { "restart", no_argument, NULL, 'r' },
120 { "restart-delay", required_argument, NULL, 'R' },
121 { "title", required_argument, NULL, 't' },
122 { "user", required_argument, NULL, 'u' },
123 { "syslog-priority", required_argument, NULL, 's' },
124 { "syslog-facility", required_argument, NULL, 'l' },
125 { "syslog-tag", required_argument, NULL, 'T' },
126 { "help", no_argument, NULL, 'h' },
130 static _Noreturn void
133 (void)fprintf(stderr,
134 "usage: daemon [-cfHrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
135 " [-u user] [-o output_file] [-t title]\n"
136 " [-l syslog_facility] [-s syslog_priority]\n"
137 " [-T syslog_tag] [-m output_mask] [-R restart_delay_secs]\n"
138 "command arguments ...\n");
140 (void)fprintf(stderr,
141 " --change-dir -c Change the current working directory to root\n"
142 " --close-fds -f Set stdin, stdout, stderr to /dev/null\n"
143 " --sighup -H Close and re-open output file on SIGHUP\n"
144 " --syslog -S Send output to syslog\n"
145 " --output-file -o <file> Append output of the child process to file\n"
146 " --output-mask -m <mask> What to send to syslog/file\n"
147 " 1=stdout, 2=stderr, 3=both\n"
148 " --child-pidfile -p <file> Write PID of the child process to file\n"
149 " --supervisor-pidfile -P <file> Write PID of the supervisor process to file\n"
150 " --restart -r Restart child if it terminates (1 sec delay)\n"
151 " --restart-delay -R <N> Restart child if it terminates after N sec\n"
152 " --title -t <title> Set the title of the supervisor process\n"
153 " --user -u <user> Drop privileges, run as given user\n"
154 " --syslog-priority -s <prio> Set syslog priority\n"
155 " --syslog-facility -l <flty> Set syslog facility\n"
156 " --syslog-tag -T <tag> Set syslog tag\n"
157 " --help -h Show this help\n");
163 main(int argc, char *argv[])
167 struct daemon_state state;
169 daemon_state_init(&state);
171 /* Signals are processed via kqueue */
172 signal(SIGHUP, SIG_IGN);
173 signal(SIGTERM, SIG_IGN);
176 * Supervision mode is enabled if one of the following options are used:
178 * --supervisor-pidfile -P
179 * --restart -r / --restart-delay -R
181 * --syslog-facility -l
182 * --syslog-priority -s
185 * In supervision mode daemon executes the command in a forked process
186 * and observes the child by waiting for SIGCHILD. In supervision mode
187 * daemon must never exit before the child, this is necessary to prevent
188 * orphaning the child and leaving a stale pid file.
189 * To achieve this daemon catches SIGTERM and
190 * forwards it to the child, expecting to get SIGCHLD eventually.
192 while ((ch = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
195 state.keep_cur_workdir = 0;
198 state.keep_fds_open = 0;
201 state.log_reopen = true;
204 state.syslog_facility = get_log_mapping(optarg,
206 if (state.syslog_facility == -1) {
207 errx(5, "unrecognized syslog facility");
209 state.syslog_enabled = true;
210 state.mode = MODE_SUPERVISE;
213 state.stdmask = strtol(optarg, &p, 10);
214 if (p == optarg || state.stdmask < 0 || state.stdmask > 3) {
215 errx(6, "unrecognized listening mask");
219 state.output_filename = optarg;
221 * TODO: setting output filename doesn't have to turn
222 * the supervision mode on. For non-supervised mode
223 * daemon could open the specified file and set it's
224 * descriptor as both stderr and stout before execve()
226 state.mode = MODE_SUPERVISE;
229 state.child_pidfile = optarg;
230 state.mode = MODE_SUPERVISE;
233 state.parent_pidfile = optarg;
234 state.mode = MODE_SUPERVISE;
237 state.restart_enabled = true;
238 state.mode = MODE_SUPERVISE;
241 state.restart_enabled = true;
242 state.restart_delay = strtol(optarg, &p, 0);
243 if (p == optarg || state.restart_delay < 1) {
244 errx(6, "invalid restart delay");
248 state.syslog_priority = get_log_mapping(optarg,
250 if (state.syslog_priority == -1) {
251 errx(4, "unrecognized syslog priority");
253 state.syslog_enabled = true;
254 state.mode = MODE_SUPERVISE;
257 state.syslog_enabled = true;
258 state.mode = MODE_SUPERVISE;
261 state.title = optarg;
264 state.syslog_tag = optarg;
265 state.syslog_enabled = true;
266 state.mode = MODE_SUPERVISE;
273 __builtin_unreachable();
287 state.title = argv[0];
290 if (state.output_filename) {
291 state.output_fd = open_log(state.output_filename);
292 if (state.output_fd == -1) {
297 if (state.syslog_enabled) {
298 openlog(state.syslog_tag, LOG_PID | LOG_NDELAY,
299 state.syslog_facility);
303 * Try to open the pidfile before calling daemon(3),
304 * to be able to report the error intelligently
306 open_pid_files(&state);
309 * TODO: add feature to avoid backgrounding
310 * i.e. --foreground, -f
312 if (daemon(state.keep_cur_workdir, state.keep_fds_open) == -1) {
314 daemon_terminate(&state);
317 if (state.mode == MODE_DAEMON) {
321 /* Write out parent pidfile if needed. */
322 pidfile_write(state.parent_pidfh);
325 state.mode = MODE_SUPERVISE;
326 daemon_eventloop(&state);
327 daemon_sleep(&state);
328 } while (state.restart_enabled);
330 daemon_terminate(&state);
334 daemon_exec(struct daemon_state *state)
336 pidfile_write(state->child_pidfh);
338 if (state->user != NULL) {
339 restrict_process(state->user);
342 /* Ignored signals remain ignored after execve, unignore them */
343 signal(SIGHUP, SIG_DFL);
344 signal(SIGTERM, SIG_DFL);
345 execvp(state->argv[0], state->argv);
346 /* execvp() failed - report error and exit this process */
347 err(1, "%s", state->argv[0]);
350 /* Main event loop: fork the child and watch for events.
351 * After SIGTERM is recieved and propagated to the child there are
352 * several options on what to do next:
354 * - read until EOF but only for a while
356 * Currently the third option is used, because otherwise there is no
357 * guarantee that read() won't block indefinitely if the child refuses
358 * to depart. To handle the second option, a different approach
359 * would be needed (procctl()?).
362 daemon_eventloop(struct daemon_state *state)
369 * Try to protect against pageout kill. Ignore the
370 * error, madvise(2) will fail only if a process does
371 * not have superuser privileges.
373 (void)madvise(NULL, 0, MADV_PROTECT);
375 if (pipe(state->pipe_fd)) {
379 kq = kqueuex(KQUEUE_CLOEXEC);
380 EV_SET(&event, state->pipe_fd[0], EVFILT_READ, EV_ADD|EV_CLEAR, 0, 0,
382 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
383 err(EXIT_FAILURE, "failed to register kevent");
386 EV_SET(&event, SIGHUP, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
387 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
388 err(EXIT_FAILURE, "failed to register kevent");
391 EV_SET(&event, SIGTERM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
392 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
393 err(EXIT_FAILURE, "failed to register kevent");
396 EV_SET(&event, SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
397 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
398 err(EXIT_FAILURE, "failed to register kevent");
400 memset(&event, 0, sizeof(struct kevent));
402 /* Spawn a child to exec the command. */
405 /* fork failed, this can only happen when supervision is enabled */
406 switch (state->pid) {
409 state->mode = MODE_NOCHILD;
411 /* fork succeeded, this is child's branch */
414 daemon_set_child_pipe(state);
419 /* case: pid > 0; fork succeeded */
420 close(state->pipe_fd[1]);
421 state->pipe_fd[1] = -1;
422 setproctitle("%s[%d]", state->title, (int)state->pid);
424 while (state->mode != MODE_NOCHILD) {
425 ret = kevent(kq, NULL, 0, &event, 1, NULL);
430 err(EXIT_FAILURE, "kevent wait");
435 if (event.flags & EV_ERROR) {
436 errx(EXIT_FAILURE, "Event error: %s",
437 strerror(event.data));
440 switch (event.filter) {
443 switch (event.ident) {
445 if (daemon_is_child_dead(state)) {
446 /* child is dead, read all until EOF */
448 state->mode = MODE_NOCHILD;
449 while (listen_child(state->pipe_fd[0],
455 if (state->mode != MODE_SUPERVISE) {
456 /* user is impatient */
457 /* TODO: warn about repeated SIGTERM? */
461 state->mode = MODE_TERMINATING;
462 state->restart_enabled = false;
463 if (state->pid > 0) {
464 kill(state->pid, SIGTERM);
467 * TODO set kevent timer to exit
468 * unconditionally after some time
472 if (state->log_reopen && state->output_fd >= 0) {
481 * detecting EOF is no longer necessary
482 * if child closes the pipe daemon will stop getting
486 if (event.data > 0) {
487 (void)listen_child(state->pipe_fd[0], state);
496 close(state->pipe_fd[0]);
497 state->pipe_fd[0] = -1;
501 daemon_sleep(struct daemon_state *state)
503 struct timespec ts = { state->restart_delay, 0 };
505 if (!state->restart_enabled) {
508 while (nanosleep(&ts, &ts) == -1) {
509 if (errno != EINTR) {
516 open_pid_files(struct daemon_state *state)
521 if (state->child_pidfile) {
522 state->child_pidfh = pidfile_open(state->child_pidfile, 0600, &fpid);
523 if (state->child_pidfh == NULL) {
524 if (errno == EEXIST) {
525 errx(3, "process already running, pid: %d",
528 err(2, "pidfile ``%s''", state->child_pidfile);
531 /* Do the same for the actual daemon process. */
532 if (state->parent_pidfile) {
533 state->parent_pidfh= pidfile_open(state->parent_pidfile, 0600, &fpid);
534 if (state->parent_pidfh == NULL) {
536 pidfile_remove(state->child_pidfh);
538 if (errno == EEXIST) {
539 errx(3, "process already running, pid: %d",
542 err(2, "ppidfile ``%s''", state->parent_pidfile);
548 get_log_mapping(const char *str, const CODE *c)
551 for (cp = c; cp->c_name; cp++)
552 if (strcmp(cp->c_name, str) == 0) {
559 restrict_process(const char *user)
561 struct passwd *pw = NULL;
565 errx(1, "unknown user: %s", user);
568 if (setusercontext(NULL, pw, pw->pw_uid, LOGIN_SETALL) != 0) {
569 errx(1, "failed to set user environment");
572 setenv("USER", pw->pw_name, 1);
573 setenv("HOME", pw->pw_dir, 1);
574 setenv("SHELL", *pw->pw_shell ? pw->pw_shell : _PATH_BSHELL, 1);
578 * We try to collect whole lines terminated by '\n'. Otherwise we collect a
579 * full buffer, and then output it.
581 * Return value of false is assumed to mean EOF or error, and true indicates to
584 * TODO: simplify signature - state contains pipefd
587 listen_child(int fd, struct daemon_state *state)
589 static unsigned char buf[LBUF_SIZE];
590 static size_t bytes_read = 0;
593 assert(state != NULL);
594 assert(bytes_read < LBUF_SIZE - 1);
596 rv = read(fd, buf + bytes_read, LBUF_SIZE - bytes_read - 1);
601 assert(bytes_read <= LBUF_SIZE - 1);
602 /* Always NUL-terminate just in case. */
603 buf[LBUF_SIZE - 1] = '\0';
605 * Chomp line by line until we run out of buffer.
606 * This does not take NUL characters into account.
608 while ((cp = memchr(buf, '\n', bytes_read)) != NULL) {
609 size_t bytes_line = cp - buf + 1;
610 assert(bytes_line <= bytes_read);
611 do_output(buf, bytes_line, state);
612 bytes_read -= bytes_line;
613 memmove(buf, cp + 1, bytes_read);
615 /* Wait until the buffer is full. */
616 if (bytes_read < LBUF_SIZE - 1) {
619 do_output(buf, bytes_read, state);
622 } else if (rv == -1) {
623 /* EINTR should trigger another read. */
624 if (errno == EINTR) {
631 /* Upon EOF, we have to flush what's left of the buffer. */
632 if (bytes_read > 0) {
633 do_output(buf, bytes_read, state);
640 * The default behavior is to stay silent if the user wants to redirect
641 * output to a file and/or syslog. If neither are provided, then we bounce
642 * everything back to parent's stdout.
645 do_output(const unsigned char *buf, size_t len, struct daemon_state *state)
647 assert(len <= LBUF_SIZE);
648 assert(state != NULL);
653 if (state->syslog_enabled) {
654 syslog(state->syslog_priority, "%.*s", (int)len, buf);
656 if (state->output_fd != -1) {
657 if (write(state->output_fd, buf, len) == -1)
660 if (state->keep_fds_open &&
661 !state->syslog_enabled &&
662 state->output_fd == -1) {
663 printf("%.*s", (int)len, buf);
668 open_log(const char *outfn)
671 return open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
675 reopen_log(struct daemon_state *state)
679 outfd = open_log(state->output_filename);
680 if (state->output_fd >= 0) {
681 close(state->output_fd);
683 state->output_fd = outfd;
687 daemon_state_init(struct daemon_state *state)
689 *state = (struct daemon_state) {
690 .pipe_fd = { -1, -1 },
692 .parent_pidfh = NULL,
694 .child_pidfile = NULL,
695 .parent_pidfile = NULL,
699 .restart_enabled = false,
701 .keep_cur_workdir = 1,
703 .stdmask = STDOUT_FILENO | STDERR_FILENO,
704 .syslog_enabled = false,
706 .syslog_priority = LOG_NOTICE,
707 .syslog_tag = "daemon",
708 .syslog_facility = LOG_DAEMON,
711 .output_filename = NULL,
715 static _Noreturn void
716 daemon_terminate(struct daemon_state *state)
718 assert(state != NULL);
720 if (state->output_fd >= 0) {
721 close(state->output_fd);
723 if (state->pipe_fd[0] >= 0) {
724 close(state->pipe_fd[0]);
727 if (state->pipe_fd[1] >= 0) {
728 close(state->pipe_fd[1]);
730 if (state->syslog_enabled) {
733 pidfile_remove(state->child_pidfh);
734 pidfile_remove(state->parent_pidfh);
737 * Note that the exit value here doesn't matter in the case of a clean
738 * exit; daemon(3) already detached us from the caller, nothing is left
739 * to care about this one.
745 * Returns true if SIGCHILD came from state->pid
746 * This function could hang if SIGCHILD was emittied for a reason other than
747 * child dying (e.g., ptrace attach).
750 daemon_is_child_dead(struct daemon_state *state)
753 int who = waitpid(-1, NULL, WNOHANG);
754 if (state->pid == who) {
757 if (who == -1 && errno != EINTR) {
765 daemon_set_child_pipe(struct daemon_state *state)
767 if (state->stdmask & STDERR_FILENO) {
768 if (dup2(state->pipe_fd[1], STDERR_FILENO) == -1) {
772 if (state->stdmask & STDOUT_FILENO) {
773 if (dup2(state->pipe_fd[1], STDOUT_FILENO) == -1) {
777 if (state->pipe_fd[1] != STDERR_FILENO &&
778 state->pipe_fd[1] != STDOUT_FILENO) {
779 close(state->pipe_fd[1]);
782 /* The child gets dup'd pipes. */
783 close(state->pipe_fd[0]);