lib/spawni.c

   1 /* Guts of POSIX spawn interface.  Generic POSIX.1 version.
   2    Copyright (C) 2000-2006, 2008-2019 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program 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
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 #include <config.h>
  19
  20 /* Specification.  */
  21 #include <spawn.h>
  22 #include "spawn_int.h"
  23
  24 #include <alloca.h>
  25 #include <errno.h>
  26
  27 #include <fcntl.h>
  28 #ifndef O_LARGEFILE
  29 # define O_LARGEFILE 0
  30 #endif
  31
  32 #if _LIBC || HAVE_PATHS_H
  33 # include <paths.h>
  34 #else
  35 # define _PATH_BSHELL BOURNE_SHELL
  36 #endif
  37
  38 #include <signal.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <unistd.h>
  42
  43 #if _LIBC
  44 # include <not-cancel.h>
  45 #else
  46 # define close_not_cancel close
  47 # define open_not_cancel open
  48 #endif
  49
  50 #if _LIBC
  51 # include <local-setxid.h>
  52 #else
  53 # if !HAVE_SETEUID
  54 #  define seteuid(id) setresuid (-1, id, -1)
  55 # endif
  56 # if !HAVE_SETEGID
  57 #  define setegid(id) setresgid (-1, id, -1)
  58 # endif
  59 # define local_seteuid(id) seteuid (id)
  60 # define local_setegid(id) setegid (id)
  61 #endif
  62
  63 #if _LIBC
  64 # define alloca __alloca
  65 # define execve __execve
  66 # define dup2 __dup2
  67 # define fork __fork
  68 # define getgid __getgid
  69 # define getuid __getuid
  70 # define sched_setparam __sched_setparam
  71 # define sched_setscheduler __sched_setscheduler
  72 # define setpgid __setpgid
  73 # define sigaction __sigaction
  74 # define sigismember __sigismember
  75 # define sigprocmask __sigprocmask
  76 # define strchrnul __strchrnul
  77 # define vfork __vfork
  78 #else
  79 # undef internal_function
  80 # define internal_function /* empty */
  81 #endif
  82
  83
  84 /* The Unix standard contains a long explanation of the way to signal
  85    an error after the fork() was successful.  Since no new wait status
  86    was wanted there is no way to signal an error using one of the
  87    available methods.  The committee chose to signal an error by a
  88    normal program exit with the exit code 127.  */
  89 #define SPAWN_ERROR     127
  90
  91
  92 #if defined _WIN32 && ! defined __CYGWIN__
  93
  94 /* Native Windows API.  */
  95 int
  96 __spawni (pid_t *pid, const char *file,
  97           const posix_spawn_file_actions_t *file_actions,
  98           const posix_spawnattr_t *attrp, char *const argv[],
  99           char *const envp[], int use_path)
 100 {
 101   /* Not yet implemented.  */
 102   return ENOSYS;
 103 }
 104
 105 #else
 106
 107
 108 /* The file is accessible but it is not an executable file.  Invoke
 109    the shell to interpret it as a script.  */
 110 static void
 111 internal_function
 112 script_execute (const char *file, char *const argv[], char *const envp[])
 113 {
 114   /* Count the arguments.  */
 115   int argc = 0;
 116   while (argv[argc++])
 117     ;
 118
 119   /* Construct an argument list for the shell.  */
 120   {
 121     char **new_argv = (char **) alloca ((argc + 1) * sizeof (char *));
 122     new_argv[0] = (char *) _PATH_BSHELL;
 123     new_argv[1] = (char *) file;
 124     while (argc > 1)
 125       {
 126         new_argv[argc] = argv[argc - 1];
 127         --argc;
 128       }
 129
 130     /* Execute the shell.  */
 131     execve (new_argv[0], new_argv, envp);
 132   }
 133 }
 134
 135
 136 /* Spawn a new process executing PATH with the attributes describes in *ATTRP.
 137    Before running the process perform the actions described in FILE-ACTIONS. */
 138 int
 139 __spawni (pid_t *pid, const char *file,
 140           const posix_spawn_file_actions_t *file_actions,
 141           const posix_spawnattr_t *attrp, char *const argv[],
 142           char *const envp[], int use_path)
 143 {
 144   pid_t new_pid;
 145   char *path, *p, *name;
 146   size_t len;
 147   size_t pathlen;
 148
 149   /* Do this once.  */
 150   short int flags = attrp == NULL ? 0 : attrp->_flags;
 151
 152   /* Avoid gcc warning
 153        "variable 'flags' might be clobbered by 'longjmp' or 'vfork'"  */
 154   (void) &flags;
 155
 156   /* Generate the new process.  */
 157 #if HAVE_VFORK
 158   if ((flags & POSIX_SPAWN_USEVFORK) != 0
 159       /* If no major work is done, allow using vfork.  Note that we
 160          might perform the path searching.  But this would be done by
 161          a call to execvp(), too, and such a call must be OK according
 162          to POSIX.  */
 163       || ((flags & (POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF
 164                     | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER
 165                     | POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_RESETIDS)) == 0
 166           && file_actions == NULL))
 167     new_pid = vfork ();
 168   else
 169 #endif
 170     new_pid = fork ();
 171
 172   if (new_pid != 0)
 173     {
 174       if (new_pid < 0)
 175         return errno;
 176
 177       /* The call was successful.  Store the PID if necessary.  */
 178       if (pid != NULL)
 179         *pid = new_pid;
 180
 181       return 0;
 182     }
 183
 184   /* Set signal mask.  */
 185   if ((flags & POSIX_SPAWN_SETSIGMASK) != 0
 186       && sigprocmask (SIG_SETMASK, &attrp->_ss, NULL) != 0)
 187     _exit (SPAWN_ERROR);
 188
 189   /* Set signal default action.  */
 190   if ((flags & POSIX_SPAWN_SETSIGDEF) != 0)
 191     {
 192       /* We have to iterate over all signals.  This could possibly be
 193          done better but it requires system specific solutions since
 194          the sigset_t data type can be very different on different
 195          architectures.  */
 196       int sig;
 197       struct sigaction sa;
 198
 199       memset (&sa, '\0', sizeof (sa));
 200       sa.sa_handler = SIG_DFL;
 201
 202       for (sig = 1; sig <= NSIG; ++sig)
 203         if (sigismember (&attrp->_sd, sig) != 0
 204             && sigaction (sig, &sa, NULL) != 0)
 205           _exit (SPAWN_ERROR);
 206
 207     }
 208
 209 #if (_LIBC ? defined _POSIX_PRIORITY_SCHEDULING : HAVE_SCHED_SETPARAM && HAVE_SCHED_SETSCHEDULER)
 210   /* Set the scheduling algorithm and parameters.  */
 211   if ((flags & (POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER))
 212       == POSIX_SPAWN_SETSCHEDPARAM)
 213     {
 214       if (sched_setparam (0, &attrp->_sp) == -1)
 215         _exit (SPAWN_ERROR);
 216     }
 217   else if ((flags & POSIX_SPAWN_SETSCHEDULER) != 0)
 218     {
 219       if (sched_setscheduler (0, attrp->_policy,
 220                               (flags & POSIX_SPAWN_SETSCHEDPARAM) != 0
 221                               ? &attrp->_sp : NULL) == -1)
 222         _exit (SPAWN_ERROR);
 223     }
 224 #endif
 225
 226   /* Set the process group ID.  */
 227   if ((flags & POSIX_SPAWN_SETPGROUP) != 0
 228       && setpgid (0, attrp->_pgrp) != 0)
 229     _exit (SPAWN_ERROR);
 230
 231   /* Set the effective user and group IDs.  */
 232   if ((flags & POSIX_SPAWN_RESETIDS) != 0
 233       && (local_seteuid (getuid ()) != 0
 234           || local_setegid (getgid ()) != 0))
 235     _exit (SPAWN_ERROR);
 236
 237   /* Execute the file actions.  */
 238   if (file_actions != NULL)
 239     {
 240       int cnt;
 241
 242       for (cnt = 0; cnt < file_actions->_used; ++cnt)
 243         {
 244           struct __spawn_action *action = &file_actions->_actions[cnt];
 245
 246           switch (action->tag)
 247             {
 248             case spawn_do_close:
 249               if (close_not_cancel (action->action.close_action.fd) != 0)
 250                 /* Signal the error.  */
 251                 _exit (SPAWN_ERROR);
 252               break;
 253
 254             case spawn_do_open:
 255               {
 256                 int new_fd = open_not_cancel (action->action.open_action.path,
 257                                               action->action.open_action.oflag
 258                                               | O_LARGEFILE,
 259                                               action->action.open_action.mode);
 260
 261                 if (new_fd == -1)
 262                   /* The 'open' call failed.  */
 263                   _exit (SPAWN_ERROR);
 264
 265                 /* Make sure the desired file descriptor is used.  */
 266                 if (new_fd != action->action.open_action.fd)
 267                   {
 268                     if (dup2 (new_fd, action->action.open_action.fd)
 269                         != action->action.open_action.fd)
 270                       /* The 'dup2' call failed.  */
 271                       _exit (SPAWN_ERROR);
 272
 273                     if (close_not_cancel (new_fd) != 0)
 274                       /* The 'close' call failed.  */
 275                       _exit (SPAWN_ERROR);
 276                   }
 277               }
 278               break;
 279
 280             case spawn_do_dup2:
 281               if (dup2 (action->action.dup2_action.fd,
 282                         action->action.dup2_action.newfd)
 283                   != action->action.dup2_action.newfd)
 284                 /* The 'dup2' call failed.  */
 285                 _exit (SPAWN_ERROR);
 286               break;
 287
 288             case spawn_do_chdir:
 289               if (chdir (action->action.chdir_action.path) < 0)
 290                 /* The 'chdir' call failed.  */
 291                 _exit (SPAWN_ERROR);
 292               break;
 293             }
 294         }
 295     }
 296
 297   if (! use_path || strchr (file, '/') != NULL)
 298     {
 299       /* The FILE parameter is actually a path.  */
 300       execve (file, argv, envp);
 301
 302       if (errno == ENOEXEC)
 303         script_execute (file, argv, envp);
 304
 305       /* Oh, oh.  'execve' returns.  This is bad.  */
 306       _exit (SPAWN_ERROR);
 307     }
 308
 309   /* We have to search for FILE on the path.  */
 310   path = getenv ("PATH");
 311   if (path == NULL)
 312     {
 313 #if HAVE_CONFSTR
 314       /* There is no 'PATH' in the environment.
 315          The default search path is the current directory
 316          followed by the path 'confstr' returns for '_CS_PATH'.  */
 317       len = confstr (_CS_PATH, (char *) NULL, 0);
 318       path = (char *) alloca (1 + len);
 319       path[0] = ':';
 320       (void) confstr (_CS_PATH, path + 1, len);
 321 #else
 322       /* Pretend that the PATH contains only the current directory.  */
 323       path = "";
 324 #endif
 325     }
 326
 327   len = strlen (file) + 1;
 328   pathlen = strlen (path);
 329   name = alloca (pathlen + len + 1);
 330   /* Copy the file name at the top.  */
 331   name = (char *) memcpy (name + pathlen + 1, file, len);
 332   /* And add the slash.  */
 333   *--name = '/';
 334
 335   p = path;
 336   do
 337     {
 338       char *startp;
 339
 340       path = p;
 341       p = strchrnul (path, ':');
 342
 343       if (p == path)
 344         /* Two adjacent colons, or a colon at the beginning or the end
 345            of 'PATH' means to search the current directory.  */
 346         startp = name + 1;
 347       else
 348         startp = (char *) memcpy (name - (p - path), path, p - path);
 349
 350       /* Try to execute this name.  If it works, execv will not return.  */
 351       execve (startp, argv, envp);
 352
 353       if (errno == ENOEXEC)
 354         script_execute (startp, argv, envp);
 355
 356       switch (errno)
 357         {
 358         case EACCES:
 359         case ENOENT:
 360         case ESTALE:
 361         case ENOTDIR:
 362           /* Those errors indicate the file is missing or not executable
 363              by us, in which case we want to just try the next path
 364              directory.  */
 365           break;
 366
 367         default:
 368           /* Some other error means we found an executable file, but
 369              something went wrong executing it; return the error to our
 370              caller.  */
 371           _exit (SPAWN_ERROR);
 372         }
 373     }
 374   while (*p++ != '\0');
 375
 376   /* Return with an error.  */
 377   _exit (SPAWN_ERROR);
 378 }
 379
 380 #endif