librt/spawn.c

   1 /* Copyright (C) 2000, 2011 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <errno.h>
  19 #include <alloca.h>
  20 #include <unistd.h>
  21 #include <signal.h>
  22 #include <stdbool.h>
  23 #include <sys/syscall.h>
  24 #include <fcntl.h>
  25
  26 #include <sys/resource.h>
  27 #include <not-cancel.h>
  28 #include <internal-signals.h>
  29
  30 #include <spawn.h>
  31 #include "spawn_int.h"
  32
  33 /* The Unix standard contains a long explanation of the way to signal
  34    an error after the fork() was successful.  Since no new wait status
  35    was wanted there is no way to signal an error using one of the
  36    available methods.  The committee chose to signal an error by a
  37    normal program exit with the exit code 127.  */
  38 #define SPAWN_ERROR     127
  39
  40 /* Execute file actions.
  41  * Returns true on error.
  42  */
  43 inline static bool execute_file_actions(const posix_spawn_file_actions_t *fa)
  44 {
  45         struct rlimit64 fdlimit;
  46         bool have_fdlimit = false;
  47         int cnt;
  48
  49         for (cnt = 0; cnt < fa->__used; ++cnt) {
  50                 struct __spawn_action *action = &fa->__actions[cnt];
  51
  52                 switch (action->tag) {
  53                 case spawn_do_close:
  54                         if (close_not_cancel(action->action.close_action.fd) != 0) {
  55                                 if (!have_fdlimit) {
  56                                         getrlimit64(RLIMIT_NOFILE, &fdlimit);
  57                                         have_fdlimit = true;
  58                                 }
  59
  60                                 /* Only signal errors for file descriptors out of range.  */
  61                                 if (0 > action->action.close_action.fd
  62                                     || action->action.close_action.fd >= fdlimit.rlim_cur)
  63                                         /* Signal the error.  */
  64                                         return true;
  65                         }
  66                         break;
  67
  68                 case spawn_do_open:;
  69                         int new_fd = open_not_cancel(action->action.open_action.path,
  70                                                      action->action.open_action.oflag
  71                                                      | O_LARGEFILE,
  72                                                      action->action.open_action.mode);
  73
  74                         if (new_fd == -1)
  75                                 return true;
  76
  77                         /* Make sure the desired file descriptor is used.  */
  78                         if (new_fd != action->action.open_action.fd) {
  79                                 if (dup2(new_fd, action->action.open_action.fd)
  80                                     != action->action.open_action.fd)
  81                                         return true;
  82
  83                                 if (close_not_cancel(new_fd) != 0)
  84                                         return true;
  85                         }
  86                         break;
  87
  88                 case spawn_do_dup2:
  89                         if (dup2(action->action.dup2_action.fd,
  90                                    action->action.dup2_action.newfd)
  91                             != action->action.dup2_action.newfd)
  92                                 return true;
  93                         break;
  94                 }
  95         }
  96
  97         return false;
  98 }
  99
 100 #define DANGEROUS (POSIX_SPAWN_SETSIGMASK               \
 101                    | POSIX_SPAWN_SETSIGDEF              \
 102                    | POSIX_SPAWN_SETSCHEDPARAM          \
 103                    | POSIX_SPAWN_SETSCHEDULER           \
 104                    | POSIX_SPAWN_SETPGROUP              \
 105                    | POSIX_SPAWN_RESETIDS)
 106 inline static bool is_vfork_safe(short int flags)
 107 {
 108         return ((flags & POSIX_SPAWN_USEVFORK) || !(flags & DANGEROUS));
 109 }
 110
 111
 112 /* Spawn a new process executing PATH with the attributes describes in *ATTRP.
 113    Before running the process perform the actions described in FILE-ACTIONS. */
 114 static int
 115 __spawni(pid_t *pid, const char *file,
 116          const posix_spawn_file_actions_t *fa,
 117          const posix_spawnattr_t *attrp, char *const argv[],
 118          char *const envp[], const char *path)
 119 {
 120         short int flags = attrp ? attrp->__flags : 0;
 121
 122         pid_t new_pid;
 123         if (is_vfork_safe(flags) && !fa)
 124                 new_pid = vfork();
 125         else {
 126 #ifdef __ARCH_USE_MMU__
 127                 new_pid = fork();
 128 #else
 129                 return ENOSYS;
 130 #endif
 131         }
 132
 133         if (new_pid) {
 134                 if (new_pid < 0)
 135                         return errno;
 136
 137                 if (pid)
 138                         *pid = new_pid;
 139
 140                 return 0;
 141         }
 142
 143         if (flags & POSIX_SPAWN_SETSIGMASK) {
 144                 if (sigprocmask(SIG_SETMASK, &attrp->__ss, NULL) != 0)
 145                         goto error;
 146         }
 147
 148         if (flags & POSIX_SPAWN_SETSIGDEF) {
 149                 /* We have to iterate over all signals.  This could possibly be
 150                    done better but it requires system specific solutions since
 151                    the sigset_t data type can be very different on different
 152                    architectures.  */
 153                 struct sigaction sa;
 154                 int sig;
 155
 156                 memset(&sa, 0, sizeof(sa));
 157
 158                 sigset_t hset;
 159                 sigprocmask (SIG_BLOCK, 0, &hset);
 160
 161                 for (int sig = 1; sig < _NSIG; ++sig) {
 162                   if ((flags & POSIX_SPAWN_SETSIGDEF)
 163                   && sigismember (&attrp->__sd, sig))
 164                   {
 165                     sa.sa_handler = SIG_DFL;
 166                   }
 167                   else if (sigismember (&hset, sig))
 168                   {
 169                     if (__is_internal_signal (sig))
 170                       sa.sa_handler = SIG_IGN;
 171                     else
 172                     {
 173                       __libc_sigaction (sig, 0, &sa);
 174                       if (sa.sa_handler == SIG_IGN)
 175                         continue;
 176                       sa.sa_handler = SIG_DFL;
 177                     }
 178                   }
 179                 else
 180                   continue;
 181
 182                 __libc_sigaction (sig, &sa, 0);
 183                 }
 184         }
 185
 186         if (flags & POSIX_SPAWN_SETSCHEDULER) {
 187                 if (sched_setscheduler(0, attrp->__policy, &attrp->__sp) == -1)
 188                         goto error;
 189         } else if (flags & POSIX_SPAWN_SETSCHEDPARAM) {
 190                 if (sched_setparam(0, &attrp->__sp) == -1)
 191                         goto error;
 192         }
 193
 194         if (flags & POSIX_SPAWN_SETPGROUP) {
 195                 if (setpgid(0, attrp->__pgrp) != 0)
 196                         goto error;
 197         }
 198
 199         if (flags & POSIX_SPAWN_RESETIDS) {
 200                 if (seteuid(getuid()) || setegid(getgid()))
 201                         goto error;
 202         }
 203
 204         if (fa && execute_file_actions(fa))
 205                 goto error;
 206
 207         if (!path || strchr(file, '/')) {
 208                 execve(file, argv, envp);
 209                 goto error;
 210         }
 211
 212
 213         char *name;
 214         {
 215                 size_t filelen = strlen(file) + 1;
 216                 size_t pathlen = strlen(path) + 1;
 217                 name = alloca(pathlen + filelen);
 218
 219                 /* Copy the file name at the top. */
 220                 name = (char *) memcpy(name + pathlen, file, filelen);
 221
 222                 /* And add the slash.  */
 223                 *--name = '/';
 224         }
 225
 226         char *p = (char *)path;
 227         do {
 228                 char *startp;
 229                 path = p;
 230                 p = strchrnul(path, ':');
 231
 232                 /* Two adjacent colons, or a colon at the beginning or the end
 233                    of `PATH' means to search the current directory.  */
 234                 if (p == path)
 235                         startp = name + 1;
 236                 else
 237                         startp = (char *) memcpy(name - (p - path), path, p - path);
 238
 239                 execve(startp, argv, envp);
 240
 241                 switch (errno) {
 242                 case EACCES:
 243                 case ENOENT:
 244                 case ESTALE:
 245                 case ENOTDIR:
 246                         /* Those errors indicate the file is missing or not
 247                            executable by us, in which case we want to just try
 248                            the next path directory. */
 249                         break;
 250                 default:
 251                         /* Some other error means we found an executable file,
 252                            but something went wrong executing it; return the
 253                            error to our caller. */
 254                         goto error;
 255                 }
 256
 257         } while (*p++ != '\0');
 258
 259 error:
 260         _exit(SPAWN_ERROR);
 261 }
 262
 263 /* Spawn a new process executing PATH with the attributes describes in *ATTRP.
 264    Before running the process perform the actions described in FILE-ACTIONS. */
 265 int posix_spawn (pid_t *pid, const char *path,
 266                const posix_spawn_file_actions_t *fa,
 267                const posix_spawnattr_t *attrp, char *const argv[],
 268                char *const envp[])
 269 {
 270         return __spawni(pid, path, fa, attrp, argv, envp, NULL);
 271 }
 272
 273 /* Spawn a new process executing FILE with the attributes describes in *ATTRP.
 274    Before running the process perform the actions described in FILE-ACTIONS. */
 275 int
 276 posix_spawnp(pid_t *pid, const char *file,
 277              const posix_spawn_file_actions_t *fa,
 278              const posix_spawnattr_t *attrp, char *const argv[],
 279              char *const envp[])
 280 {
 281         const char *path = getenv("PATH");
 282
 283         if (!path)
 284                 path = ":/bin:/usr/bin";
 285
 286         return __spawni(pid, file, fa, attrp, argv, envp, path);
 287 }