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