Page MenuHomeFreeBSD
Files F142537049

D7993.id20720.diff
No OneTemporary
Actions

D7993.id20720.diff
View Options

Index: usr.sbin/daemon/daemon.8
===================================================================
--- usr.sbin/daemon/daemon.8
+++ usr.sbin/daemon/daemon.8
@@ -26,7 +26,7 @@
.\"
.\" $FreeBSD: head/usr.sbin/daemon/daemon.8 296321 2016-03-02 19:10:39Z cem $
.\"
-.Dd March 2, 2016
+.Dd September 25, 2016
.Dt DAEMON 8
.Os
.Sh NAME
@@ -34,11 +34,16 @@
.Nd run detached from the controlling terminal
.Sh SYNOPSIS
.Nm
-.Op Fl cfr
+.Op Fl cfrS
.Op Fl p Ar child_pidfile
.Op Fl P Ar supervisor_pidfile
.Op Fl t Ar title
.Op Fl u Ar user
+.Op Fl m Ar output_mask
+.Op Fl o Ar output_file
+.Op Fl s Ar syslog_priority
+.Op Fl T Ar syslog_tag
+.Op Fl s Ar syslog_facility
.Ar command arguments ...
.Sh DESCRIPTION
The
@@ -55,6 +60,19 @@
.It Fl f
Redirect standard input, standard output and standard error to
.Pa /dev/null .
+.It Fl S
+Enable syslog output. This is implicitly applied if other syslog parameters
+are provided.
+The default values are daemon, notice, and daemon for facility, priority, and
+tag, respectively.
+.It Fl o Ar output_file
+Append output from the daemonized process to
+.Pa output_file .
+If the file does not exist, it is created with permissions 0600.
+.It Fl m Ar output_mask
+Redirect output from the child process stdout (1), stderr (2), or both (3).
+This affects only file and syslog output.
+The default is 3.
.It Fl p Ar child_pidfile
Write the ID of the created process into the
.Ar child_pidfile
@@ -96,18 +114,37 @@
.It Fl r
Supervise and restart the program if it has been terminated.
.It Fl t Ar title
-Process title for the daemon to make it easily identifiable.
+Set the title for the daemon process.
+The default is the daemonized invocation.
.It Fl u Ar user
Login name of the user to execute the program under.
Requires adequate superuser privileges.
+.It Fl s Ar syslog_priority
+These priorities are accepted: emerg, alert, crit, err, warning,
+notice, info, and debug.
+The default is info.
+.It Fl l Ar syslog_facility
+These facilities are accepted: auth, authpriv, console, cron, daemon,
+ftp, kern, lpr, mail, news, ntp, security, syslog, user, uucp, and
+local0, ..., local7.
+The default is daemon.
+.It Fl T Ar syslog_tag
+Set the tag which is appended to all syslog messages.
+The default is daemon.
.El
.Pp
-If the
+If any of the options
.Fl p ,
-.Fl P
+.Fl P ,
+.Fl r ,
+.Fl o ,
+.Fl s ,
+.Fl T ,
+.Fl m ,
+.Fl S ,
or
-.Fl r
-option is specified the program is executed in a spawned child process.
+.Fl l
+are specified, the program is executed in a spawned child process.
The
.Nm
waits until it terminates to keep the pid file(s) locked and removes them
@@ -119,6 +156,10 @@
Normally it will cause the child to exit, remove the pidfile(s)
and then terminate.
.Pp
+If neither file or syslog output are selected, all output is redirected to the
+.Nm
+process and written to stdout.
+.Pp
The
.Fl P
option is useful combined with the
@@ -145,8 +186,15 @@
or
.Ar supervisor_pidfile
is requested, but cannot be opened, 3 if process is already running (pidfile
-exists and is locked),
-otherwise 0.
+exists and is locked), 4 if
+.Ar syslog_priority
+is not accepted, 5 if
+.Ar syslog_facility
+is not accepted, 6 if
+.Ar output_mask
+is not within the accepted range, 7 if
+.Ar output_file
+cannot be opened for appending, and otherwise 0.
.Sh DIAGNOSTICS
If the command cannot be executed, an error message is displayed on
standard error unless the
Index: usr.sbin/daemon/daemon.c
===================================================================
--- usr.sbin/daemon/daemon.c
+++ usr.sbin/daemon/daemon.c
@@ -35,6 +35,7 @@
#include <sys/mman.h>
#include <sys/wait.h>
+#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <libutil.h>
@@ -44,25 +45,59 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
+#include <string.h>
+#include <strings.h>
+#define SYSLOG_NAMES
+#include <syslog.h>
+#include <time.h>
+#include <assert.h>
+
+#define LBUF_SIZE 4096
+
+struct log_params {
+ int dosyslog;
+ int logpri;
+ int noclose;
+ int outfd;
+};
-static void dummy_sighandler(int);
static void restrict_process(const char *);
-static int wait_child(pid_t pid, sigset_t *mask);
+static void handle_term(int);
+static void handle_chld(int);
+static int listen_child(int, struct log_params *);
+static int get_log_mapping(const char *, const CODE *);
+static void open_pid_files(const char *, const char *, struct pidfh **,
+ struct pidfh **);
+static void do_output(const unsigned char *, size_t, struct log_params *);
+static void daemon_sleep(time_t, long);
static void usage(void);
+static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0;
+
int
main(int argc, char *argv[])
{
- struct pidfh *ppfh, *pfh;
- sigset_t mask, oldmask;
- int ch, nochdir, noclose, restart, serrno;
- const char *pidfile, *ppidfile, *title, *user;
- pid_t otherpid, pid;
+ const char *pidfile, *ppidfile, *title, *user, *outfn, *logtag;
+ int ch, nochdir, noclose, restart, dosyslog, child_eof;
+ sigset_t mask_susp, mask_orig, mask_read, mask_term;
+ struct log_params logpar;
+ int pfd[2] = { -1, -1 }, outfd = -1;
+ int stdmask, logpri, logfac;
+ struct pidfh *ppfh, *pfh;
+ char *p;
+ memset(&logpar, 0, sizeof(logpar));
+ stdmask = STDOUT_FILENO | STDERR_FILENO;
+ ppidfile = pidfile = user = NULL;
nochdir = noclose = 1;
+ logpri = LOG_NOTICE;
+ logfac = LOG_DAEMON;
+ logtag = "daemon";
restart = 0;
- ppidfile = pidfile = title = user = NULL;
- while ((ch = getopt(argc, argv, "cfp:P:rt:u:")) != -1) {
+ dosyslog = 0;
+ outfn = NULL;
+ title = NULL;
+ while ((ch = getopt(argc, argv, "cfSp:P:ru:o:s:l:t:l:m:T:")) != -1) {
switch (ch) {
case 'c':
nochdir = 0;
@@ -70,6 +105,20 @@
case 'f':
noclose = 0;
break;
+ case 'l':
+ logfac = get_log_mapping(optarg, facilitynames);
+ if (logfac == -1)
+ errx(5, "unrecognized syslog facility");
+ dosyslog = 1;
+ break;
+ case 'm':
+ stdmask = strtol(optarg, &p, 10);
+ if (p == optarg || stdmask < 0 || stdmask > 3)
+ errx(6, "unrecognized listening mask");
+ break;
+ case 'o':
+ outfn = optarg;
+ break;
case 'p':
pidfile = optarg;
break;
@@ -79,9 +128,22 @@
case 'r':
restart = 1;
break;
+ case 's':
+ logpri = get_log_mapping(optarg, prioritynames);
+ if (logpri == -1)
+ errx(4, "unrecognized syslog priority");
+ dosyslog = 1;
+ break;
+ case 'S':
+ dosyslog = 1;
+ break;
case 't':
title = optarg;
break;
+ case 'T':
+ logtag = optarg;
+ dosyslog = 1;
+ break;
case 'u':
user = optarg;
break;
@@ -95,35 +157,23 @@
if (argc == 0)
usage();
+ if (!title)
+ title = argv[0];
+
ppfh = pfh = NULL;
/*
* Try to open the pidfile before calling daemon(3),
* to be able to report the error intelligently
*/
- if (pidfile != NULL) {
- pfh = pidfile_open(pidfile, 0600, &otherpid);
- if (pfh == NULL) {
- if (errno == EEXIST) {
- errx(3, "process already running, pid: %d",
- otherpid);
- }
- err(2, "pidfile ``%s''", pidfile);
- }
- }
- /* Do the same for actual daemon process. */
- if (ppidfile != NULL) {
- ppfh = pidfile_open(ppidfile, 0600, &otherpid);
- if (ppfh == NULL) {
- serrno = errno;
- pidfile_remove(pfh);
- errno = serrno;
- if (errno == EEXIST) {
- errx(3, "process already running, pid: %d",
- otherpid);
- }
- err(2, "ppidfile ``%s''", ppidfile);
- }
+ open_pid_files(pidfile, ppidfile, &pfh, &ppfh);
+
+ if (outfn) {
+ outfd = open(outfn, O_CREAT | O_WRONLY | O_APPEND, 0600);
+ if (outfd == -1)
+ err(7, "open");
}
+ if (dosyslog)
+ openlog(logtag, LOG_PID | LOG_NDELAY, logfac);
if (daemon(nochdir, noclose) == -1) {
warn("daemon");
@@ -131,7 +181,6 @@
}
/* Write out parent pidfile if needed. */
pidfile_write(ppfh);
-
/*
* If the pidfile or restart option is specified the daemon
* executes the command in a forked process and wait on child
@@ -139,34 +188,50 @@
* we don't want the monitoring daemon to be terminated
* leaving the running process and the stale pidfile, so we
* catch SIGTERM and forward it to the children expecting to
- * get SIGCHLD eventually.
+ * get SIGCHLD eventually. We also must fork() to obtain a
+ * readable pipe with the child for writing to a log file
+ * and syslog.
*/
pid = -1;
- if (pidfile != NULL || ppidfile != NULL || restart) {
+ if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
+ struct sigaction act_term, act_chld;
+
+ memset(&act_term, 0, sizeof(act_term));
+ act_term.sa_handler = handle_term;
+ sigemptyset(&act_term.sa_mask);
/*
- * Restore default action for SIGTERM in case the
- * parent process decided to ignore it.
+ * XXX Perhaps block SIGTERM during SIGCHLD handling
+ * and vice versa.
*/
- if (signal(SIGTERM, SIG_DFL) == SIG_ERR) {
- warn("signal");
- goto exit;
- }
+ memset(&act_chld, 0, sizeof(act_chld));
+ act_chld.sa_handler = handle_chld;
+ sigemptyset(&act_chld.sa_mask);
+
+ /* Block these when avoiding racing before sigsuspend(). */
+ sigemptyset(&mask_susp);
+ sigaddset(&mask_susp, SIGTERM);
+ sigaddset(&mask_susp, SIGCHLD);
+ /* Block SIGTERM until we have forked. */
+ sigemptyset(&mask_term);
+ sigaddset(&mask_term, SIGTERM);
/*
- * Because SIGCHLD is ignored by default, setup dummy handler
- * for it, so we can mask it.
+ * When reading, we wish to avoid SIGCHLD. SIGTERM
+ * has to be caught, otherwise we'll be stuck until
+ * the read() returns - if it returns.
*/
- if (signal(SIGCHLD, dummy_sighandler) == SIG_ERR) {
- warn("signal");
+ sigemptyset(&mask_read);
+ sigaddset(&mask_read, SIGCHLD);
+ /* Block SIGTERM to avoid racing until we have forked. */
+ if (sigprocmask(SIG_BLOCK, &mask_term, &mask_orig)) {
+ warn("sigprocmask");
goto exit;
}
- /*
- * Block interesting signals.
- */
- sigemptyset(&mask);
- sigaddset(&mask, SIGTERM);
- sigaddset(&mask, SIGCHLD);
- if (sigprocmask(SIG_SETMASK, &mask, &oldmask) == -1) {
- warn("sigprocmask");
+ if (sigaction(SIGTERM, &act_term, NULL) == -1) {
+ warn("sigaction");
+ goto exit;
+ }
+ if (sigaction(SIGCHLD, &act_chld, NULL) == -1) {
+ warn("sigaction");
goto exit;
}
/*
@@ -175,56 +240,188 @@
* not have superuser privileges.
*/
(void)madvise(NULL, 0, MADV_PROTECT);
+ logpar.outfd = outfd;
+ logpar.dosyslog = dosyslog;
+ logpar.logpri = logpri;
+ logpar.noclose = noclose;
restart:
+ if (pipe(pfd))
+ err(1, "pipe");
/*
- * Spawn a child to exec the command, so in the parent
- * we could wait for it to exit and remove pidfile.
- */
+ * Spawn a child to exec the command.
+ */
+ child_gone = 0;
pid = fork();
if (pid == -1) {
warn("fork");
goto exit;
+ } else if (pid > 0) {
+ /*
+ * Unblock SIGTERM after we know we have a valid
+ * child PID to kill.
+ */
+ if (sigprocmask(SIG_UNBLOCK, &mask_term, NULL)) {
+ warn("sigprocmask");
+ goto exit;
+ }
+ close(pfd[1]);
+ pfd[1] = -1;
}
}
if (pid <= 0) {
- if (pid == 0) {
- /* Restore old sigmask in the child. */
- if (sigprocmask(SIG_SETMASK, &oldmask, NULL) == -1)
- err(1, "sigprocmask");
- }
/* Now that we are the child, write out the pid. */
pidfile_write(pfh);
if (user != NULL)
restrict_process(user);
-
+ /*
+ * When forking, the child gets the original sigmask,
+ * and dup'd pipes.
+ */
+ if (pid == 0) {
+ close(pfd[0]);
+ if (sigprocmask(SIG_SETMASK, &mask_orig, NULL))
+ err(1, "sigprogmask");
+ if (stdmask & STDERR_FILENO) {
+ if (dup2(pfd[1], STDERR_FILENO) == -1)
+ err(1, "dup2");
+ }
+ if (stdmask & STDOUT_FILENO) {
+ if (dup2(pfd[1], STDOUT_FILENO) == -1)
+ err(1, "dup2");
+ }
+ /* XXX Is this right? */
+ if (pfd[1] != STDERR_FILENO &&
+ pfd[1] != STDOUT_FILENO)
+ close(pfd[1]);
+ }
execvp(argv[0], argv);
-
/*
* execvp() failed -- report the error. The child is
* now running, so the exit status doesn't matter.
*/
err(1, "%s", argv[0]);
}
-
- if (title != NULL)
- setproctitle("%s[%d]", title, pid);
- else
- setproctitle("%s[%d]", argv[0], pid);
- if (wait_child(pid, &mask) == 0 && restart) {
- sleep(1);
+ setproctitle("%s[%d]", title, (int)pid);
+ /*
+ * As we have closed the write end of pipe for parent process,
+ * we might detect the child's exit by reading EOF. The child
+ * might have closed its stdout and stderr, so we must wait for
+ * the SIGCHLD to ensure that the process is actually gone.
+ */
+ child_eof = 0;
+ for (;;) {
+ /*
+ * We block SIGCHLD when listening, but SIGTERM we accept
+ * so the read() won't block if we wish to depart.
+ *
+ * Upon receiving SIGTERM, we some options after sending
+ * the SIGTERM to our child:
+ * - read until EOF
+ * - read until EOF but only for a while
+ * - bail immediately
+ *
+ * We go for the third, as otherwise we have no guarantee
+ * that we won't block indefinitely if the child refuses
+ * to depart. To handle the second possibility, a different
+ * approach would be needed (procctl()?)
+ */
+ if (child_gone && child_eof) {
+ break;
+ } else if (terminate) {
+ goto exit;
+ } else if (!child_eof) {
+ if (sigprocmask(SIG_BLOCK, &mask_read, NULL)) {
+ warn("sigprocmask");
+ goto exit;
+ }
+ child_eof = !listen_child(pfd[0], &logpar);
+ if (sigprocmask(SIG_UNBLOCK, &mask_read, NULL)) {
+ warn("sigprocmask");
+ goto exit;
+ }
+ } else {
+ if (sigprocmask(SIG_BLOCK, &mask_susp, NULL)) {
+ warn("sigprocmask");
+ goto exit;
+ }
+ while (!terminate && !child_gone)
+ sigsuspend(&mask_orig);
+ if (sigprocmask(SIG_UNBLOCK, &mask_susp, NULL)) {
+ warn("sigprocmask");
+ goto exit;
+ }
+ }
+ }
+ if (restart && !terminate) {
+ daemon_sleep(1, 0);
+ close(pfd[0]);
+ pfd[0] = -1;
goto restart;
}
exit:
+
+ close(outfd);
+ close(pfd[0]);
+ close(pfd[1]);
+ if (dosyslog)
+ closelog();
pidfile_remove(pfh);
pidfile_remove(ppfh);
exit(1); /* If daemon(3) succeeded exit status does not matter. */
}
static void
-dummy_sighandler(int sig __unused)
+daemon_sleep(time_t secs, long nsecs)
+{
+ struct timespec ts = { secs, nsecs };
+ while (nanosleep(&ts, &ts) == -1) {
+ if (errno != EINTR)
+ err(1, "nanosleep");
+ }
+}
+
+static void
+open_pid_files(const char *pidfile, const char *ppidfile,
+ struct pidfh **pfh, struct pidfh **ppfh)
+{
+ pid_t fpid;
+ int serrno;
+
+ if (pidfile) {
+ *pfh = pidfile_open(pidfile, 0600, &fpid);
+ if (*pfh == NULL) {
+ if (errno == EEXIST) {
+ errx(3, "process already running, pid: %d",
+ fpid);
+ }
+ err(2, "pidfile ``%s''", pidfile);
+ }
+ }
+ /* Do the same for actual daemon process. */
+ if (ppidfile) {
+ *ppfh = pidfile_open(ppidfile, 0600, &fpid);
+ if (*ppfh == NULL) {
+ serrno = errno;
+ pidfile_remove(*pfh);
+ errno = serrno;
+ if (errno == EEXIST) {
+ errx(3, "process already running, pid: %d",
+ fpid);
+ }
+ err(2, "ppidfile ``%s''", ppidfile);
+ }
+ }
+}
+
+static int
+get_log_mapping(const char *str, const CODE *c)
{
- /* Nothing to do. */
+ const CODE *cp;
+ for (cp = c; cp->c_name; cp++)
+ if (strcmp(cp->c_name, str) == 0)
+ return cp->c_val;
+ return -1;
}
static void
@@ -240,34 +437,114 @@
errx(1, "failed to set user environment");
}
+/*
+ * We try to collect whole lines terminated by '\n'. Otherwise
+ * we collect a full buffer, and then output it.
+ *
+ * Return value of 0 is assumed to mean EOF or error, and 1
+ * indicates to continue reading.
+ */
static int
-wait_child(pid_t pid, sigset_t *mask)
+listen_child(int fd, struct log_params *logpar)
{
- int terminate, signo;
+ static unsigned char buf[LBUF_SIZE];
+ static size_t bytes_read = 0;
+ int rv;
- terminate = 0;
- for (;;) {
- if (sigwait(mask, &signo) == -1) {
- warn("sigwaitinfo");
- return (-1);
+ assert(logpar);
+ assert(bytes_read < LBUF_SIZE - 1);
+
+ rv = read(fd, buf + bytes_read, LBUF_SIZE - bytes_read - 1);
+ if (rv > 0) {
+ unsigned char *cp;
+
+ bytes_read += rv;
+ assert(bytes_read <= LBUF_SIZE - 1);
+ /* Always NUL-terminate just in case. */
+ buf[LBUF_SIZE - 1] = '\0';
+ /*
+ * Chomp line by line until we run out of buffer.
+ * This does not take NUL characters into account.
+ */
+ while ((cp = memchr(buf, '\n', bytes_read)) != NULL) {
+ size_t bytes_line = cp - buf + 1;
+ assert(bytes_line <= bytes_read);
+ bytes_read -= bytes_line;
+ do_output(buf, bytes_line, logpar);
+ memmove(buf, cp + 1, bytes_read);
}
- switch (signo) {
- case SIGCHLD:
- if (waitpid(pid, NULL, WNOHANG) == -1) {
- warn("waitpid");
- return (-1);
- }
- return (terminate);
- case SIGTERM:
- terminate = 1;
- if (kill(pid, signo) == -1) {
- warn("kill");
- return (-1);
- }
- continue;
- default:
- warnx("sigwaitinfo: invalid signal: %d", signo);
- return (-1);
+ /* Wait until the buffer is full. */
+ if (bytes_read < LBUF_SIZE - 1)
+ return 1;
+ do_output(buf, bytes_read, logpar);
+ bytes_read = 0;
+ return 1;
+ } else if (rv == -1) {
+ /* EINTR should trigger another read. */
+ if (errno == EINTR) {
+ return 1;
+ } else {
+ warn("read");
+ return 0;
+ }
+ }
+ /* Upon EOF, we have to flush what's left of the buffer. */
+ if (bytes_read > 0) {
+ do_output(buf, bytes_read, logpar);
+ bytes_read = 0;
+ }
+ return 0;
+}
+
+/*
+ * The default behavior is to stay silent if the user wants
+ * to redirect output to a file and/or syslog. If neither
+ * are provided, then we bounce everything back to parent's
+ * stdout.
+ */
+static void
+do_output(const unsigned char *buf, size_t len, struct log_params *logpar)
+{
+ assert(len <= LBUF_SIZE);
+ assert(logpar);
+
+ if (len < 1)
+ return;
+ if (logpar->dosyslog)
+ syslog(logpar->logpri, "%.*s", (int)len, buf);
+ if (logpar->outfd != -1) {
+ if (write(logpar->outfd, buf, len) == -1)
+ warn("write");
+ }
+ if (logpar->noclose && !logpar->dosyslog && logpar->outfd == -1)
+ printf("%.*s", (int)len, buf);
+}
+
+/*
+ * Note that we use the global PID acquired directly from fork.
+ */
+static void
+handle_term(int signo)
+{
+ if (pid > 0) {
+ kill(pid, signo);
+ terminate = 1;
+ }
+}
+
+static void
+handle_chld(int signo)
+{
+ (void)signo;
+ /* EINTR might stop our waiting. */
+ for (;;) {
+ int rv = waitpid(-1, NULL, WNOHANG);
+ if (pid == rv) {
+ child_gone = 1;
+ break;
+ } else if (rv == -1 && errno != EINTR) {
+ warn("waitpid");
+ return;
}
}
}
@@ -275,8 +552,11 @@
static void
usage(void)
{
- (void)fprintf(stderr, "%s\n\t%s\n",
- "usage: daemon [-cfr] [-p child_pidfile] [-P supervisor_pidfile]",
- "[-t title] [-u user] command arguments ...");
+ (void)fprintf(stderr,
+ "usage: daemon [-cfrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
+ " [-u user] [-o output_file] [-t title]\n"
+ " [-l syslog_facility] [-s syslog_priority]\n"
+ " [-T syslog_tag] [-m output_mask]\n"
+ "command arguments ...\n");
exit(1);
}

File Metadata

Mime Type
text/plain
Expires
Wed, Jan 21, 6:10 PM (7 h, 25 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
27816074
Default Alt Text
D7993.id20720.diff (18 KB)

Event Timeline