lib/roken/detach.c

   1 /*-
   2  * Copyright (c) 2015
   3  *      Cryptonector LLC.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Cryptonector LLC may not be used to endorse or promote products
  14  *    derived from this software without specific prior written
  15  *    permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <config.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #ifdef WIN32
  34 #include <io.h>
  35 #include <stdlib.h>
  36 #else
  37 #include <unistd.h>
  38 #endif
  39 #include "roken.h"
  40
  41 #ifdef WIN32
  42 #define dup2 _dup2
  43 #endif
  44
  45 static int pipefds[2] = {-1, -1};
  46
  47 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
  48 roken_detach_prep(int argc, char **argv, char *special_arg)
  49 {
  50     ssize_t bytes;
  51     size_t i;
  52     pid_t child;
  53     char **new_argv;
  54     char buf[1];
  55     char fildes[21];
  56     int status;
  57
  58     pipefds[0] = -1;
  59     pipefds[1] = -1;
  60
  61 #ifdef WIN32
  62     if (_pipe(pipefds, 4, _O_NOINHERIT | O_BINARY) == -1)
  63         err(1, "failed to setup to detach daemon (_pipe failed)");
  64 #else
  65     if (pipe(pipefds) == -1)
  66         err(1, "failed to setup to detach daemon (pipe failed)");
  67 #endif
  68
  69     new_argv = calloc(argc + 3, sizeof(*new_argv));
  70     if (new_argv == NULL)
  71         err(1, "Out of memory");
  72
  73 #ifdef WIN32
  74     pipefds[1] = _dup(pipefds[1]); /* The new fd will be inherited */
  75     if (pipefds[1] == -1)
  76         err(1, "Out of memory");
  77 #else
  78     (void) fcntl(pipefds[1], F_SETFD,
  79                  fcntl(pipefds[1], F_GETFD & ~(O_CLOEXEC)));
  80 #endif
  81
  82     if (snprintf(fildes, sizeof(fildes), "%d", pipefds[1]) >= sizeof(fildes))
  83         err(1, "failed to setup to detach daemon (fd number %d too large)",
  84             pipefds[1]);
  85
  86     new_argv[0] = argv[0];
  87     new_argv[1] = special_arg;
  88     new_argv[2] = fildes;
  89     for (i = 1; argv[i] != NULL; i++)
  90         new_argv[i + 2] = argv[i];
  91     new_argv[argc + 2] = NULL;
  92
  93 #ifndef WIN32
  94     fflush(stdout);
  95     child = fork();
  96 #else
  97     {
  98         intptr_t child_handle;
  99
 100         _flushall();
 101         child_handle = spawnvp(_P_NOWAIT, argv[0], new_argv);
 102         if (child_handle == -1)
 103           child = (pid_t)-1;
 104         else
 105           child = GetProcessId((HANDLE)child_handle);
 106     }
 107 #endif
 108     if (child == (pid_t)-1)
 109         err(1, "failed to setup to fork daemon (fork failed)");
 110
 111 #ifndef WIN32
 112     if (child == 0) {
 113         int fd;
 114
 115         (void) close(pipefds[0]);
 116         pipefds[0] = -1;
 117         /*
 118          * Keep stdout/stderr for now so output and errors prior to
 119          * detach_finish() can be seen by the user.
 120          */
 121         fd = open(_PATH_DEVNULL, O_RDWR, 0);
 122         if (fd == -1)
 123             err(1, "failed to open /dev/null");
 124         (void) dup2(fd, STDIN_FILENO);
 125         if (fd > STDERR_FILENO)
 126             (void) close(fd);
 127         if (getenv("ROKEN_DETACH_USE_EXEC")) {
 128             (void) execvp(argv[0], new_argv);
 129             err(1, "failed to self-re-exec");
 130         }
 131         free(new_argv);
 132         return pipefds[1];
 133     }
 134 #endif
 135
 136     /* Parent */
 137     free(new_argv);
 138     (void) close(pipefds[1]);
 139     pipefds[1] = -1;
 140     do {
 141         bytes = read(pipefds[0], buf, sizeof(buf));
 142     } while (bytes == -1 && errno == EINTR);
 143     (void) close(pipefds[0]);
 144     pipefds[0] = -1;
 145     if (bytes == -1) {
 146         /*
 147          * No need to wait for the process.  We've killed it.  If it
 148          * doesn't want to exit, we'd have to wait potentially forever,
 149          * but we want to indicate failure to the user as soon as
 150          * possible.  A wait with timeout would end the same way
 151          * (attempting to kill the process).
 152          */
 153         err(1, "failed to setup daemon child (read from child pipe)");
 154     }
 155     if (bytes == 0) {
 156         warnx("daemon child preparation failed, waiting for child");
 157         status = wait_for_process(child);
 158         if (SE_IS_ERROR(status) || SE_PROCSTATUS(status) != 0)
 159             errx(SE_PROCSTATUS(status),
 160                  "daemon child preparation failed (child exited)");
 161     }
 162     _exit(0);
 163     /* NOTREACHED */
 164     return -1;
 165 }
 166
 167 #ifdef WIN32
 168 #ifdef dup2
 169 #undef dup2
 170 #endif
 171 #define dup2 _dup2
 172 #endif
 173
 174 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 175 roken_detach_finish(const char *dir, int daemon_child_fd)
 176 {
 177     char buf[1] = "";
 178     ssize_t bytes;
 179     int fd;
 180
 181     rk_pidfile(NULL);
 182     if (pipefds[1] == -1 && daemon_child_fd != -1)
 183         pipefds[1] = daemon_child_fd;
 184     if (pipefds[0] != -1)
 185         (void) close(pipefds[0]);
 186     if (pipefds[1] == -1)
 187         return;
 188
 189 #ifdef HAVE_SETSID
 190     if (setsid() == -1)
 191         err(1, "failed to detach from tty");
 192 #endif
 193
 194 #ifndef WIN32
 195     /*
 196      * Hopefully we've written any pidfiles by now, if they had to be in
 197      * the current directory...
 198      *
 199      * The daemons do re-open logs and so on, therefore this chdir()
 200      * call needs to be optional for testing.
 201      */
 202     if (dir != NULL && chdir(dir) == -1)
 203         err(1, "failed to chdir to /");
 204 #endif
 205
 206     do {
 207         bytes = write(pipefds[1], buf, sizeof(buf));
 208     } while (bytes == -1 && errno == EINTR);
 209     if (bytes == -1)
 210         err(1, "failed to signal parent while detaching");
 211     (void) close(pipefds[1]);
 212     if (bytes != sizeof(buf))
 213         errx(1, "failed to signal parent while detaching");
 214
 215     fd = open(_PATH_DEVNULL, O_RDWR, 0);
 216     if (fd == -1)
 217         err(1, "failed to open /dev/null");
 218     /*
 219      * Maybe we should check that our output got written, if redirected
 220      * to a file.  File utils normally do this.
 221      */
 222     (void) dup2(fd, STDOUT_FILENO);
 223     (void) dup2(fd, STDERR_FILENO);
 224     if (fd > 2)
 225         (void) close(fd);
 226 }