sysdeps/posix/spawni.c

   1 /* Guts of POSIX spawn interface.  Generic POSIX.1 version.
   2    Copyright (C) 2000-2005, 2006 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 = open_not_cancel (action->action.open_action.path,
 181                                               action->action.open_action.oflag
 182                                               | O_LARGEFILE,
 183                                               action->action.open_action.mode);
 184
 185                 if (new_fd == -1)
 186                   /* The `open' call failed.  */
 187                   _exit (SPAWN_ERROR);
 188
 189                 /* Make sure the desired file descriptor is used.  */
 190                 if (new_fd != action->action.open_action.fd)
 191                   {
 192                     if (__dup2 (new_fd, action->action.open_action.fd)
 193                         != action->action.open_action.fd)
 194                       /* The `dup2' call failed.  */
 195                       _exit (SPAWN_ERROR);
 196
 197                     if (close_not_cancel (new_fd) != 0)
 198                       /* The `close' call failed.  */
 199                       _exit (SPAWN_ERROR);
 200                   }
 201               }
 202               break;
 203
 204             case spawn_do_dup2:
 205               if (__dup2 (action->action.dup2_action.fd,
 206                           action->action.dup2_action.newfd)
 207                   != action->action.dup2_action.newfd)
 208                 /* The `dup2' call failed.  */
 209                 _exit (SPAWN_ERROR);
 210               break;
 211             }
 212         }
 213     }
 214
 215   if (! use_path || strchr (file, '/') != NULL)
 216     {
 217       /* The FILE parameter is actually a path.  */
 218       __execve (file, argv, envp);
 219
 220       if (errno == ENOEXEC)
 221         script_execute (file, argv, envp);
 222
 223       /* Oh, oh.  `execve' returns.  This is bad.  */
 224       _exit (SPAWN_ERROR);
 225     }
 226
 227   /* We have to search for FILE on the path.  */
 228   path = getenv ("PATH");
 229   if (path == NULL)
 230     {
 231       /* There is no `PATH' in the environment.
 232          The default search path is the current directory
 233          followed by the path `confstr' returns for `_CS_PATH'.  */
 234       len = confstr (_CS_PATH, (char *) NULL, 0);
 235       path = (char *) __alloca (1 + len);
 236       path[0] = ':';
 237       (void) confstr (_CS_PATH, path + 1, len);
 238     }
 239
 240   len = strlen (file) + 1;
 241   pathlen = strlen (path);
 242   name = __alloca (pathlen + len + 1);
 243   /* Copy the file name at the top.  */
 244   name = (char *) memcpy (name + pathlen + 1, file, len);
 245   /* And add the slash.  */
 246   *--name = '/';
 247
 248   p = path;
 249   do
 250     {
 251       char *startp;
 252
 253       path = p;
 254       p = __strchrnul (path, ':');
 255
 256       if (p == path)
 257         /* Two adjacent colons, or a colon at the beginning or the end
 258            of `PATH' means to search the current directory.  */
 259         startp = name + 1;
 260       else
 261         startp = (char *) memcpy (name - (p - path), path, p - path);
 262
 263       /* Try to execute this name.  If it works, execv will not return.  */
 264       __execve (startp, argv, envp);
 265
 266       if (errno == ENOEXEC)
 267         script_execute (startp, argv, envp);
 268
 269       switch (errno)
 270         {
 271         case EACCES:
 272         case ENOENT:
 273         case ESTALE:
 274         case ENOTDIR:
 275           /* Those errors indicate the file is missing or not executable
 276              by us, in which case we want to just try the next path
 277              directory.  */
 278           break;
 279
 280         default:
 281           /* Some other error means we found an executable file, but
 282              something went wrong executing it; return the error to our
 283              caller.  */
 284           _exit (SPAWN_ERROR);
 285             }
 286     }
 287   while (*p++ != '\0');
 288
 289   /* Return with an error.  */
 290   _exit (SPAWN_ERROR);
 291 }