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 <getopt.h>
  44 #include <libutil.h>
  45 #include <login_cap.h>
  46 #include <paths.h>
  47 #include <pwd.h>
  48 #include <signal.h>
  49 #include <stdio.h>
  50 #include <stdbool.h>
  51 #include <stdlib.h>
  52 #include <unistd.h>
  53 #include <string.h>
  54 #include <strings.h>
  55 #define SYSLOG_NAMES
  56 #include <syslog.h>
  57 #include <time.h>
  58 #include <assert.h>
  59
  60 #define LBUF_SIZE 4096
  61
  62 struct daemon_state {
  63         int pipe_fd[2];
  64         const char *child_pidfile;
  65         const char *parent_pidfile;
  66         const char *output_filename;
  67         const char *syslog_tag;
  68         const char *title;
  69         const char *user;
  70         struct pidfh *parent_pidfh;
  71         struct pidfh *child_pidfh;
  72         int keep_cur_workdir;
  73         int restart_delay;
  74         int stdmask;
  75         int syslog_priority;
  76         int syslog_facility;
  77         int keep_fds_open;
  78         int output_fd;
  79         bool supervision_enabled;
  80         bool child_eof;
  81         bool restart_enabled;
  82         bool syslog_enabled;
  83         bool log_reopen;
  84 };
  85
  86 static void restrict_process(const char *);
  87 static void handle_term(int);
  88 static void handle_chld(int);
  89 static void handle_hup(int);
  90 static int  open_log(const char *);
  91 static void reopen_log(struct daemon_state *);
  92 static bool listen_child(int, struct daemon_state *);
  93 static int  get_log_mapping(const char *, const CODE *);
  94 static void open_pid_files(struct daemon_state *);
  95 static void do_output(const unsigned char *, size_t, struct daemon_state *);
  96 static void daemon_sleep(time_t, long);
  97 static void daemon_state_init(struct daemon_state *);
  98 static void daemon_terminate(struct daemon_state *);
  99
 100 static volatile sig_atomic_t terminate = 0;
 101 static volatile sig_atomic_t child_gone = 0;
 102 static volatile sig_atomic_t pid = 0;
 103 static volatile sig_atomic_t do_log_reopen = 0;
 104
 105 static const char shortopts[] = "+cfHSp:P:ru:o:s:l:t:m:R:T:h";
 106
 107 static const struct option longopts[] = {
 108         { "change-dir",         no_argument,            NULL,           'c' },
 109         { "close-fds",          no_argument,            NULL,           'f' },
 110         { "sighup",             no_argument,            NULL,           'H' },
 111         { "syslog",             no_argument,            NULL,           'S' },
 112         { "output-file",        required_argument,      NULL,           'o' },
 113         { "output-mask",        required_argument,      NULL,           'm' },
 114         { "child-pidfile",      required_argument,      NULL,           'p' },
 115         { "supervisor-pidfile", required_argument,      NULL,           'P' },
 116         { "restart",            no_argument,            NULL,           'r' },
 117         { "restart-delay",      required_argument,      NULL,           'R' },
 118         { "title",              required_argument,      NULL,           't' },
 119         { "user",               required_argument,      NULL,           'u' },
 120         { "syslog-priority",    required_argument,      NULL,           's' },
 121         { "syslog-facility",    required_argument,      NULL,           'l' },
 122         { "syslog-tag",         required_argument,      NULL,           'T' },
 123         { "help",               no_argument,            NULL,           'h' },
 124         { NULL,                 0,                      NULL,            0  }
 125 };
 126
 127 static _Noreturn void
 128 usage(int exitcode)
 129 {
 130         (void)fprintf(stderr,
 131             "usage: daemon [-cfHrS] [-p child_pidfile] [-P supervisor_pidfile]\n"
 132             "              [-u user] [-o output_file] [-t title]\n"
 133             "              [-l syslog_facility] [-s syslog_priority]\n"
 134             "              [-T syslog_tag] [-m output_mask] [-R restart_delay_secs]\n"
 135             "command arguments ...\n");
 136
 137         (void)fprintf(stderr,
 138             "  --change-dir         -c         Change the current working directory to root\n"
 139             "  --close-fds          -f         Set stdin, stdout, stderr to /dev/null\n"
 140             "  --sighup             -H         Close and re-open output file on SIGHUP\n"
 141             "  --syslog             -S         Send output to syslog\n"
 142             "  --output-file        -o <file>  Append output of the child process to file\n"
 143             "  --output-mask        -m <mask>  What to send to syslog/file\n"
 144             "                                  1=stdout, 2=stderr, 3=both\n"
 145             "  --child-pidfile      -p <file>  Write PID of the child process to file\n"
 146             "  --supervisor-pidfile -P <file>  Write PID of the supervisor process to file\n"
 147             "  --restart            -r         Restart child if it terminates (1 sec delay)\n"
 148             "  --restart-delay      -R <N>     Restart child if it terminates after N sec\n"
 149             "  --title              -t <title> Set the title of the supervisor process\n"
 150             "  --user               -u <user>  Drop privileges, run as given user\n"
 151             "  --syslog-priority    -s <prio>  Set syslog priority\n"
 152             "  --syslog-facility    -l <flty>  Set syslog facility\n"
 153             "  --syslog-tag         -T <tag>   Set syslog tag\n"
 154             "  --help               -h         Show this help\n");
 155
 156         exit(exitcode);
 157 }
 158
 159 int
 160 main(int argc, char *argv[])
 161 {
 162         char *p = NULL;
 163         int ch = 0;
 164         struct daemon_state state;
 165         sigset_t mask_orig;
 166         sigset_t mask_read;
 167         sigset_t mask_term;
 168         sigset_t mask_susp;
 169
 170         daemon_state_init(&state);
 171         sigemptyset(&mask_susp);
 172         sigemptyset(&mask_read);
 173         sigemptyset(&mask_term);
 174         sigemptyset(&mask_orig);
 175
 176         /*
 177          * Supervision mode is enabled if one of the following options are used:
 178          * --child-pidfile -p
 179          * --supervisor-pidfile -P
 180          * --restart -r / --restart-delay -R
 181          * --syslog -S
 182          * --syslog-facility -l
 183          * --syslog-priority -s
 184          * --syslog-tag -T
 185          *
 186          * In supervision mode daemon executes the command in a forked process
 187          * and observes the child by waiting for SIGCHILD. In supervision mode
 188          * daemon must never exit before the child, this is necessary  to prevent
 189          * orphaning the child and leaving a stale pid file.
 190          * To achieve this daemon catches SIGTERM and
 191          * forwards it to the child, expecting to get SIGCHLD eventually.
 192          */
 193         while ((ch = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
 194                 switch (ch) {
 195                 case 'c':
 196                         state.keep_cur_workdir = 0;
 197                         break;
 198                 case 'f':
 199                         state.keep_fds_open = 0;
 200                         break;
 201                 case 'H':
 202                         state.log_reopen = true;
 203                         break;
 204                 case 'l':
 205                         state.syslog_facility = get_log_mapping(optarg,
 206                             facilitynames);
 207                         if (state.syslog_facility == -1) {
 208                                 errx(5, "unrecognized syslog facility");
 209                         }
 210                         state.syslog_enabled = true;
 211                         state.supervision_enabled = true;
 212                         break;
 213                 case 'm':
 214                         state.stdmask = strtol(optarg, &p, 10);
 215                         if (p == optarg || state.stdmask < 0 || state.stdmask > 3) {
 216                                 errx(6, "unrecognized listening mask");
 217                         }
 218                         break;
 219                 case 'o':
 220                         state.output_filename = optarg;
 221                         /*
 222                          * TODO: setting output filename doesn't have to turn
 223                          * the supervision mode on. For non-supervised mode
 224                          * daemon could open the specified file and set it's
 225                          * descriptor as both stderr and stout before execve()
 226                          */
 227                         state.supervision_enabled = true;
 228                         break;
 229                 case 'p':
 230                         state.child_pidfile = optarg;
 231                         state.supervision_enabled = true;
 232                         break;
 233                 case 'P':
 234                         state.parent_pidfile = optarg;
 235                         state.supervision_enabled = true;
 236                         break;
 237                 case 'r':
 238                         state.restart_enabled = true;
 239                         state.supervision_enabled = true;
 240                         break;
 241                 case 'R':
 242                         state.restart_enabled = true;
 243                         state.restart_delay = strtol(optarg, &p, 0);
 244                         if (p == optarg || state.restart_delay < 1) {
 245                                 errx(6, "invalid restart delay");
 246                         }
 247                         break;
 248                 case 's':
 249                         state.syslog_priority = get_log_mapping(optarg,
 250                             prioritynames);
 251                         if (state.syslog_priority == -1) {
 252                                 errx(4, "unrecognized syslog priority");
 253                         }
 254                         state.syslog_enabled = true;
 255                         state.supervision_enabled = true;
 256                         break;
 257                 case 'S':
 258                         state.syslog_enabled = true;
 259                         state.supervision_enabled = true;
 260                         break;
 261                 case 't':
 262                         state.title = optarg;
 263                         break;
 264                 case 'T':
 265                         state.syslog_tag = optarg;
 266                         state.syslog_enabled = true;
 267                         state.supervision_enabled = true;
 268                         break;
 269                 case 'u':
 270                         state.user = optarg;
 271                         break;
 272                 case 'h':
 273                         usage(0);
 274                         __builtin_unreachable();
 275                 default:
 276                         usage(1);
 277                 }
 278         }
 279         argc -= optind;
 280         argv += optind;
 281
 282         if (argc == 0) {
 283                 usage(1);
 284         }
 285
 286         if (!state.title) {
 287                 state.title = argv[0];
 288         }
 289
 290         if (state.output_filename) {
 291                 state.output_fd = open_log(state.output_filename);
 292                 if (state.output_fd == -1) {
 293                         err(7, "open");
 294                 }
 295         }
 296
 297         if (state.syslog_enabled) {
 298                 openlog(state.syslog_tag, LOG_PID | LOG_NDELAY,
 299                     state.syslog_facility);
 300         }
 301
 302         /*
 303          * Try to open the pidfile before calling daemon(3),
 304          * to be able to report the error intelligently
 305          */
 306         open_pid_files(&state);
 307         if (daemon(state.keep_cur_workdir, state.keep_fds_open) == -1) {
 308                 warn("daemon");
 309                 daemon_terminate(&state);
 310         }
 311         /* Write out parent pidfile if needed. */
 312         pidfile_write(state.parent_pidfh);
 313
 314         if (state.supervision_enabled) {
 315                 struct sigaction act_term = { 0 };
 316                 struct sigaction act_chld = { 0 };
 317                 struct sigaction act_hup = { 0 };
 318
 319                 /* Avoid PID racing with SIGCHLD and SIGTERM. */
 320                 act_term.sa_handler = handle_term;
 321                 sigemptyset(&act_term.sa_mask);
 322                 sigaddset(&act_term.sa_mask, SIGCHLD);
 323
 324                 act_chld.sa_handler = handle_chld;
 325                 sigemptyset(&act_chld.sa_mask);
 326                 sigaddset(&act_chld.sa_mask, SIGTERM);
 327
 328                 act_hup.sa_handler = handle_hup;
 329                 sigemptyset(&act_hup.sa_mask);
 330
 331                 /* Block these when avoiding racing before sigsuspend(). */
 332                 sigaddset(&mask_susp, SIGTERM);
 333                 sigaddset(&mask_susp, SIGCHLD);
 334                 /* Block SIGTERM when we lack a valid child PID. */
 335                 sigaddset(&mask_term, SIGTERM);
 336                 /*
 337                  * When reading, we wish to avoid SIGCHLD. SIGTERM
 338                  * has to be caught, otherwise we'll be stuck until
 339                  * the read() returns - if it returns.
 340                  */
 341                 sigaddset(&mask_read, SIGCHLD);
 342                 /* Block SIGTERM to avoid racing until we have forked. */
 343                 if (sigprocmask(SIG_BLOCK, &mask_term, &mask_orig)) {
 344                         warn("sigprocmask");
 345                         daemon_terminate(&state);
 346                 }
 347                 if (sigaction(SIGTERM, &act_term, NULL) == -1) {
 348                         warn("sigaction");
 349                         daemon_terminate(&state);
 350                 }
 351                 if (sigaction(SIGCHLD, &act_chld, NULL) == -1) {
 352                         warn("sigaction");
 353                         daemon_terminate(&state);
 354                 }
 355                 /*
 356                  * Try to protect against pageout kill. Ignore the
 357                  * error, madvise(2) will fail only if a process does
 358                  * not have superuser privileges.
 359                  */
 360                 (void)madvise(NULL, 0, MADV_PROTECT);
 361                 if (state.log_reopen && state.output_fd >= 0 &&
 362                     sigaction(SIGHUP, &act_hup, NULL) == -1) {
 363                         warn("sigaction");
 364                         daemon_terminate(&state);
 365                 }
 366 restart:
 367                 if (pipe(state.pipe_fd)) {
 368                         err(1, "pipe");
 369                 }
 370                 /*
 371                  * Spawn a child to exec the command.
 372                  */
 373                 child_gone = 0;
 374                 pid = fork();
 375         }
 376
 377         /* fork failed, this can only happen when supervision is enabled */
 378         if (pid == -1) {
 379                 warn("fork");
 380                 daemon_terminate(&state);
 381         }
 382
 383         /* fork succeeded, this is child's branch or supervision is disabled */
 384         if (pid == 0) {
 385                 pidfile_write(state.child_pidfh);
 386
 387                 if (state.user != NULL) {
 388                         restrict_process(state.user);
 389                 }
 390                 /*
 391                  * In supervision mode, the child gets the original sigmask,
 392                  * and dup'd pipes.
 393                  */
 394                 if (state.supervision_enabled) {
 395                         close(state.pipe_fd[0]);
 396                         if (sigprocmask(SIG_SETMASK, &mask_orig, NULL)) {
 397                                 err(1, "sigprogmask");
 398                         }
 399                         if (state.stdmask & STDERR_FILENO) {
 400                                 if (dup2(state.pipe_fd[1], STDERR_FILENO) == -1) {
 401                                         err(1, "dup2");
 402                                 }
 403                         }
 404                         if (state.stdmask & STDOUT_FILENO) {
 405                                 if (dup2(state.pipe_fd[1], STDOUT_FILENO) == -1) {
 406                                         err(1, "dup2");
 407                                 }
 408                         }
 409                         if (state.pipe_fd[1] != STDERR_FILENO &&
 410                             state.pipe_fd[1] != STDOUT_FILENO) {
 411                                 close(state.pipe_fd[1]);
 412                         }
 413                 }
 414                 execvp(argv[0], argv);
 415                 /* execvp() failed - report error and exit this process */
 416                 err(1, "%s", argv[0]);
 417         }
 418
 419         /*
 420          * else: pid > 0
 421          * fork succeeded, this is the parent branch, this can only happen when
 422          * supervision is enabled
 423          *
 424          * Unblock SIGTERM after we know we have a valid child PID to signal.
 425          */
 426         if (sigprocmask(SIG_UNBLOCK, &mask_term, NULL)) {
 427                 warn("sigprocmask");
 428                 daemon_terminate(&state);
 429         }
 430         close(state.pipe_fd[1]);
 431         state.pipe_fd[1] = -1;
 432
 433         setproctitle("%s[%d]", state.title, (int)pid);
 434         /*
 435          * As we have closed the write end of pipe for parent process,
 436          * we might detect the child's exit by reading EOF. The child
 437          * might have closed its stdout and stderr, so we must wait for
 438          * the SIGCHLD to ensure that the process is actually gone.
 439          */
 440         for (;;) {
 441                 /*
 442                  * We block SIGCHLD when listening, but SIGTERM we accept
 443                  * so the read() won't block if we wish to depart.
 444                  *
 445                  * Upon receiving SIGTERM, we have several options after
 446                  * sending the SIGTERM to our child:
 447                  * - read until EOF
 448                  * - read until EOF but only for a while
 449                  * - bail immediately
 450                  *
 451                  * We go for the third, as otherwise we have no guarantee
 452                  * that we won't block indefinitely if the child refuses
 453                  * to depart. To handle the second option, a different
 454                  * approach would be needed (procctl()?)
 455                  */
 456                 if (child_gone && state.child_eof) {
 457                         break;
 458                 }
 459
 460                 if (terminate) {
 461                         daemon_terminate(&state);
 462                 }
 463
 464                 if (state.child_eof) {
 465                         if (sigprocmask(SIG_BLOCK, &mask_susp, NULL)) {
 466                                 warn("sigprocmask");
 467                                 daemon_terminate(&state);
 468                         }
 469                         while (!terminate && !child_gone) {
 470                                 sigsuspend(&mask_orig);
 471                         }
 472                         if (sigprocmask(SIG_UNBLOCK, &mask_susp, NULL)) {
 473                                 warn("sigprocmask");
 474                                 daemon_terminate(&state);
 475                         }
 476                         continue;
 477                 }
 478
 479                 if (sigprocmask(SIG_BLOCK, &mask_read, NULL)) {
 480                         warn("sigprocmask");
 481                         daemon_terminate(&state);
 482                 }
 483
 484                 state.child_eof = !listen_child(state.pipe_fd[0], &state);
 485
 486                 if (sigprocmask(SIG_UNBLOCK, &mask_read, NULL)) {
 487                         warn("sigprocmask");
 488                         daemon_terminate(&state);
 489                 }
 490
 491         }
 492         if (state.restart_enabled && !terminate) {
 493                 daemon_sleep(state.restart_delay, 0);
 494         }
 495         if (sigprocmask(SIG_BLOCK, &mask_term, NULL)) {
 496                 warn("sigprocmask");
 497                 daemon_terminate(&state);
 498         }
 499         if (state.restart_enabled && !terminate) {
 500                 close(state.pipe_fd[0]);
 501                 state.pipe_fd[0] = -1;
 502                 goto restart;
 503         }
 504         daemon_terminate(&state);
 505 }
 506
 507 static void
 508 daemon_sleep(time_t secs, long nsecs)
 509 {
 510         struct timespec ts = { secs, nsecs };
 511
 512         while (!terminate && nanosleep(&ts, &ts) == -1) {
 513                 if (errno != EINTR) {
 514                         err(1, "nanosleep");
 515                 }
 516         }
 517 }
 518
 519 static void
 520 open_pid_files(struct daemon_state *state)
 521 {
 522         pid_t fpid;
 523         int serrno;
 524
 525         if (state->child_pidfile) {
 526                 state->child_pidfh = pidfile_open(state->child_pidfile, 0600, &fpid);
 527                 if (state->child_pidfh == NULL) {
 528                         if (errno == EEXIST) {
 529                                 errx(3, "process already running, pid: %d",
 530                                     fpid);
 531                         }
 532                         err(2, "pidfile ``%s''", state->child_pidfile);
 533                 }
 534         }
 535         /* Do the same for the actual daemon process. */
 536         if (state->parent_pidfile) {
 537                 state->parent_pidfh= pidfile_open(state->parent_pidfile, 0600, &fpid);
 538                 if (state->parent_pidfh == NULL) {
 539                         serrno = errno;
 540                         pidfile_remove(state->child_pidfh);
 541                         errno = serrno;
 542                         if (errno == EEXIST) {
 543                                 errx(3, "process already running, pid: %d",
 544                                      fpid);
 545                         }
 546                         err(2, "ppidfile ``%s''", state->parent_pidfile);
 547                 }
 548         }
 549 }
 550
 551 static int
 552 get_log_mapping(const char *str, const CODE *c)
 553 {
 554         const CODE *cp;
 555         for (cp = c; cp->c_name; cp++)
 556                 if (strcmp(cp->c_name, str) == 0) {
 557                         return cp->c_val;
 558                 }
 559         return -1;
 560 }
 561
 562 static void
 563 restrict_process(const char *user)
 564 {
 565         struct passwd *pw = NULL;
 566
 567         pw = getpwnam(user);
 568         if (pw == NULL) {
 569                 errx(1, "unknown user: %s", user);
 570         }
 571
 572         if (setusercontext(NULL, pw, pw->pw_uid, LOGIN_SETALL) != 0) {
 573                 errx(1, "failed to set user environment");
 574         }
 575
 576         setenv("USER", pw->pw_name, 1);
 577         setenv("HOME", pw->pw_dir, 1);
 578         setenv("SHELL", *pw->pw_shell ? pw->pw_shell : _PATH_BSHELL, 1);
 579 }
 580
 581 /*
 582  * We try to collect whole lines terminated by '\n'. Otherwise we collect a
 583  * full buffer, and then output it.
 584  *
 585  * Return value of false is assumed to mean EOF or error, and true indicates to
 586  * continue reading.
 587  */
 588 static bool
 589 listen_child(int fd, struct daemon_state *state)
 590 {
 591         static unsigned char buf[LBUF_SIZE];
 592         static size_t bytes_read = 0;
 593         int rv;
 594
 595         assert(state != NULL);
 596         assert(bytes_read < LBUF_SIZE - 1);
 597
 598         if (do_log_reopen) {
 599                 reopen_log(state);
 600         }
 601         rv = read(fd, buf + bytes_read, LBUF_SIZE - bytes_read - 1);
 602         if (rv > 0) {
 603                 unsigned char *cp;
 604
 605                 bytes_read += rv;
 606                 assert(bytes_read <= LBUF_SIZE - 1);
 607                 /* Always NUL-terminate just in case. */
 608                 buf[LBUF_SIZE - 1] = '\0';
 609                 /*
 610                  * Chomp line by line until we run out of buffer.
 611                  * This does not take NUL characters into account.
 612                  */
 613                 while ((cp = memchr(buf, '\n', bytes_read)) != NULL) {
 614                         size_t bytes_line = cp - buf + 1;
 615                         assert(bytes_line <= bytes_read);
 616                         do_output(buf, bytes_line, state);
 617                         bytes_read -= bytes_line;
 618                         memmove(buf, cp + 1, bytes_read);
 619                 }
 620                 /* Wait until the buffer is full. */
 621                 if (bytes_read < LBUF_SIZE - 1) {
 622                         return true;
 623                 }
 624                 do_output(buf, bytes_read, state);
 625                 bytes_read = 0;
 626                 return true;
 627         } else if (rv == -1) {
 628                 /* EINTR should trigger another read. */
 629                 if (errno == EINTR) {
 630                         return true;
 631                 } else {
 632                         warn("read");
 633                         return false;
 634                 }
 635         }
 636         /* Upon EOF, we have to flush what's left of the buffer. */
 637         if (bytes_read > 0) {
 638                 do_output(buf, bytes_read, state);
 639                 bytes_read = 0;
 640         }
 641         return false;
 642 }
 643
 644 /*
 645  * The default behavior is to stay silent if the user wants to redirect
 646  * output to a file and/or syslog. If neither are provided, then we bounce
 647  * everything back to parent's stdout.
 648  */
 649 static void
 650 do_output(const unsigned char *buf, size_t len, struct daemon_state *state)
 651 {
 652         assert(len <= LBUF_SIZE);
 653         assert(state != NULL);
 654
 655         if (len < 1) {
 656                 return;
 657         }
 658         if (state->syslog_enabled) {
 659                 syslog(state->syslog_priority, "%.*s", (int)len, buf);
 660         }
 661         if (state->output_fd != -1) {
 662                 if (write(state->output_fd, buf, len) == -1)
 663                         warn("write");
 664         }
 665         if (state->keep_fds_open &&
 666             !state->syslog_enabled &&
 667             state->output_fd == -1) {
 668                 printf("%.*s", (int)len, buf);
 669         }
 670 }
 671
 672 /*
 673  * We use the global PID acquired directly from fork. If there is no valid
 674  * child pid, the handler should be blocked and/or child_gone == 1.
 675  */
 676 static void
 677 handle_term(int signo)
 678 {
 679         if (pid > 0 && !child_gone) {
 680                 kill(pid, signo);
 681         }
 682         terminate = 1;
 683 }
 684
 685 static void
 686 handle_chld(int signo __unused)
 687 {
 688
 689         for (;;) {
 690                 int rv = waitpid(-1, NULL, WNOHANG);
 691                 if (pid == rv) {
 692                         child_gone = 1;
 693                         break;
 694                 } else if (rv == -1 && errno != EINTR) {
 695                         warn("waitpid");
 696                         return;
 697                 }
 698         }
 699 }
 700
 701 static void
 702 handle_hup(int signo __unused)
 703 {
 704
 705         do_log_reopen = 1;
 706 }
 707
 708 static int
 709 open_log(const char *outfn)
 710 {
 711
 712         return open(outfn, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0600);
 713 }
 714
 715 static void
 716 reopen_log(struct daemon_state *state)
 717 {
 718         int outfd;
 719
 720         do_log_reopen = 0;
 721         outfd = open_log(state->output_filename);
 722         if (state->output_fd >= 0) {
 723                 close(state->output_fd);
 724         }
 725         state->output_fd = outfd;
 726 }
 727
 728 static void
 729 daemon_state_init(struct daemon_state *state)
 730 {
 731         *state = (struct daemon_state) {
 732                 .pipe_fd = { -1, -1 },
 733                 .parent_pidfh = NULL,
 734                 .child_pidfh = NULL,
 735                 .child_pidfile = NULL,
 736                 .parent_pidfile = NULL,
 737                 .title = NULL,
 738                 .user = NULL,
 739                 .supervision_enabled = false,
 740                 .child_eof = false,
 741                 .restart_enabled = false,
 742                 .keep_cur_workdir = 1,
 743                 .restart_delay = 1,
 744                 .stdmask = STDOUT_FILENO | STDERR_FILENO,
 745                 .syslog_enabled = false,
 746                 .log_reopen = false,
 747                 .syslog_priority = LOG_NOTICE,
 748                 .syslog_tag = "daemon",
 749                 .syslog_facility = LOG_DAEMON,
 750                 .keep_fds_open = 1,
 751                 .output_fd = -1,
 752                 .output_filename = NULL,
 753         };
 754 }
 755
 756 static _Noreturn void
 757 daemon_terminate(struct daemon_state *state)
 758 {
 759         assert(state != NULL);
 760         close(state->output_fd);
 761         close(state->pipe_fd[0]);
 762         close(state->pipe_fd[1]);
 763         if (state->syslog_enabled) {
 764                 closelog();
 765         }
 766         pidfile_remove(state->child_pidfh);
 767         pidfile_remove(state->parent_pidfh);
 768
 769         /*
 770          * Note that the exit value here doesn't matter in the case of a clean
 771          * exit; daemon(3) already detached us from the caller, nothing is left
 772          * to care about this one.
 773          */
 774         exit(1);
 775 }