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