sysdeps/posix/spawni.c

   1 /* Guts of POSIX spawn interface.  Generic POSIX.1 version.
   2    Copyright (C) 2000,2001,2002,2003,2004,2005 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 "spawn_int.h"
  28 #include <not-cancel.h>
  29
  30
  31 /* The Unix standard contains a long explanation of the way to signal
  32    an error after the fork() was successful.  Since no new wait status
  33    was wanted there is no way to signal an error using one of the
  34    available methods.  The committee chose to signal an error by a
  35    normal program exit with the exit code 127.  */
  36 #define SPAWN_ERROR     127
  37
  38
  39 /* The file is accessible but it is not an executable file.  Invoke
  40    the shell to interpret it as a script.  */
  41 static void
  42 internal_function
  43 script_execute (const char *file, char *const argv[], char *const envp[])
  44 {
  45   /* Count the arguments.  */
  46   int argc = 0;
  47   while (argv[argc++])
  48     ;
  49
  50   /* Construct an argument list for the shell.  */
  51   {
  52     char *new_argv[argc + 1];
  53     new_argv[0] = (char *) _PATH_BSHELL;
  54     new_argv[1] = (char *) file;
  55     while (argc > 1)
  56       {
  57         new_argv[argc] = argv[argc - 1];
  58         --argc;
  59       }
  60
  61     /* Execute the shell.  */
  62     __execve (new_argv[0], new_argv, envp);
  63   }
  64 }
  65
  66
  67 /* Spawn a new process executing PATH with the attributes describes in *ATTRP.
  68    Before running the process perform the actions described in FILE-ACTIONS. */
  69 int
  70 __spawni (pid_t *pid, const char *file,
  71           const posix_spawn_file_actions_t *file_actions,
  72           const posix_spawnattr_t *attrp, char *const argv[],
  73           char *const envp[], int use_path)
  74 {
  75   pid_t new_pid;
  76   char *path, *p, *name;
  77   size_t len;
  78   size_t pathlen;
  79
  80   /* Do this once.  */
  81   short int flags = attrp == NULL ? 0 : attrp->__flags;
  82
  83   /* Generate the new process.  */
  84   if ((flags & POSIX_SPAWN_USEVFORK) != 0
  85       /* If no major work is done, allow using vfork.  Note that we
  86          might perform the path searching.  But this would be done by
  87          a call to execvp(), too, and such a call must be OK according
  88          to POSIX.  */
  89       || ((flags & (POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF
  90                     | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER
  91                     | POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_RESETIDS)) == 0
  92           && file_actions == NULL))
  93     new_pid = __vfork ();
  94   else
  95     new_pid = __fork ();
  96
  97   if (new_pid != 0)
  98     {
  99       if (new_pid < 0)
 100         return errno;
 101
 102       /* The call was successful.  Store the PID if necessary.  */
 103       if (pid != NULL)
 104         *pid = new_pid;
 105
 106       return 0;
 107     }
 108
 109   /* Set signal mask.  */
 110   if ((flags & POSIX_SPAWN_SETSIGMASK) != 0
 111       && __sigprocmask (SIG_SETMASK, &attrp->__ss, NULL) != 0)
 112     _exit (SPAWN_ERROR);
 113
 114   /* Set signal default action.  */
 115   if ((flags & POSIX_SPAWN_SETSIGDEF) != 0)
 116     {
 117       /* We have to iterate over all signals.  This could possibly be
 118          done better but it requires system specific solutions since
 119          the sigset_t data type can be very different on different
 120          architectures.  */
 121       int sig;
 122       struct sigaction sa;
 123
 124       memset (&sa, '\0', sizeof (sa));
 125       sa.sa_handler = SIG_DFL;
 126
 127       for (sig = 1; sig <= _NSIG; ++sig)
 128         if (__sigismember (&attrp->__sd, sig) != 0
 129             && __sigaction (sig, &sa, NULL) != 0)
 130           _exit (SPAWN_ERROR);
 131
 132     }
 133
 134 #ifdef _POSIX_PRIORITY_SCHEDULING
 135   /* Set the scheduling algorithm and parameters.  */
 136   if ((flags & (POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER))
 137       == POSIX_SPAWN_SETSCHEDPARAM)
 138     {
 139       if (__sched_setparam (0, &attrp->__sp) == -1)
 140         _exit (SPAWN_ERROR);
 141     }
 142   else if ((flags & POSIX_SPAWN_SETSCHEDULER) != 0)
 143     {
 144       if (__sched_setscheduler (0, attrp->__policy,
 145                                 (flags & POSIX_SPAWN_SETSCHEDPARAM) != 0
 146                                 ? &attrp->__sp : NULL) == -1)
 147         _exit (SPAWN_ERROR);
 148     }
 149 #endif
 150
 151   /* Set the process group ID.  */
 152   if ((flags & POSIX_SPAWN_SETPGROUP) != 0
 153       && __setpgid (0, attrp->__pgrp) != 0)
 154     _exit (SPAWN_ERROR);
 155
 156   /* Set the effective user and group IDs.  */
 157   if ((flags & POSIX_SPAWN_RESETIDS) != 0
 158       && (seteuid (__getuid ()) != 0 || setegid (__getgid ()) != 0))
 159     _exit (SPAWN_ERROR);
 160
 161   /* Execute the file actions.  */
 162   if (file_actions != NULL)
 163     {
 164       int cnt;
 165
 166       for (cnt = 0; cnt < file_actions->__used; ++cnt)
 167         {
 168           struct __spawn_action *action = &file_actions->__actions[cnt];
 169
 170           switch (action->tag)
 171             {
 172             case spawn_do_close:
 173               if (close_not_cancel (action->action.close_action.fd) != 0)
 174                 /* Signal the error.  */
 175                 _exit (SPAWN_ERROR);
 176               break;
 177
 178             case spawn_do_open:
 179               {
 180                 int new_fd = __open64 (action->action.open_action.path,
 181                                        action->action.open_action.oflag,
 182                                        action->action.open_action.mode);
 183
 184                 if (new_fd == -1)
 185                   /* The `open' call failed.  */
 186                   _exit (SPAWN_ERROR);
 187
 188                 /* Make sure the desired file descriptor is used.  */
 189                 if (new_fd != action->action.open_action.fd)
 190                   {
 191                     if (__dup2 (new_fd, action->action.open_action.fd)
 192                         != action->action.open_action.fd)
 193                       /* The `dup2' call failed.  */
 194                       _exit (SPAWN_ERROR);
 195
 196                     if (__close (new_fd) != 0)
 197                       /* The `close' call failed.  */
 198                       _exit (SPAWN_ERROR);
 199                   }
 200               }
 201               break;
 202
 203             case spawn_do_dup2:
 204               if (__dup2 (action->action.dup2_action.fd,
 205                           action->action.dup2_action.newfd)
 206                   != action->action.dup2_action.newfd)
 207                 /* The `dup2' call failed.  */
 208                 _exit (SPAWN_ERROR);
 209               break;
 210             }
 211         }
 212     }
 213
 214   if (! use_path || strchr (file, '/') != NULL)
 215     {
 216       /* The FILE parameter is actually a path.  */
 217       __execve (file, argv, envp);
 218
 219       if (errno == ENOEXEC)
 220         script_execute (file, argv, envp);
 221
 222       /* Oh, oh.  `execve' returns.  This is bad.  */
 223       _exit (SPAWN_ERROR);
 224     }
 225
 226   /* We have to search for FILE on the path.  */
 227   path = getenv ("PATH");
 228   if (path == NULL)
 229     {
 230       /* There is no `PATH' in the environment.
 231          The default search path is the current directory
 232          followed by the path `confstr' returns for `_CS_PATH'.  */
 233       len = confstr (_CS_PATH, (char *) NULL, 0);
 234       path = (char *) __alloca (1 + len);
 235       path[0] = ':';
 236       (void) confstr (_CS_PATH, path + 1, len);
 237     }
 238
 239   len = strlen (file) + 1;
 240   pathlen = strlen (path);
 241   name = __alloca (pathlen + len + 1);
 242   /* Copy the file name at the top.  */
 243   name = (char *) memcpy (name + pathlen + 1, file, len);
 244   /* And add the slash.  */
 245   *--name = '/';
 246
 247   p = path;
 248   do
 249     {
 250       char *startp;
 251
 252       path = p;
 253       p = __strchrnul (path, ':');
 254
 255       if (p == path)
 256         /* Two adjacent colons, or a colon at the beginning or the end
 257            of `PATH' means to search the current directory.  */
 258         startp = name + 1;
 259       else
 260         startp = (char *) memcpy (name - (p - path), path, p - path);
 261
 262       /* Try to execute this name.  If it works, execv will not return.  */
 263       __execve (startp, argv, envp);
 264
 265       if (errno == ENOEXEC)
 266         script_execute (startp, argv, envp);
 267
 268       switch (errno)
 269         {
 270         case EACCES:
 271         case ENOENT:
 272         case ESTALE:
 273         case ENOTDIR:
 274           /* Those errors indicate the file is missing or not executable
 275              by us, in which case we want to just try the next path
 276              directory.  */
 277           break;
 278
 279         default:
 280           /* Some other error means we found an executable file, but
 281              something went wrong executing it; return the error to our
 282              caller.  */
 283           _exit (SPAWN_ERROR);
 284             }
 285     }
 286   while (*p++ != '\0');
 287
 288   /* Return with an error.  */
 289   _exit (SPAWN_ERROR);
 290 }