usr.sbin/daemon/daemon.c

   1 /*-
   2  * Copyright (c) 1999 Berkeley Software Design, Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. Berkeley Software Design Inc's name may not be used to endorse or
  13  *    promote products derived from this software without specific prior
  14  *    written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  *      From BSDI: daemon.c,v 1.2 1996/08/15 01:11:09 jch Exp
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/mman.h>
  36 #include <sys/wait.h>
  37
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <libutil.h>
  41 #include <login_cap.h>
  42 #include <pwd.h>
  43 #include <signal.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <unistd.h>
  47
  48 static void dummy_sighandler(int);
  49 static void restrict_process(const char *);
  50 static int  wait_child(pid_t pid, sigset_t *mask);
  51 static void usage(void);
  52
  53 int
  54 main(int argc, char *argv[])
  55 {
  56         struct pidfh *pfh = NULL;
  57         sigset_t mask, oldmask;
  58         int ch, nochdir, noclose, restart;
  59         const char *pidfile, *user;
  60         pid_t otherpid, pid;
  61
  62         nochdir = noclose = 1;
  63         restart = 0;
  64         pidfile = user = NULL;
  65         while ((ch = getopt(argc, argv, "cfp:ru:")) != -1) {
  66                 switch (ch) {
  67                 case 'c':
  68                         nochdir = 0;
  69                         break;
  70                 case 'f':
  71                         noclose = 0;
  72                         break;
  73                 case 'p':
  74                         pidfile = optarg;
  75                         break;
  76                 case 'r':
  77                         restart = 1;
  78                         break;
  79                 case 'u':
  80                         user = optarg;
  81                         break;
  82                 default:
  83                         usage();
  84                 }
  85         }
  86         argc -= optind;
  87         argv += optind;
  88
  89         if (argc == 0)
  90                 usage();
  91
  92         pfh = NULL;
  93         /*
  94          * Try to open the pidfile before calling daemon(3),
  95          * to be able to report the error intelligently
  96          */
  97         if (pidfile != NULL) {
  98                 pfh = pidfile_open(pidfile, 0600, &otherpid);
  99                 if (pfh == NULL) {
 100                         if (errno == EEXIST) {
 101                                 errx(3, "process already running, pid: %d",
 102                                     otherpid);
 103                         }
 104                         err(2, "pidfile ``%s''", pidfile);
 105                 }
 106         }
 107
 108         if (daemon(nochdir, noclose) == -1)
 109                 err(1, NULL);
 110
 111         /*
 112          * If the pidfile or restart option is specified the daemon
 113          * executes the command in a forked process and wait on child
 114          * exit to remove the pidfile or restart the command. Normally
 115          * we don't want the monitoring daemon to be terminated
 116          * leaving the running process and the stale pidfile, so we
 117          * catch SIGTERM and forward it to the children expecting to
 118          * get SIGCHLD eventually.
 119          */
 120         pid = -1;
 121         if (pidfile != NULL || restart) {
 122                 /*
 123                  * Restore default action for SIGTERM in case the
 124                  * parent process decided to ignore it.
 125                  */
 126                 if (signal(SIGTERM, SIG_DFL) == SIG_ERR)
 127                         err(1, "signal");
 128                 /*
 129                  * Because SIGCHLD is ignored by default, setup dummy handler
 130                  * for it, so we can mask it.
 131                  */
 132                 if (signal(SIGCHLD, dummy_sighandler) == SIG_ERR)
 133                         err(1, "signal");
 134                 /*
 135                  * Block interesting signals.
 136                  */
 137                 sigemptyset(&mask);
 138                 sigaddset(&mask, SIGTERM);
 139                 sigaddset(&mask, SIGCHLD);
 140                 if (sigprocmask(SIG_SETMASK, &mask, &oldmask) == -1)
 141                         err(1, "sigprocmask");
 142                 /*
 143                  * Try to protect against pageout kill. Ignore the
 144                  * error, madvise(2) will fail only if a process does
 145                  * not have superuser privileges.
 146                  */
 147                 (void)madvise(NULL, 0, MADV_PROTECT);
 148 restart:
 149                 /*
 150                  * Spawn a child to exec the command, so in the parent
 151                  * we could wait for it to exit and remove pidfile.
 152                  */
 153                 pid = fork();
 154                 if (pid == -1) {
 155                         pidfile_remove(pfh);
 156                         err(1, "fork");
 157                 }
 158         }
 159         if (pid <= 0) {
 160                 if (pid == 0) {
 161                         /* Restore old sigmask in the child. */
 162                         if (sigprocmask(SIG_SETMASK, &oldmask, NULL) == -1)
 163                                 err(1, "sigprocmask");
 164                 }
 165                 /* Now that we are the child, write out the pid. */
 166                 pidfile_write(pfh);
 167
 168                 if (user != NULL)
 169                         restrict_process(user);
 170
 171                 execvp(argv[0], argv);
 172
 173                 /*
 174                  * execvp() failed -- report the error. The child is
 175                  * now running, so the exit status doesn't matter.
 176                  */
 177                 err(1, "%s", argv[0]);
 178         }
 179         setproctitle("%s[%d]", argv[0], pid);
 180         if (wait_child(pid, &mask) == 0 && restart) {
 181                 sleep(1);
 182                 goto restart;
 183         }
 184         pidfile_remove(pfh);
 185         exit(0); /* Exit status does not matter. */
 186 }
 187
 188 static void
 189 dummy_sighandler(int sig __unused)
 190 {
 191         /* Nothing to do. */
 192 }
 193
 194 static void
 195 restrict_process(const char *user)
 196 {
 197         struct passwd *pw = NULL;
 198
 199         pw = getpwnam(user);
 200         if (pw == NULL)
 201                 errx(1, "unknown user: %s", user);
 202
 203         if (setusercontext(NULL, pw, pw->pw_uid, LOGIN_SETALL) != 0)
 204                 errx(1, "failed to set user environment");
 205 }
 206
 207 static int
 208 wait_child(pid_t pid, sigset_t *mask)
 209 {
 210         int terminate, signo;
 211
 212         terminate = 0;
 213         for (;;) {
 214                 if (sigwait(mask, &signo) == -1) {
 215                         warn("sigwaitinfo");
 216                         return (-1);
 217                 }
 218                 switch (signo) {
 219                 case SIGCHLD:
 220                         if (waitpid(pid, NULL, WNOHANG) == -1) {
 221                                 warn("waitpid");
 222                                 return (-1);
 223                         }
 224                         return (terminate);
 225                 case SIGTERM:
 226                         terminate = 1;
 227                         if (kill(pid, signo) == -1) {
 228                                 warn("kill");
 229                                 return (-1);
 230                         }
 231                         continue;
 232                 default:
 233                         warnx("sigwaitinfo: invalid signal: %d", signo);
 234                         return (-1);
 235                 }
 236         }
 237 }
 238
 239 static void
 240 usage(void)
 241 {
 242         (void)fprintf(stderr,
 243             "usage: daemon [-cfr] [-p pidfile] [-u user] command "
 244                 "arguments ...\n");
 245         exit(1);
 246 }