sysdeps/posix/spawni.c

   1 /* Guts of POSIX spawn interface.  Generic POSIX.1 version.
   2    Copyright (C) 2000-2005, 2006, 2011 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <paths.h>
  23 #include <spawn.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <sys/resource.h>
  28 #include "spawn_int.h"
  29 #include <not-cancel.h>
  30 #include <local-setxid.h>
  31
  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
  41 /* The file is accessible but it is not an executable file.  Invoke
  42    the shell to interpret it as a script.  */
  43 static void
  44 internal_function
  45 script_execute (const char *file, char *const argv[], char *const envp[])
  46 {
  47   /* Count the arguments.  */
  48   int argc = 0;
  49   while (argv[argc++])
  50     ;
  51
  52   /* Construct an argument list for the shell.  */
  53   {
  54     char *new_argv[argc + 1];
  55     new_argv[0] = (char *) _PATH_BSHELL;
  56     new_argv[1] = (char *) file;
  57     while (argc > 1)
  58       {
  59         new_argv[argc] = argv[argc - 1];
  60         --argc;
  61       }
  62
  63     /* Execute the shell.  */
  64     __execve (new_argv[0], new_argv, envp);
  65   }
  66 }
  67
  68
  69 /* Spawn a new process executing PATH with the attributes describes in *ATTRP.
  70    Before running the process perform the actions described in FILE-ACTIONS. */
  71 int
  72 __spawni (pid_t *pid, const char *file,
  73           const posix_spawn_file_actions_t *file_actions,
  74           const posix_spawnattr_t *attrp, char *const argv[],
  75           char *const envp[], int use_path)
  76 {
  77   pid_t new_pid;
  78   char *path, *p, *name;
  79   size_t len;
  80   size_t pathlen;
  81
  82   /* Do this once.  */
  83   short int flags = attrp == NULL ? 0 : attrp->__flags;
  84
  85   /* Generate the new process.  */
  86   if ((flags & POSIX_SPAWN_USEVFORK) != 0
  87       /* If no major work is done, allow using vfork.  Note that we
  88          might perform the path searching.  But this would be done by
  89          a call to execvp(), too, and such a call must be OK according
  90          to POSIX.  */
  91       || ((flags & (POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF
  92                     | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER
  93                     | POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_RESETIDS)) == 0
  94           && file_actions == NULL))
  95     new_pid = __vfork ();
  96   else
  97     new_pid = __fork ();
  98
  99   if (new_pid != 0)
 100     {
 101       if (new_pid < 0)
 102         return errno;
 103
 104       /* The call was successful.  Store the PID if necessary.  */
 105       if (pid != NULL)
 106         *pid = new_pid;
 107
 108       return 0;
 109     }
 110
 111   /* Set signal mask.  */
 112   if ((flags & POSIX_SPAWN_SETSIGMASK) != 0
 113       && __sigprocmask (SIG_SETMASK, &attrp->__ss, NULL) != 0)
 114     _exit (SPAWN_ERROR);
 115
 116   /* Set signal default action.  */
 117   if ((flags & POSIX_SPAWN_SETSIGDEF) != 0)
 118     {
 119       /* We have to iterate over all signals.  This could possibly be
 120          done better but it requires system specific solutions since
 121          the sigset_t data type can be very different on different
 122          architectures.  */
 123       int sig;
 124       struct sigaction sa;
 125
 126       memset (&sa, '\0', sizeof (sa));
 127       sa.sa_handler = SIG_DFL;
 128
 129       for (sig = 1; sig <= _NSIG; ++sig)
 130         if (__sigismember (&attrp->__sd, sig) != 0
 131             && __sigaction (sig, &sa, NULL) != 0)
 132           _exit (SPAWN_ERROR);
 133
 134     }
 135
 136 #ifdef _POSIX_PRIORITY_SCHEDULING
 137   /* Set the scheduling algorithm and parameters.  */
 138   if ((flags & (POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER))
 139       == POSIX_SPAWN_SETSCHEDPARAM)
 140     {
 141       if (__sched_setparam (0, &attrp->__sp) == -1)
 142         _exit (SPAWN_ERROR);
 143     }
 144   else if ((flags & POSIX_SPAWN_SETSCHEDULER) != 0)
 145     {
 146       if (__sched_setscheduler (0, attrp->__policy,
 147                                 (flags & POSIX_SPAWN_SETSCHEDPARAM) != 0
 148                                 ? &attrp->__sp : NULL) == -1)
 149         _exit (SPAWN_ERROR);
 150     }
 151 #endif
 152
 153   /* Set the process group ID.  */
 154   if ((flags & POSIX_SPAWN_SETPGROUP) != 0
 155       && __setpgid (0, attrp->__pgrp) != 0)
 156     _exit (SPAWN_ERROR);
 157
 158   /* Set the effective user and group IDs.  */
 159   if ((flags & POSIX_SPAWN_RESETIDS) != 0
 160       && (local_seteuid (__getuid ()) != 0
 161           || local_setegid (__getgid ()) != 0))
 162     _exit (SPAWN_ERROR);
 163
 164   /* Execute the file actions.  */
 165   if (file_actions != NULL)
 166     {
 167       int cnt;
 168       struct rlimit64 fdlimit;
 169       bool have_fdlimit = false;
 170
 171       for (cnt = 0; cnt < file_actions->__used; ++cnt)
 172         {
 173           struct __spawn_action *action = &file_actions->__actions[cnt];
 174
 175           switch (action->tag)
 176             {
 177             case spawn_do_close:
 178               if (close_not_cancel (action->action.close_action.fd) != 0)
 179                 {
 180                   if (! have_fdlimit)
 181                     {
 182                       getrlimit64 (RLIMIT_NOFILE, &fdlimit);
 183                       have_fdlimit = true;
 184                     }
 185
 186                   /* Only signal errors for file descriptors out of range.  */
 187                   if (action->action.close_action.fd < 0
 188                       || action->action.close_action.fd >= fdlimit.rlim_cur)
 189                     /* Signal the error.  */
 190                     _exit (SPAWN_ERROR);
 191                 }
 192               break;
 193
 194             case spawn_do_open:
 195               {
 196                 int new_fd = open_not_cancel (action->action.open_action.path,
 197                                               action->action.open_action.oflag
 198                                               | O_LARGEFILE,
 199                                               action->action.open_action.mode);
 200
 201                 if (new_fd == -1)
 202                   /* The `open' call failed.  */
 203                   _exit (SPAWN_ERROR);
 204
 205                 /* Make sure the desired file descriptor is used.  */
 206                 if (new_fd != action->action.open_action.fd)
 207                   {
 208                     if (__dup2 (new_fd, action->action.open_action.fd)
 209                         != action->action.open_action.fd)
 210                       /* The `dup2' call failed.  */
 211                       _exit (SPAWN_ERROR);
 212
 213                     if (close_not_cancel (new_fd) != 0)
 214                       /* The `close' call failed.  */
 215                       _exit (SPAWN_ERROR);
 216                   }
 217               }
 218               break;
 219
 220             case spawn_do_dup2:
 221               if (__dup2 (action->action.dup2_action.fd,
 222                           action->action.dup2_action.newfd)
 223                   != action->action.dup2_action.newfd)
 224                 /* The `dup2' call failed.  */
 225                 _exit (SPAWN_ERROR);
 226               break;
 227             }
 228         }
 229     }
 230
 231   if (! use_path || strchr (file, '/') != NULL)
 232     {
 233       /* The FILE parameter is actually a path.  */
 234       __execve (file, argv, envp);
 235
 236       if (errno == ENOEXEC)
 237         script_execute (file, argv, envp);
 238
 239       /* Oh, oh.  `execve' returns.  This is bad.  */
 240       _exit (SPAWN_ERROR);
 241     }
 242
 243   /* We have to search for FILE on the path.  */
 244   path = getenv ("PATH");
 245   if (path == NULL)
 246     {
 247       /* There is no `PATH' in the environment.
 248          The default search path is the current directory
 249          followed by the path `confstr' returns for `_CS_PATH'.  */
 250       len = confstr (_CS_PATH, (char *) NULL, 0);
 251       path = (char *) __alloca (1 + len);
 252       path[0] = ':';
 253       (void) confstr (_CS_PATH, path + 1, len);
 254     }
 255
 256   len = strlen (file) + 1;
 257   pathlen = strlen (path);
 258   name = __alloca (pathlen + len + 1);
 259   /* Copy the file name at the top.  */
 260   name = (char *) memcpy (name + pathlen + 1, file, len);
 261   /* And add the slash.  */
 262   *--name = '/';
 263
 264   p = path;
 265   do
 266     {
 267       char *startp;
 268
 269       path = p;
 270       p = __strchrnul (path, ':');
 271
 272       if (p == path)
 273         /* Two adjacent colons, or a colon at the beginning or the end
 274            of `PATH' means to search the current directory.  */
 275         startp = name + 1;
 276       else
 277         startp = (char *) memcpy (name - (p - path), path, p - path);
 278
 279       /* Try to execute this name.  If it works, execv will not return.  */
 280       __execve (startp, argv, envp);
 281
 282       if (errno == ENOEXEC)
 283         script_execute (startp, argv, envp);
 284
 285       switch (errno)
 286         {
 287         case EACCES:
 288         case ENOENT:
 289         case ESTALE:
 290         case ENOTDIR:
 291           /* Those errors indicate the file is missing or not executable
 292              by us, in which case we want to just try the next path
 293              directory.  */
 294           break;
 295
 296         default:
 297           /* Some other error means we found an executable file, but
 298              something went wrong executing it; return the error to our
 299              caller.  */
 300           _exit (SPAWN_ERROR);
 301             }
 302     }
 303   while (*p++ != '\0');
 304
 305   /* Return with an error.  */
 306   _exit (SPAWN_ERROR);
 307 }