usr.sbin/daemon/daemon.c

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