usr/src/lib/libc/port/stdio/system.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1988 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #include "lint.h"
  31 #include "mtlib.h"
  32 #include <sys/types.h>
  33 #include <sys/wait.h>
  34 #include <signal.h>
  35 #include <stdlib.h>
  36 #include <wait.h>
  37 #include <sys/stat.h>
  38 #include <unistd.h>
  39 #include <memory.h>
  40 #include <thread.h>
  41 #include <pthread.h>
  42 #include <errno.h>
  43 #include <synch.h>
  44 #include <spawn.h>
  45 #include <paths.h>
  46 #include "libc.h"
  47
  48 extern const char **_environ;
  49
  50 extern int __xpg4;      /* defined in _xpg4.c; 0 if not xpg4-compiled program */
  51 extern const sigset_t maskset;          /* all maskable signals */
  52
  53 static mutex_t sys_lock = DEFAULTMUTEX; /* protects the following */
  54 static uint_t sys_count = 0;            /* number of threads in system() */
  55 static struct sigaction sys_ibuf;       /* saved SIGINT sigaction */
  56 static struct sigaction sys_qbuf;       /* saved SIGQUIT sigaction */
  57 static struct sigaction ignore = {0, {SIG_IGN}, {0}};
  58
  59 /*
  60  * Things needed by the cancellation cleanup handler.
  61  */
  62 typedef struct {
  63         sigset_t        savemask;       /* saved signal mask */
  64         pid_t           pid;            /* if nonzero, the child's pid */
  65 } cleanup_t;
  66
  67 /*
  68  * Daemon thread whose sole function is to reap an abandoned child.
  69  * Also invoked from pclose() (see port/stdio/popen.c).
  70  */
  71 void *
  72 reapchild(void *arg)
  73 {
  74         pid_t pid = (pid_t)(uintptr_t)arg;
  75         int cancel_state;
  76
  77         (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancel_state);
  78         while (waitpid(pid, NULL, 0) == -1) {
  79                 if (errno != EINTR)
  80                         break;
  81         }
  82         (void) pthread_setcancelstate(cancel_state, NULL);
  83         return (NULL);
  84 }
  85
  86 /*
  87  * Cancellation cleanup handler.
  88  * If we were cancelled in waitpid(), create a daemon thread to
  89  * reap our abandoned child.  No other thread can do this for us.
  90  * It would be better if there were a system call to disinherit
  91  * a child process (give it to init, just as though we exited).
  92  */
  93 static void
  94 cleanup(void *arg)
  95 {
  96         cleanup_t *cup = arg;
  97
  98         if (cup->pid != 0) {    /* we were cancelled; abandoning our pid */
  99                 (void) thr_sigsetmask(SIG_SETMASK, &maskset, NULL);
 100                 (void) thr_create(NULL, 0,
 101                     reapchild, (void *)(uintptr_t)cup->pid,
 102                     THR_DAEMON, NULL);
 103         }
 104
 105         lmutex_lock(&sys_lock);
 106         if (--sys_count == 0) {         /* leaving system() */
 107                 /*
 108                  * There are no remaining threads in system(), so
 109                  * restore the SIGINT and SIGQUIT signal actions.
 110                  */
 111                 (void) sigaction(SIGINT, &sys_ibuf, NULL);
 112                 (void) sigaction(SIGQUIT, &sys_qbuf, NULL);
 113         }
 114         lmutex_unlock(&sys_lock);
 115
 116         (void) thr_sigsetmask(SIG_SETMASK, &cup->savemask, NULL);
 117 }
 118
 119 int
 120 system(const char *cmd)
 121 {
 122         cleanup_t cu;
 123         pid_t w;
 124         int status;
 125         int error;
 126         sigset_t mask;
 127         struct stat64 buf;
 128         const char *shpath = _PATH_BSHELL;
 129         char *argv[4];
 130         posix_spawnattr_t attr;
 131         static const char *shell = "sh";
 132
 133         if (cmd == NULL) {
 134                 if (stat64(shpath, &buf) != 0) {
 135                         return (0);
 136                 } else if (getuid() == buf.st_uid) {
 137                         /* exec for user */
 138                         if ((buf.st_mode & 0100) == 0)
 139                                 return (0);
 140                 } else if (getgid() == buf.st_gid) {
 141                         /* exec for group */
 142                         if ((buf.st_mode & 0010) == 0)
 143                                 return (0);
 144                 } else if ((buf.st_mode & 0001) == 0) { /* exec for others */
 145                         return (0);
 146                 }
 147                 return (1);
 148         }
 149
 150         /*
 151          * Initialize the posix_spawn() attributes structure.
 152          *
 153          * The setting of POSIX_SPAWN_WAITPID_NP ensures that no
 154          * wait-for-multiple wait() operation will reap our child
 155          * and that the child will not be automatically reaped due
 156          * to the disposition of SIGCHLD being set to be ignored.
 157          * Only a specific wait for the specific pid will be able
 158          * to reap the child.  Since no other thread knows the pid
 159          * of our child, this should be safe enough.
 160          *
 161          * The POSIX_SPAWN_NOEXECERR_NP flag tells posix_spawn() not
 162          * to fail if the shell cannot be executed, but rather cause
 163          * a child to be created that simply performs _exit(127).
 164          * This is in order to satisfy the Posix requirement on system():
 165          *      The system function shall behave as if a child process were
 166          *      created using fork(), and the child process invoked the sh
 167          *      utility using execl().  If some error prevents the command
 168          *      language interpreter from executing after the child process
 169          *      is created, the return value from system() shall be as if
 170          *      the command language interpreter had terminated using
 171          *      exit(127) or _exit(127).
 172          */
 173         error = posix_spawnattr_init(&attr);
 174         if (error == 0)
 175                 error = posix_spawnattr_setflags(&attr,
 176                     POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF |
 177                     POSIX_SPAWN_NOSIGCHLD_NP | POSIX_SPAWN_WAITPID_NP |
 178                     POSIX_SPAWN_NOEXECERR_NP);
 179
 180         /*
 181          * The POSIX spec for system() requires us to block SIGCHLD,
 182          * the rationale being that the process's signal handler for
 183          * SIGCHLD, if any, should not be called when our child exits.
 184          * This doesn't work for a multithreaded process because some
 185          * other thread could receive the SIGCHLD.
 186          *
 187          * The above setting of POSIX_SPAWN_NOSIGCHLD_NP ensures that no
 188          * SIGCHLD signal will be posted for our child when it exits, so
 189          * we don't have to block SIGCHLD to meet the intent of the spec.
 190          * We block SIGCHLD anyway, just because the spec requires it.
 191          */
 192         (void) sigemptyset(&mask);
 193         (void) sigaddset(&mask, SIGCHLD);
 194         (void) thr_sigsetmask(SIG_BLOCK, &mask, &cu.savemask);
 195         /*
 196          * Tell posix_spawn() to restore the signal mask in the child.
 197          */
 198         if (error == 0)
 199                 error = posix_spawnattr_setsigmask(&attr, &cu.savemask);
 200
 201         /*
 202          * We are required to set the disposition of SIGINT and SIGQUIT
 203          * to be ignored for the duration of the system() operation.
 204          *
 205          * We allow more than one thread to call system() concurrently by
 206          * keeping a count of such threads.  The signal actions are set
 207          * to SIG_IGN when the first thread calls system().  They are
 208          * restored in cleanup() when the last thread exits system().
 209          *
 210          * However, system() is still MT-unsafe because sigaction() has
 211          * a process-wide effect and some other thread may also be
 212          * setting the signal actions for SIGINT or SIGQUIT.
 213          */
 214         lmutex_lock(&sys_lock);
 215         if (sys_count++ == 0) {
 216                 (void) sigaction(SIGINT, &ignore, &sys_ibuf);
 217                 (void) sigaction(SIGQUIT, &ignore, &sys_qbuf);
 218         }
 219         lmutex_unlock(&sys_lock);
 220
 221         /*
 222          * If SIGINT and SIGQUIT were not already SIG_IGN, tell
 223          * posix_spawn() to make them SIG_DFL in the child,
 224          * else leave them as SIG_IGN in the child.
 225          */
 226         (void) sigemptyset(&mask);
 227         if (sys_ibuf.sa_handler != SIG_IGN)
 228                 (void) sigaddset(&mask, SIGINT);
 229         if (sys_qbuf.sa_handler != SIG_IGN)
 230                 (void) sigaddset(&mask, SIGQUIT);
 231         if (error == 0)
 232                 error = posix_spawnattr_setsigdefault(&attr, &mask);
 233
 234         argv[0] = (char *)shell;
 235         argv[1] = "-c";
 236         argv[2] = (char *)cmd;
 237         argv[3] = NULL;
 238         if (error == 0)
 239                 error = posix_spawn(&cu.pid, shpath, NULL, &attr,
 240                     (char *const *)argv, (char *const *)_environ);
 241
 242         (void) posix_spawnattr_destroy(&attr);
 243
 244         if (error) {
 245                 errno = error;
 246                 status = -1;
 247         } else {
 248                 /*
 249                  * system() is a cancellation point and so is waitpid().
 250                  */
 251                 pthread_cleanup_push(cleanup, &cu);
 252                 do {
 253                         w = waitpid(cu.pid, &status, 0);
 254                 } while (w == -1 && errno == EINTR);
 255                 pthread_cleanup_pop(0);
 256                 if (w == -1)
 257                         status = -1;
 258         }
 259         error = errno;
 260         cu.pid = 0;
 261         cleanup(&cu);
 262         errno = error;
 263
 264         return (status);
 265 }