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 <fcntl.h>
  39 #include <err.h>
  40 #include <errno.h>
  41 #include <libutil.h>
  42 #include <login_cap.h>
  43 #include <pwd.h>
  44 #include <signal.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <unistd.h>
  48 #include <string.h>
  49 #include <strings.h>
  50 #define SYSLOG_NAMES
  51 #include <syslog.h>
  52 #include <time.h>
  53 #include <assert.h>
  54
  55 #define LBUF_SIZE 4096
  56
  57 struct log_params {
  58         int dosyslog;
  59         int logpri;
  60         int noclose;
  61         int outfd;
  62 };
  63
  64 static void restrict_process(const char *);
  65 static void handle_term(int);
  66 static void handle_chld(int);
  67 static int  listen_child(int, struct log_params *);
  68 static int  get_log_mapping(const char *, const CODE *);
  69 static void open_pid_files(const char *, const char *, struct pidfh **,
  70                            struct pidfh **);
  71 static void do_output(const unsigned char *, size_t, struct log_params *);
  72 static void daemon_sleep(time_t, long);
  73 static void usage(void);
  74
  75 static volatile sig_atomic_t terminate = 0, child_gone = 0, pid = 0;
  76
  77 int
  78 main(int argc, char *argv[])
  79 {
  80         const char *pidfile, *ppidfile, *title, *user, *outfn, *logtag;
  81         int ch, nochdir, noclose, restart, dosyslog, child_eof;
  82         sigset_t mask_susp, mask_orig, mask_read, mask_term;
  83         struct log_params logpar;
  84         int pfd[2] = { -1, -1 }, outfd = -1;
  85         int stdmask, logpri, logfac;
  86         struct pidfh *ppfh, *pfh;
  87         char *p;
  88
  89         memset(&logpar, 0, sizeof(logpar));
  90         stdmask = STDOUT_FILENO | STDERR_FILENO;
  91         ppidfile = pidfile = user = NULL;
  92         nochdir = noclose = 1;
  93         logpri = LOG_NOTICE;
  94         logfac = LOG_DAEMON;
  95         logtag = "daemon";
  96         restart = 0;
  97         dosyslog = 0;
  98         outfn = NULL;
  99         title = NULL;
 100         while ((ch = getopt(argc, argv, "cfSp:P:ru:o:s:l:t:l:m:T:")) != -1) {
 101                 switch (ch) {
 102                 case 'c':
 103                         nochdir = 0;
 104                         break;
 105                 case 'f':
 106                         noclose = 0;
 107                         break;
 108                 case 'l':
 109                         logfac = get_log_mapping(optarg, facilitynames);
 110                         if (logfac == -1)
 111                                 errx(5, "unrecognized syslog facility");
 112                         dosyslog = 1;
 113                         break;
 114                 case 'm':
 115                         stdmask = strtol(optarg, &p, 10);
 116                         if (p == optarg || stdmask < 0 || stdmask > 3)
 117                                 errx(6, "unrecognized listening mask");
 118                         break;
 119                 case 'o':
 120                         outfn = optarg;
 121                         break;
 122                 case 'p':
 123                         pidfile = optarg;
 124                         break;
 125                 case 'P':
 126                         ppidfile = optarg;
 127                         break;
 128                 case 'r':
 129                         restart = 1;
 130                         break;
 131                 case 's':
 132                         logpri = get_log_mapping(optarg, prioritynames);
 133                         if (logpri == -1)
 134                                 errx(4, "unrecognized syslog priority");
 135                         dosyslog = 1;
 136                         break;
 137                 case 'S':
 138                         dosyslog = 1;
 139                         break;
 140                 case 't':
 141                         title = optarg;
 142                         break;
 143                 case 'T':
 144                         logtag = optarg;
 145                         dosyslog = 1;
 146                         break;
 147                 case 'u':
 148                         user = optarg;
 149                         break;
 150                 default:
 151                         usage();
 152                 }
 153         }
 154         argc -= optind;
 155         argv += optind;
 156
 157         if (argc == 0)
 158                 usage();
 159
 160         if (!title)
 161                 title = argv[0];
 162
 163         if (outfn) {
 164                 outfd = open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
 165                 if (outfd == -1)
 166                         err(7, "open");
 167         }
 168
 169         if (dosyslog)
 170                 openlog(logtag, LOG_PID | LOG_NDELAY, logfac);
 171
 172         ppfh = pfh = NULL;
 173         /*
 174          * Try to open the pidfile before calling daemon(3),
 175          * to be able to report the error intelligently
 176          */
 177         open_pid_files(pidfile, ppidfile, &pfh, &ppfh);
 178         if (daemon(nochdir, noclose) == -1) {
 179                 warn("daemon");
 180                 goto exit;
 181         }
 182         /* Write out parent pidfile if needed. */
 183         pidfile_write(ppfh);
 184         /*
 185          * If the pidfile or restart option is specified the daemon
 186          * executes the command in a forked process and wait on child
 187          * exit to remove the pidfile or restart the command. Normally
 188          * we don't want the monitoring daemon to be terminated
 189          * leaving the running process and the stale pidfile, so we
 190          * catch SIGTERM and forward it to the children expecting to
 191          * get SIGCHLD eventually. We also must fork() to obtain a
 192          * readable pipe with the child for writing to a log file
 193          * and syslog.
 194          */
 195         pid = -1;
 196         if (pidfile || ppidfile || restart || outfd != -1 || dosyslog) {
 197                 struct sigaction act_term, act_chld;
 198
 199                 /* Avoid PID racing with SIGCHLD and SIGTERM. */
 200                 memset(&act_term, 0, sizeof(act_term));
 201                 act_term.sa_handler = handle_term;
 202                 sigemptyset(&act_term.sa_mask);
 203                 sigaddset(&act_term.sa_mask, SIGCHLD);
 204
 205                 memset(&act_chld, 0, sizeof(act_chld));
 206                 act_chld.sa_handler = handle_chld;
 207                 sigemptyset(&act_chld.sa_mask);
 208                 sigaddset(&act_chld.sa_mask, SIGTERM);
 209
 210                 /* Block these when avoiding racing before sigsuspend(). */
 211                 sigemptyset(&mask_susp);
 212                 sigaddset(&mask_susp, SIGTERM);
 213                 sigaddset(&mask_susp, SIGCHLD);
 214                 /* Block SIGTERM when we lack a valid child PID. */
 215                 sigemptyset(&mask_term);
 216                 sigaddset(&mask_term, SIGTERM);
 217                 /*
 218                  * When reading, we wish to avoid SIGCHLD. SIGTERM
 219                  * has to be caught, otherwise we'll be stuck until
 220                  * the read() returns - if it returns.
 221                  */
 222                 sigemptyset(&mask_read);
 223                 sigaddset(&mask_read, SIGCHLD);
 224                 /* Block SIGTERM to avoid racing until we have forked. */
 225                 if (sigprocmask(SIG_BLOCK, &mask_term, &mask_orig)) {
 226                         warn("sigprocmask");
 227                         goto exit;
 228                 }
 229                 if (sigaction(SIGTERM, &act_term, NULL) == -1) {
 230                         warn("sigaction");
 231                         goto exit;
 232                 }
 233                 if (sigaction(SIGCHLD, &act_chld, NULL) == -1) {
 234                         warn("sigaction");
 235                         goto exit;
 236                 }
 237                 /*
 238                  * Try to protect against pageout kill. Ignore the
 239                  * error, madvise(2) will fail only if a process does
 240                  * not have superuser privileges.
 241                  */
 242                 (void)madvise(NULL, 0, MADV_PROTECT);
 243                 logpar.outfd = outfd;
 244                 logpar.dosyslog = dosyslog;
 245                 logpar.logpri = logpri;
 246                 logpar.noclose = noclose;
 247 restart:
 248                 if (pipe(pfd))
 249                         err(1, "pipe");
 250                 /*
 251                  * Spawn a child to exec the command.
 252                  */
 253                 child_gone = 0;
 254                 pid = fork();
 255                 if (pid == -1) {
 256                         warn("fork");
 257                         goto exit;
 258                 } else if (pid > 0) {
 259                         /*
 260                          * Unblock SIGTERM after we know we have a valid
 261                          * child PID to signal.
 262                          */
 263                         if (sigprocmask(SIG_UNBLOCK, &mask_term, NULL)) {
 264                                 warn("sigprocmask");
 265                                 goto exit;
 266                         }
 267                         close(pfd[1]);
 268                         pfd[1] = -1;
 269                 }
 270         }
 271         if (pid <= 0) {
 272                 /* Now that we are the child, write out the pid. */
 273                 pidfile_write(pfh);
 274
 275                 if (user != NULL)
 276                         restrict_process(user);
 277                 /*
 278                  * When forking, the child gets the original sigmask,
 279                  * and dup'd pipes.
 280                  */
 281                 if (pid == 0) {
 282                         close(pfd[0]);
 283                         if (sigprocmask(SIG_SETMASK, &mask_orig, NULL))
 284                                 err(1, "sigprogmask");
 285                         if (stdmask & STDERR_FILENO) {
 286                                 if (dup2(pfd[1], STDERR_FILENO) == -1)
 287                                         err(1, "dup2");
 288                         }
 289                         if (stdmask & STDOUT_FILENO) {
 290                                 if (dup2(pfd[1], STDOUT_FILENO) == -1)
 291                                         err(1, "dup2");
 292                         }
 293                         if (pfd[1] != STDERR_FILENO &&
 294                             pfd[1] != STDOUT_FILENO)
 295                                 close(pfd[1]);
 296                 }
 297                 execvp(argv[0], argv);
 298                 /*
 299                  * execvp() failed -- report the error. The child is
 300                  * now running, so the exit status doesn't matter.
 301                  */
 302                 err(1, "%s", argv[0]);
 303         }
 304         setproctitle("%s[%d]", title, (int)pid);
 305         /*
 306          * As we have closed the write end of pipe for parent process,
 307          * we might detect the child's exit by reading EOF. The child
 308          * might have closed its stdout and stderr, so we must wait for
 309          * the SIGCHLD to ensure that the process is actually gone.
 310          */
 311         child_eof = 0;
 312         for (;;) {
 313                 /*
 314                  * We block SIGCHLD when listening, but SIGTERM we accept
 315                  * so the read() won't block if we wish to depart.
 316                  *
 317                  * Upon receiving SIGTERM, we have several options after
 318                  * sending the SIGTERM to our child:
 319                  * - read until EOF
 320                  * - read until EOF but only for a while
 321                  * - bail immediately
 322                  *
 323                  * We go for the third, as otherwise we have no guarantee
 324                  * that we won't block indefinitely if the child refuses
 325                  * to depart. To handle the second option, a different
 326                  * approach would be needed (procctl()?)
 327                  */
 328                 if (child_gone && child_eof) {
 329                         break;
 330                 } else if (terminate) {
 331                         goto exit;
 332                 } else if (!child_eof) {
 333                         if (sigprocmask(SIG_BLOCK, &mask_read, NULL)) {
 334                                 warn("sigprocmask");
 335                                 goto exit;
 336                         }
 337                         child_eof = !listen_child(pfd[0], &logpar);
 338                         if (sigprocmask(SIG_UNBLOCK, &mask_read, NULL)) {
 339                                 warn("sigprocmask");
 340                                 goto exit;
 341                         }
 342                 } else {
 343                         if (sigprocmask(SIG_BLOCK, &mask_susp, NULL)) {
 344                                 warn("sigprocmask");
 345                                 goto exit;
 346                         }
 347                         while (!terminate && !child_gone)
 348                                 sigsuspend(&mask_orig);
 349                         if (sigprocmask(SIG_UNBLOCK, &mask_susp, NULL)) {
 350                                 warn("sigprocmask");
 351                                 goto exit;
 352                         }
 353                 }
 354         }
 355         if (sigprocmask(SIG_BLOCK, &mask_term, NULL)) {
 356                 warn("sigprocmask");
 357                 goto exit;
 358         }
 359         if (restart && !terminate) {
 360                 daemon_sleep(1, 0);
 361                 close(pfd[0]);
 362                 pfd[0] = -1;
 363                 goto restart;
 364         }
 365 exit:
 366         close(outfd);
 367         close(pfd[0]);
 368         close(pfd[1]);
 369         if (dosyslog)
 370                 closelog();
 371         pidfile_remove(pfh);
 372         pidfile_remove(ppfh);
 373         exit(1); /* If daemon(3) succeeded exit status does not matter. */
 374 }
 375
 376 static void
 377 daemon_sleep(time_t secs, long nsecs)
 378 {
 379         struct timespec ts = { secs, nsecs };
 380         while (nanosleep(&ts, &ts) == -1) {
 381                 if (errno != EINTR)
 382                         err(1, "nanosleep");
 383         }
 384 }
 385
 386 static void
 387 open_pid_files(const char *pidfile, const char *ppidfile,
 388                struct pidfh **pfh, struct pidfh **ppfh)
 389 {
 390         pid_t fpid;
 391         int serrno;
 392
 393         if (pidfile) {
 394                 *pfh = pidfile_open(pidfile, 0600, &fpid);
 395                 if (*pfh == NULL) {
 396                         if (errno == EEXIST) {
 397                                 errx(3, "process already running, pid: %d",
 398                                     fpid);
 399                         }
 400                         err(2, "pidfile ``%s''", pidfile);
 401                 }
 402         }
 403         /* Do the same for the actual daemon process. */
 404         if (ppidfile) {
 405                 *ppfh = pidfile_open(ppidfile, 0600, &fpid);
 406                 if (*ppfh == NULL) {
 407                         serrno = errno;
 408                         pidfile_remove(*pfh);
 409                         errno = serrno;
 410                         if (errno == EEXIST) {
 411                                 errx(3, "process already running, pid: %d",
 412                                      fpid);
 413                         }
 414                         err(2, "ppidfile ``%s''", ppidfile);
 415                 }
 416         }
 417 }
 418
 419 static int
 420 get_log_mapping(const char *str, const CODE *c)
 421 {
 422         const CODE *cp;
 423         for (cp = c; cp->c_name; cp++)
 424                 if (strcmp(cp->c_name, str) == 0)
 425                         return cp->c_val;
 426         return -1;
 427 }
 428
 429 static void
 430 restrict_process(const char *user)
 431 {
 432         struct passwd *pw = NULL;
 433
 434         pw = getpwnam(user);
 435         if (pw == NULL)
 436                 errx(1, "unknown user: %s", user);
 437
 438         if (setusercontext(NULL, pw, pw->pw_uid, LOGIN_SETALL) != 0)
 439                 errx(1, "failed to set user environment");
 440 }
 441
 442 /*
 443  * We try to collect whole lines terminated by '\n'. Otherwise we collect a
 444  * full buffer, and then output it.
 445  *
 446  * Return value of 0 is assumed to mean EOF or error, and 1 indicates to
 447  * continue reading.
 448  */
 449 static int
 450 listen_child(int fd, struct log_params *logpar)
 451 {
 452         static unsigned char buf[LBUF_SIZE];
 453         static size_t bytes_read = 0;
 454         int rv;
 455
 456         assert(logpar);
 457         assert(bytes_read < LBUF_SIZE - 1);
 458
 459         rv = read(fd, buf + bytes_read, LBUF_SIZE - bytes_read - 1);
 460         if (rv > 0) {
 461                 unsigned char *cp;
 462
 463                 bytes_read += rv;
 464                 assert(bytes_read <= LBUF_SIZE - 1);
 465                 /* Always NUL-terminate just in case. */
 466                 buf[LBUF_SIZE - 1] = '\0';
 467                 /*
 468                  * Chomp line by line until we run out of buffer.
 469                  * This does not take NUL characters into account.
 470                  */
 471                 while ((cp = memchr(buf, '\n', bytes_read)) != NULL) {
 472                         size_t bytes_line = cp - buf + 1;
 473                         assert(bytes_line <= bytes_read);
 474                         do_output(buf, bytes_line, logpar);
 475                         bytes_read -= bytes_line;
 476                         memmove(buf, cp + 1, bytes_read);
 477                 }
 478                 /* Wait until the buffer is full. */
 479                 if (bytes_read < LBUF_SIZE - 1)
 480                         return 1;
 481                 do_output(buf, bytes_read, logpar);
 482                 bytes_read = 0;
 483                 return 1;
 484         } else if (rv == -1) {
 485                 /* EINTR should trigger another read. */
 486                 if (errno == EINTR) {
 487                         return 1;
 488                 } else {
 489                         warn("read");
 490                         return 0;
 491                 }
 492         }
 493         /* Upon EOF, we have to flush what's left of the buffer. */
 494         if (bytes_read > 0) {
 495                 do_output(buf, bytes_read, logpar);
 496                 bytes_read = 0;
 497         }
 498         return 0;
 499 }
 500
 501 /*
 502  * The default behavior is to stay silent if the user wants to redirect
 503  * output to a file and/or syslog. If neither are provided, then we bounce
 504  * everything back to parent's stdout.
 505  */
 506 static void
 507 do_output(const unsigned char *buf, size_t len, struct log_params *logpar)
 508 {
 509         assert(len <= LBUF_SIZE);
 510         assert(logpar);
 511
 512         if (len < 1)
 513                 return;
 514         if (logpar->dosyslog)
 515                 syslog(logpar->logpri, "%.*s", (int)len, buf);
 516         if (logpar->outfd != -1) {
 517                 if (write(logpar->outfd, buf, len) == -1)
 518                         warn("write");
 519         }
 520         if (logpar->noclose && !logpar->dosyslog && logpar->outfd == -1)
 521                 printf("%.*s", (int)len, buf);
 522 }
 523
 524 /*
 525  * We use the global PID acquired directly from fork. If there is no valid
 526  * child pid, the handler should be blocked and/or child_gone == 1.
 527  */
 528 static void
 529 handle_term(int signo)
 530 {
 531         if (pid > 0 && !child_gone)
 532                 kill(pid, signo);
 533         terminate = 1;
 534 }
 535
 536 static void
 537 handle_chld(int signo)
 538 {
 539         (void)signo;
 540         for (;;) {
 541                 int rv = waitpid(-1, NULL, WNOHANG);
 542                 if (pid == rv) {
 543                         child_gone = 1;
 544                         break;
 545                 } else if (rv == -1 && errno != EINTR) {
 546                         warn("waitpid");
 547                         return;
 548                 }
 549         }
 550 }
 551
 552 static void
 553 usage(void)
 554 {
 555         (void)fprintf(stderr,
 556             "usage: daemon [-cfrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
 557             "              [-u user] [-o output_file] [-t title]\n"
 558             "              [-l syslog_facility] [-s syslog_priority]\n"
 559             "              [-T syslog_tag] [-m output_mask]\n"
 560             "command arguments ...\n");
 561         exit(1);
 562 }