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