1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1999 Berkeley Software Design, Inc. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
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
16 *    written permission.
17 *
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
28 * SUCH DAMAGE.
29 *
30 *	From BSDI: daemon.c,v 1.2 1996/08/15 01:11:09 jch Exp
31 */
32
33#include <sys/event.h>
34#include <sys/mman.h>
35#include <sys/wait.h>
36
37#include <fcntl.h>
38#include <err.h>
39#include <errno.h>
40#include <getopt.h>
41#include <libutil.h>
42#include <login_cap.h>
43#include <paths.h>
44#include <pwd.h>
45#include <signal.h>
46#include <stdio.h>
47#include <stdbool.h>
48#include <stdlib.h>
49#include <unistd.h>
50#include <string.h>
51#define SYSLOG_NAMES
52#include <syslog.h>
53#include <time.h>
54#include <assert.h>
55
56/* 1 year in seconds */
57#define MAX_RESTART_DELAY 60*60*24*365
58
59/* Maximum number of restarts */
60#define MAX_RESTART_COUNT 128
61
62#define LBUF_SIZE 4096
63
64enum daemon_mode {
65	MODE_DAEMON = 0,   /* simply daemonize, no supervision */
66	MODE_SUPERVISE,    /* initial supervision state */
67	MODE_TERMINATING,  /* user requested termination */
68	MODE_NOCHILD,      /* child is terminated, final state of the event loop */
69};
70
71
72struct daemon_state {
73	unsigned char buf[LBUF_SIZE];
74	size_t pos;
75	char **argv;
76	const char *child_pidfile;
77	const char *parent_pidfile;
78	const char *output_filename;
79	const char *syslog_tag;
80	const char *title;
81	const char *user;
82	struct pidfh *parent_pidfh;
83	struct pidfh *child_pidfh;
84	enum daemon_mode mode;
85	int pid;
86	int pipe_rd;
87	int pipe_wr;
88	int keep_cur_workdir;
89	int restart_delay;
90	int stdmask;
91	int syslog_priority;
92	int syslog_facility;
93	int keep_fds_open;
94	int output_fd;
95	bool restart_enabled;
96	bool syslog_enabled;
97	bool log_reopen;
98	int restart_count;
99	int restarted_count;
100};
101
102static void restrict_process(const char *);
103static int  open_log(const char *);
104static void reopen_log(struct daemon_state *);
105static bool listen_child(struct daemon_state *);
106static int  get_log_mapping(const char *, const CODE *);
107static void open_pid_files(struct daemon_state *);
108static void do_output(const unsigned char *, size_t, struct daemon_state *);
109static void daemon_sleep(struct daemon_state *);
110static void daemon_state_init(struct daemon_state *);
111static void daemon_eventloop(struct daemon_state *);
112static void daemon_terminate(struct daemon_state *);
113static void daemon_exec(struct daemon_state *);
114static bool daemon_is_child_dead(struct daemon_state *);
115static void daemon_set_child_pipe(struct daemon_state *);
116
117static const char shortopts[] = "+cfHSp:P:ru:o:s:l:t:m:R:T:C:h";
118
119static const struct option longopts[] = {
120	{ "change-dir",         no_argument,            NULL,           'c' },
121	{ "close-fds",          no_argument,            NULL,           'f' },
122	{ "sighup",             no_argument,            NULL,           'H' },
123	{ "syslog",             no_argument,            NULL,           'S' },
124	{ "output-file",        required_argument,      NULL,           'o' },
125	{ "output-mask",        required_argument,      NULL,           'm' },
126	{ "child-pidfile",      required_argument,      NULL,           'p' },
127	{ "supervisor-pidfile", required_argument,      NULL,           'P' },
128	{ "restart",            no_argument,            NULL,           'r' },
129	{ "restart-count",      required_argument,      NULL,           'C' },
130	{ "restart-delay",      required_argument,      NULL,           'R' },
131	{ "title",              required_argument,      NULL,           't' },
132	{ "user",               required_argument,      NULL,           'u' },
133	{ "syslog-priority",    required_argument,      NULL,           's' },
134	{ "syslog-facility",    required_argument,      NULL,           'l' },
135	{ "syslog-tag",         required_argument,      NULL,           'T' },
136	{ "help",               no_argument,            NULL,           'h' },
137	{ NULL,                 0,                      NULL,            0  }
138};
139
140static _Noreturn void
141usage(int exitcode)
142{
143	(void)fprintf(stderr,
144	    "usage: daemon [-cfHrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
145	    "              [-u user] [-o output_file] [-t title]\n"
146	    "              [-l syslog_facility] [-s syslog_priority]\n"
147	    "              [-T syslog_tag] [-m output_mask] [-R restart_delay_secs]\n"
148	    "              [-C restart_count]\n"
149	    "command arguments ...\n");
150
151	(void)fprintf(stderr,
152	    "  --change-dir         -c         Change the current working directory to root\n"
153	    "  --close-fds          -f         Set stdin, stdout, stderr to /dev/null\n"
154	    "  --sighup             -H         Close and re-open output file on SIGHUP\n"
155	    "  --syslog             -S         Send output to syslog\n"
156	    "  --output-file        -o <file>  Append output of the child process to file\n"
157	    "  --output-mask        -m <mask>  What to send to syslog/file\n"
158	    "                                  1=stdout, 2=stderr, 3=both\n"
159	    "  --child-pidfile      -p <file>  Write PID of the child process to file\n"
160	    "  --supervisor-pidfile -P <file>  Write PID of the supervisor process to file\n"
161	    "  --restart            -r         Restart child if it terminates (1 sec delay)\n"
162	    "  --restart-count      -C <N>     Restart child at most N times, then exit\n"
163	    "  --restart-delay      -R <N>     Restart child if it terminates after N sec\n"
164	    "  --title              -t <title> Set the title of the supervisor process\n"
165	    "  --user               -u <user>  Drop privileges, run as given user\n"
166	    "  --syslog-priority    -s <prio>  Set syslog priority\n"
167	    "  --syslog-facility    -l <flty>  Set syslog facility\n"
168	    "  --syslog-tag         -T <tag>   Set syslog tag\n"
169	    "  --help               -h         Show this help\n");
170
171	exit(exitcode);
172}
173
174int
175main(int argc, char *argv[])
176{
177	const char *e = NULL;
178	int ch = 0;
179	struct daemon_state state;
180
181	daemon_state_init(&state);
182
183	/* Signals are processed via kqueue */
184	signal(SIGHUP, SIG_IGN);
185	signal(SIGTERM, SIG_IGN);
186
187	/*
188	 * Supervision mode is enabled if one of the following options are used:
189	 * --child-pidfile -p
190	 * --supervisor-pidfile -P
191	 * --restart -r / --restart-delay -R
192	 * --syslog -S
193	 * --syslog-facility -l
194	 * --syslog-priority -s
195	 * --syslog-tag -T
196	 *
197	 * In supervision mode daemon executes the command in a forked process
198	 * and observes the child by waiting for SIGCHILD. In supervision mode
199	 * daemon must never exit before the child, this is necessary  to prevent
200	 * orphaning the child and leaving a stale pid file.
201	 * To achieve this daemon catches SIGTERM and
202	 * forwards it to the child, expecting to get SIGCHLD eventually.
203	 */
204	while ((ch = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
205		switch (ch) {
206		case 'c':
207			state.keep_cur_workdir = 0;
208			break;
209		case 'C':
210			state.restart_count = (int)strtonum(optarg, 0,
211			    MAX_RESTART_COUNT, &e);
212			if (e != NULL) {
213				errx(6, "invalid restart count: %s", e);
214			}
215			break;
216		case 'f':
217			state.keep_fds_open = 0;
218			break;
219		case 'H':
220			state.log_reopen = true;
221			break;
222		case 'l':
223			state.syslog_facility = get_log_mapping(optarg,
224			    facilitynames);
225			if (state.syslog_facility == -1) {
226				errx(5, "unrecognized syslog facility");
227			}
228			state.syslog_enabled = true;
229			state.mode = MODE_SUPERVISE;
230			break;
231		case 'm':
232			state.stdmask = (int)strtonum(optarg, 0, 3, &e);
233			if (e != NULL) {
234				errx(6, "unrecognized listening mask: %s", e);
235			}
236			break;
237		case 'o':
238			state.output_filename = optarg;
239			/*
240			 * TODO: setting output filename doesn't have to turn
241			 * the supervision mode on. For non-supervised mode
242			 * daemon could open the specified file and set it's
243			 * descriptor as both stderr and stout before execve()
244			 */
245			state.mode = MODE_SUPERVISE;
246			break;
247		case 'p':
248			state.child_pidfile = optarg;
249			state.mode = MODE_SUPERVISE;
250			break;
251		case 'P':
252			state.parent_pidfile = optarg;
253			state.mode = MODE_SUPERVISE;
254			break;
255		case 'r':
256			state.restart_enabled = true;
257			state.mode = MODE_SUPERVISE;
258			break;
259		case 'R':
260			state.restart_enabled = true;
261			state.restart_delay = (int)strtonum(optarg, 1,
262			    MAX_RESTART_DELAY, &e);
263			if (e != NULL) {
264				errx(6, "invalid restart delay: %s", e);
265			}
266			state.mode = MODE_SUPERVISE;
267			break;
268		case 's':
269			state.syslog_priority = get_log_mapping(optarg,
270			    prioritynames);
271			if (state.syslog_priority == -1) {
272				errx(4, "unrecognized syslog priority");
273			}
274			state.syslog_enabled = true;
275			state.mode = MODE_SUPERVISE;
276			break;
277		case 'S':
278			state.syslog_enabled = true;
279			state.mode = MODE_SUPERVISE;
280			break;
281		case 't':
282			state.title = optarg;
283			break;
284		case 'T':
285			state.syslog_tag = optarg;
286			state.syslog_enabled = true;
287			state.mode = MODE_SUPERVISE;
288			break;
289		case 'u':
290			state.user = optarg;
291			break;
292		case 'h':
293			usage(0);
294			__unreachable();
295		default:
296			usage(1);
297		}
298	}
299	argc -= optind;
300	argv += optind;
301	state.argv = argv;
302
303	if (argc == 0) {
304		usage(1);
305	}
306
307	if (!state.title) {
308		state.title = argv[0];
309	}
310
311	if (state.output_filename) {
312		state.output_fd = open_log(state.output_filename);
313		if (state.output_fd == -1) {
314			err(7, "open");
315		}
316	}
317
318	if (state.syslog_enabled) {
319		openlog(state.syslog_tag, LOG_PID | LOG_NDELAY,
320		    state.syslog_facility);
321	}
322
323	/*
324	 * Try to open the pidfile before calling daemon(3),
325	 * to be able to report the error intelligently
326	 */
327	open_pid_files(&state);
328
329	/*
330	 * TODO: add feature to avoid backgrounding
331	 * i.e. --foreground, -f
332	 */
333	if (daemon(state.keep_cur_workdir, state.keep_fds_open) == -1) {
334		warn("daemon");
335		daemon_terminate(&state);
336	}
337
338	if (state.mode == MODE_DAEMON) {
339		daemon_exec(&state);
340	}
341
342	/* Write out parent pidfile if needed. */
343	pidfile_write(state.parent_pidfh);
344
345	do {
346		state.mode = MODE_SUPERVISE;
347		daemon_eventloop(&state);
348		daemon_sleep(&state);
349		if (state.restart_enabled && state.restart_count > -1) {
350			if (state.restarted_count >= state.restart_count) {
351				state.restart_enabled = false;
352			}
353			state.restarted_count++;
354		}
355	} while (state.restart_enabled);
356
357	daemon_terminate(&state);
358}
359
360static void
361daemon_exec(struct daemon_state *state)
362{
363	pidfile_write(state->child_pidfh);
364
365	if (state->user != NULL) {
366		restrict_process(state->user);
367	}
368
369	/* Ignored signals remain ignored after execve, unignore them */
370	signal(SIGHUP, SIG_DFL);
371	signal(SIGTERM, SIG_DFL);
372	execvp(state->argv[0], state->argv);
373	/* execvp() failed - report error and exit this process */
374	err(1, "%s", state->argv[0]);
375}
376
377/* Main event loop: fork the child and watch for events.
378 * After SIGTERM is received and propagated to the child there are
379 * several options on what to do next:
380 * - read until EOF
381 * - read until EOF but only for a while
382 * - bail immediately
383 * Currently the third option is used, because otherwise there is no
384 * guarantee that read() won't block indefinitely if the child refuses
385 * to depart. To handle the second option, a different approach
386 * would be needed (procctl()?).
387 */
388static void
389daemon_eventloop(struct daemon_state *state)
390{
391	struct kevent event;
392	int kq;
393	int ret;
394	int pipe_fd[2];
395
396	/*
397	 * Try to protect against pageout kill. Ignore the
398	 * error, madvise(2) will fail only if a process does
399	 * not have superuser privileges.
400	 */
401	(void)madvise(NULL, 0, MADV_PROTECT);
402
403	if (pipe(pipe_fd)) {
404		err(1, "pipe");
405	}
406	state->pipe_rd = pipe_fd[0];
407	state->pipe_wr = pipe_fd[1];
408
409	kq = kqueuex(KQUEUE_CLOEXEC);
410	EV_SET(&event, state->pipe_rd, EVFILT_READ, EV_ADD|EV_CLEAR, 0, 0,
411	    NULL);
412	if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
413		err(EXIT_FAILURE, "failed to register kevent");
414	}
415
416	EV_SET(&event, SIGHUP,  EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
417	if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
418		err(EXIT_FAILURE, "failed to register kevent");
419	}
420
421	EV_SET(&event, SIGTERM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
422	if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
423		err(EXIT_FAILURE, "failed to register kevent");
424	}
425
426	EV_SET(&event, SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
427	if (kevent(kq, &event, 1, NULL, 0, NULL) == -1) {
428		err(EXIT_FAILURE, "failed to register kevent");
429	}
430	memset(&event, 0, sizeof(struct kevent));
431
432	/* Spawn a child to exec the command. */
433	state->pid = fork();
434
435	/* fork failed, this can only happen when supervision is enabled */
436	switch (state->pid) {
437	case -1:
438		warn("fork");
439		state->mode = MODE_NOCHILD;
440		return;
441	/* fork succeeded, this is child's branch */
442	case 0:
443		close(kq);
444		daemon_set_child_pipe(state);
445		daemon_exec(state);
446		break;
447	}
448
449	/* case: pid > 0; fork succeeded */
450	close(state->pipe_wr);
451	state->pipe_wr = -1;
452	setproctitle("%s[%d]", state->title, (int)state->pid);
453	setbuf(stdout, NULL);
454
455	while (state->mode != MODE_NOCHILD) {
456		ret = kevent(kq, NULL, 0, &event, 1, NULL);
457		switch (ret) {
458		case -1:
459			if (errno == EINTR)
460				continue;
461			err(EXIT_FAILURE, "kevent wait");
462		case 0:
463			continue;
464		}
465
466		if (event.flags & EV_ERROR) {
467			errx(EXIT_FAILURE, "Event error: %s",
468			    strerror((int)event.data));
469		}
470
471		switch (event.filter) {
472		case EVFILT_SIGNAL:
473
474			switch (event.ident) {
475			case SIGCHLD:
476				if (daemon_is_child_dead(state)) {
477					/* child is dead, read all until EOF */
478					state->pid = -1;
479					state->mode = MODE_NOCHILD;
480					while (listen_child(state)) {
481						continue;
482					}
483				}
484				continue;
485			case SIGTERM:
486				if (state->mode != MODE_SUPERVISE) {
487					/* user is impatient */
488					/* TODO: warn about repeated SIGTERM? */
489					continue;
490				}
491
492				state->mode = MODE_TERMINATING;
493				state->restart_enabled = false;
494				if (state->pid > 0) {
495					kill(state->pid, SIGTERM);
496				}
497				/*
498				 * TODO set kevent timer to exit
499				 * unconditionally after some time
500				 */
501				continue;
502			case SIGHUP:
503				if (state->log_reopen && state->output_fd >= 0) {
504					reopen_log(state);
505				}
506				continue;
507			}
508			break;
509
510		case EVFILT_READ:
511			/*
512			 * detecting EOF is no longer necessary
513			 * if child closes the pipe daemon will stop getting
514			 * EVFILT_READ events
515			 */
516
517			if (event.data > 0) {
518				(void)listen_child(state);
519			}
520			continue;
521		default:
522			continue;
523		}
524	}
525
526	close(kq);
527	close(state->pipe_rd);
528	state->pipe_rd = -1;
529}
530
531static void
532daemon_sleep(struct daemon_state *state)
533{
534	struct timespec ts = { state->restart_delay, 0 };
535
536	if (!state->restart_enabled) {
537		return;
538	}
539	while (nanosleep(&ts, &ts) == -1) {
540		if (errno != EINTR) {
541			err(1, "nanosleep");
542		}
543	}
544}
545
546static void
547open_pid_files(struct daemon_state *state)
548{
549	pid_t fpid;
550	int serrno;
551
552	if (state->child_pidfile) {
553		state->child_pidfh = pidfile_open(state->child_pidfile, 0600, &fpid);
554		if (state->child_pidfh == NULL) {
555			if (errno == EEXIST) {
556				errx(3, "process already running, pid: %d",
557				    fpid);
558			}
559			err(2, "pidfile ``%s''", state->child_pidfile);
560		}
561	}
562	/* Do the same for the actual daemon process. */
563	if (state->parent_pidfile) {
564		state->parent_pidfh= pidfile_open(state->parent_pidfile, 0600, &fpid);
565		if (state->parent_pidfh == NULL) {
566			serrno = errno;
567			pidfile_remove(state->child_pidfh);
568			errno = serrno;
569			if (errno == EEXIST) {
570				errx(3, "process already running, pid: %d",
571				     fpid);
572			}
573			err(2, "ppidfile ``%s''", state->parent_pidfile);
574		}
575	}
576}
577
578static int
579get_log_mapping(const char *str, const CODE *c)
580{
581	const CODE *cp;
582	for (cp = c; cp->c_name; cp++)
583		if (strcmp(cp->c_name, str) == 0) {
584			return cp->c_val;
585		}
586	return -1;
587}
588
589static void
590restrict_process(const char *user)
591{
592	struct passwd *pw = NULL;
593
594	pw = getpwnam(user);
595	if (pw == NULL) {
596		errx(1, "unknown user: %s", user);
597	}
598
599	if (setusercontext(NULL, pw, pw->pw_uid, LOGIN_SETALL) != 0) {
600		errx(1, "failed to set user environment");
601	}
602
603	setenv("USER", pw->pw_name, 1);
604	setenv("HOME", pw->pw_dir, 1);
605	setenv("SHELL", *pw->pw_shell ? pw->pw_shell : _PATH_BSHELL, 1);
606}
607
608/*
609 * We try to collect whole lines terminated by '\n'. Otherwise we collect a
610 * full buffer, and then output it.
611 *
612 * Return value of false is assumed to mean EOF or error, and true indicates to
613 * continue reading.
614 */
615static bool
616listen_child(struct daemon_state *state)
617{
618	ssize_t rv;
619	unsigned char *cp;
620
621	assert(state != NULL);
622	assert(state->pos < LBUF_SIZE - 1);
623
624	rv = read(state->pipe_rd, state->buf + state->pos,
625	    LBUF_SIZE - state->pos - 1);
626	if (rv > 0) {
627		state->pos += rv;
628		assert(state->pos <= LBUF_SIZE - 1);
629		/* Always NUL-terminate just in case. */
630		state->buf[LBUF_SIZE - 1] = '\0';
631
632		/*
633		 * Find position of the last newline in the buffer.
634		 * The buffer is guaranteed to have one or more complete lines
635		 * if at least one newline was found when searching in reverse.
636		 * All complete lines are flushed.
637		 * This does not take NUL characters into account.
638		 */
639		cp = memrchr(state->buf, '\n', state->pos);
640		if (cp != NULL) {
641			size_t bytes_line = cp - state->buf + 1;
642			assert(bytes_line <= state->pos);
643			do_output(state->buf, bytes_line, state);
644			state->pos -= bytes_line;
645			memmove(state->buf, cp + 1, state->pos);
646		}
647		/* Wait until the buffer is full. */
648		if (state->pos < LBUF_SIZE - 1) {
649			return true;
650		}
651		do_output(state->buf, state->pos, state);
652		state->pos = 0;
653		return true;
654	} else if (rv == -1) {
655		/* EINTR should trigger another read. */
656		if (errno == EINTR) {
657			return true;
658		} else {
659			warn("read");
660			return false;
661		}
662	}
663	/* Upon EOF, we have to flush what's left of the buffer. */
664	if (state->pos > 0) {
665		do_output(state->buf, state->pos, state);
666		state->pos = 0;
667	}
668	return false;
669}
670
671/*
672 * The default behavior is to stay silent if the user wants to redirect
673 * output to a file and/or syslog. If neither are provided, then we bounce
674 * everything back to parent's stdout.
675 */
676static void
677do_output(const unsigned char *buf, size_t len, struct daemon_state *state)
678{
679	assert(len <= LBUF_SIZE);
680	assert(state != NULL);
681
682	if (len < 1) {
683		return;
684	}
685	if (state->syslog_enabled) {
686		syslog(state->syslog_priority, "%.*s", (int)len, buf);
687	}
688	if (state->output_fd != -1) {
689		if (write(state->output_fd, buf, len) == -1)
690			warn("write");
691	}
692	if (state->keep_fds_open &&
693	    !state->syslog_enabled &&
694	    state->output_fd == -1) {
695		printf("%.*s", (int)len, buf);
696	}
697}
698
699static int
700open_log(const char *outfn)
701{
702
703	return open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
704}
705
706static void
707reopen_log(struct daemon_state *state)
708{
709	int outfd;
710
711	outfd = open_log(state->output_filename);
712	if (state->output_fd >= 0) {
713		close(state->output_fd);
714	}
715	state->output_fd = outfd;
716}
717
718static void
719daemon_state_init(struct daemon_state *state)
720{
721	*state = (struct daemon_state) {
722		.buf = {0},
723		.pos = 0,
724		.argv = NULL,
725		.parent_pidfh = NULL,
726		.child_pidfh = NULL,
727		.child_pidfile = NULL,
728		.parent_pidfile = NULL,
729		.title = NULL,
730		.user = NULL,
731		.mode = MODE_DAEMON,
732		.restart_enabled = false,
733		.pid = 0,
734		.pipe_rd = -1,
735		.pipe_wr = -1,
736		.keep_cur_workdir = 1,
737		.restart_delay = 1,
738		.stdmask = STDOUT_FILENO | STDERR_FILENO,
739		.syslog_enabled = false,
740		.log_reopen = false,
741		.syslog_priority = LOG_NOTICE,
742		.syslog_tag = "daemon",
743		.syslog_facility = LOG_DAEMON,
744		.keep_fds_open = 1,
745		.output_fd = -1,
746		.output_filename = NULL,
747		.restart_count = -1,
748		.restarted_count = 0
749	};
750}
751
752static _Noreturn void
753daemon_terminate(struct daemon_state *state)
754{
755	assert(state != NULL);
756
757	if (state->output_fd >= 0) {
758		close(state->output_fd);
759	}
760	if (state->pipe_rd >= 0) {
761		close(state->pipe_rd);
762	}
763
764	if (state->pipe_wr >= 0) {
765		close(state->pipe_wr);
766	}
767	if (state->syslog_enabled) {
768		closelog();
769	}
770	pidfile_remove(state->child_pidfh);
771	pidfile_remove(state->parent_pidfh);
772
773	/*
774	 * Note that the exit value here doesn't matter in the case of a clean
775	 * exit; daemon(3) already detached us from the caller, nothing is left
776	 * to care about this one.
777	 */
778	exit(1);
779}
780
781/*
782 * Returns true if SIGCHILD came from state->pid due to its exit.
783 */
784static bool
785daemon_is_child_dead(struct daemon_state *state)
786{
787	int status;
788
789	for (;;) {
790		int who = waitpid(-1, &status, WNOHANG);
791		if (state->pid == who && (WIFEXITED(status) ||
792		    WIFSIGNALED(status))) {
793			return true;
794		}
795		if (who == 0) {
796			return false;
797		}
798		if (who == -1 && errno != EINTR) {
799			warn("waitpid");
800			return false;
801		}
802	}
803}
804
805static void
806daemon_set_child_pipe(struct daemon_state *state)
807{
808	if (state->stdmask & STDERR_FILENO) {
809		if (dup2(state->pipe_wr, STDERR_FILENO) == -1) {
810			err(1, "dup2");
811		}
812	}
813	if (state->stdmask & STDOUT_FILENO) {
814		if (dup2(state->pipe_wr, STDOUT_FILENO) == -1) {
815			err(1, "dup2");
816		}
817	}
818	if (state->pipe_wr != STDERR_FILENO &&
819	    state->pipe_wr != STDOUT_FILENO) {
820		close(state->pipe_wr);
821	}
822
823	/* The child gets dup'd pipes. */
824	close(state->pipe_rd);
825}
826