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/param.h>
34 #include <sys/event.h>
43 #include <login_cap.h>
58 #define LBUF_SIZE 4096
61 MODE_DAEMON = 0, /* simply daemonize, no supervision */
62 MODE_SUPERVISE, /* initial supervision state */
63 MODE_TERMINATING, /* user requested termination */
64 MODE_NOCHILD, /* child is terminated, final state of the event loop */
70 const char *child_pidfile;
71 const char *parent_pidfile;
72 const char *output_filename;
73 const char *syslog_tag;
76 struct pidfh *parent_pidfh;
77 struct pidfh *child_pidfh;
78 enum daemon_mode mode;
92 static void restrict_process(const char *);
93 static int open_log(const char *);
94 static void reopen_log(struct daemon_state *);
95 static bool listen_child(int, struct daemon_state *);
96 static int get_log_mapping(const char *, const CODE *);
97 static void open_pid_files(struct daemon_state *);
98 static void do_output(const unsigned char *, size_t, struct daemon_state *);
99 static void daemon_sleep(struct daemon_state *);
100 static void daemon_state_init(struct daemon_state *);
101 static void daemon_eventloop(struct daemon_state *);
102 static void daemon_terminate(struct daemon_state *);
103 static void daemon_exec(struct daemon_state *);
104 static bool daemon_is_child_dead(struct daemon_state *);
105 static void daemon_set_child_pipe(struct daemon_state *);
107 static const char shortopts[] = "+cfHSp:P:ru:o:s:l:t:m:R:T:h";
109 static const struct option longopts[] = {
110 { "change-dir", no_argument, NULL, 'c' },
111 { "close-fds", no_argument, NULL, 'f' },
112 { "sighup", no_argument, NULL, 'H' },
113 { "syslog", no_argument, NULL, 'S' },
114 { "output-file", required_argument, NULL, 'o' },
115 { "output-mask", required_argument, NULL, 'm' },
116 { "child-pidfile", required_argument, NULL, 'p' },
117 { "supervisor-pidfile", required_argument, NULL, 'P' },
118 { "restart", no_argument, NULL, 'r' },
119 { "restart-delay", required_argument, NULL, 'R' },
120 { "title", required_argument, NULL, 't' },
121 { "user", required_argument, NULL, 'u' },
122 { "syslog-priority", required_argument, NULL, 's' },
123 { "syslog-facility", required_argument, NULL, 'l' },
124 { "syslog-tag", required_argument, NULL, 'T' },
125 { "help", no_argument, NULL, 'h' },
129 static _Noreturn void
132 (void)fprintf(stderr,
133 "usage: daemon [-cfHrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
134 " [-u user] [-o output_file] [-t title]\n"
135 " [-l syslog_facility] [-s syslog_priority]\n"
136 " [-T syslog_tag] [-m output_mask] [-R restart_delay_secs]\n"
137 "command arguments ...\n");
139 (void)fprintf(stderr,
140 " --change-dir -c Change the current working directory to root\n"
141 " --close-fds -f Set stdin, stdout, stderr to /dev/null\n"
142 " --sighup -H Close and re-open output file on SIGHUP\n"
143 " --syslog -S Send output to syslog\n"
144 " --output-file -o <file> Append output of the child process to file\n"
145 " --output-mask -m <mask> What to send to syslog/file\n"
146 " 1=stdout, 2=stderr, 3=both\n"
147 " --child-pidfile -p <file> Write PID of the child process to file\n"
148 " --supervisor-pidfile -P <file> Write PID of the supervisor process to file\n"
149 " --restart -r Restart child if it terminates (1 sec delay)\n"
150 " --restart-delay -R <N> Restart child if it terminates after N sec\n"
151 " --title -t <title> Set the title of the supervisor process\n"
152 " --user -u <user> Drop privileges, run as given user\n"
153 " --syslog-priority -s <prio> Set syslog priority\n"
154 " --syslog-facility -l <flty> Set syslog facility\n"
155 " --syslog-tag -T <tag> Set syslog tag\n"
156 " --help -h Show this help\n");
162 main(int argc, char *argv[])
166 struct daemon_state state;
168 daemon_state_init(&state);
170 /* Signals are processed via kqueue */
171 signal(SIGHUP, SIG_IGN);
172 signal(SIGTERM, SIG_IGN);
175 * Supervision mode is enabled if one of the following options are used:
177 * --supervisor-pidfile -P
178 * --restart -r / --restart-delay -R
180 * --syslog-facility -l
181 * --syslog-priority -s
184 * In supervision mode daemon executes the command in a forked process
185 * and observes the child by waiting for SIGCHILD. In supervision mode
186 * daemon must never exit before the child, this is necessary to prevent
187 * orphaning the child and leaving a stale pid file.
188 * To achieve this daemon catches SIGTERM and
189 * forwards it to the child, expecting to get SIGCHLD eventually.
191 while ((ch = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
194 state.keep_cur_workdir = 0;
197 state.keep_fds_open = 0;
200 state.log_reopen = true;
203 state.syslog_facility = get_log_mapping(optarg,
205 if (state.syslog_facility == -1) {
206 errx(5, "unrecognized syslog facility");
208 state.syslog_enabled = true;
209 state.mode = MODE_SUPERVISE;
212 state.stdmask = strtol(optarg, &p, 10);
213 if (p == optarg || state.stdmask < 0 || state.stdmask > 3) {
214 errx(6, "unrecognized listening mask");
218 state.output_filename = optarg;
220 * TODO: setting output filename doesn't have to turn
221 * the supervision mode on. For non-supervised mode
222 * daemon could open the specified file and set it's
223 * descriptor as both stderr and stout before execve()
225 state.mode = MODE_SUPERVISE;
228 state.child_pidfile = optarg;
229 state.mode = MODE_SUPERVISE;
232 state.parent_pidfile = optarg;
233 state.mode = MODE_SUPERVISE;
236 state.restart_enabled = true;
237 state.mode = MODE_SUPERVISE;
240 state.restart_enabled = true;
241 state.restart_delay = strtol(optarg, &p, 0);
242 if (p == optarg || state.restart_delay < 1) {
243 errx(6, "invalid restart delay");
247 state.syslog_priority = get_log_mapping(optarg,
249 if (state.syslog_priority == -1) {
250 errx(4, "unrecognized syslog priority");
252 state.syslog_enabled = true;
253 state.mode = MODE_SUPERVISE;
256 state.syslog_enabled = true;
257 state.mode = MODE_SUPERVISE;
260 state.title = optarg;
263 state.syslog_tag = optarg;
264 state.syslog_enabled = true;
265 state.mode = MODE_SUPERVISE;
272 __builtin_unreachable();
286 state.title = argv[0];
289 if (state.output_filename) {
290 state.output_fd = open_log(state.output_filename);
291 if (state.output_fd == -1) {
296 if (state.syslog_enabled) {
297 openlog(state.syslog_tag, LOG_PID | LOG_NDELAY,
298 state.syslog_facility);
302 * Try to open the pidfile before calling daemon(3),
303 * to be able to report the error intelligently
305 open_pid_files(&state);
308 * TODO: add feature to avoid backgrounding
309 * i.e. --foreground, -f
311 if (daemon(state.keep_cur_workdir, state.keep_fds_open) == -1) {
313 daemon_terminate(&state);
316 if (state.mode == MODE_DAEMON) {
320 /* Write out parent pidfile if needed. */
321 pidfile_write(state.parent_pidfh);
324 state.mode = MODE_SUPERVISE;
325 daemon_eventloop(&state);
326 daemon_sleep(&state);
327 } while (state.restart_enabled);
329 daemon_terminate(&state);
333 daemon_exec(struct daemon_state *state)
335 pidfile_write(state->child_pidfh);
337 if (state->user != NULL) {
338 restrict_process(state->user);
341 /* Ignored signals remain ignored after execve, unignore them */
342 signal(SIGHUP, SIG_DFL);
343 signal(SIGTERM, SIG_DFL);
344 execvp(state->argv[0], state->argv);
345 /* execvp() failed - report error and exit this process */
346 err(1, "%s", state->argv[0]);
349 /* Main event loop: fork the child and watch for events.
350 * After SIGTERM is recieved and propagated to the child there are
351 * several options on what to do next:
353 * - read until EOF but only for a while
355 * Currently the third option is used, because otherwise there is no
356 * guarantee that read() won't block indefinitely if the child refuses
357 * to depart. To handle the second option, a different approach
358 * would be needed (procctl()?).
361 daemon_eventloop(struct daemon_state *state)
368 * Try to protect against pageout kill. Ignore the
369 * error, madvise(2) will fail only if a process does
370 * not have superuser privileges.
372 (void)madvise(NULL, 0, MADV_PROTECT);
374 if (pipe(state->pipe_fd)) {
378 kq = kqueuex(KQUEUE_CLOEXEC);
379 EV_SET(&event, state->pipe_fd[0], EVFILT_READ, EV_ADD|EV_CLEAR, 0, 0,
381 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
382 err(EXIT_FAILURE, "failed to register kevent");
385 EV_SET(&event, SIGHUP, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
386 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
387 err(EXIT_FAILURE, "failed to register kevent");
390 EV_SET(&event, SIGTERM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
391 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
392 err(EXIT_FAILURE, "failed to register kevent");
395 EV_SET(&event, SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
396 if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
397 err(EXIT_FAILURE, "failed to register kevent");
399 memset(&event, 0, sizeof(struct kevent));
401 /* Spawn a child to exec the command. */
404 /* fork failed, this can only happen when supervision is enabled */
405 switch (state->pid) {
408 state->mode = MODE_NOCHILD;
410 /* fork succeeded, this is child's branch */
413 daemon_set_child_pipe(state);
418 /* case: pid > 0; fork succeeded */
419 close(state->pipe_fd[1]);
420 state->pipe_fd[1] = -1;
421 setproctitle("%s[%d]", state->title, (int)state->pid);
422 setbuf(stdout, NULL);
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]);