libio/iopopen.c

   1 /* Copyright (C) 1993-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.
  17
  18    As a special exception, if you link the code in this file with
  19    files compiled with a GNU compiler to produce an executable,
  20    that does not cause the resulting executable to be covered by
  21    the GNU Lesser General Public License.  This exception does not
  22    however invalidate any other reasons why the executable file
  23    might be covered by the GNU Lesser General Public License.
  24    This exception applies to code released by its copyright holders
  25    in files containing the exception.  */
  26
  27 #include "libioP.h"
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <unistd.h>
  31 #include <stdlib.h>
  32 #include <shlib-compat.h>
  33 #include <not-cancel.h>
  34 #include <sys/types.h>
  35 #include <sys/wait.h>
  36 #include <spawn.h>
  37 #include <paths.h>
  38
  39 struct _IO_proc_file
  40 {
  41   struct _IO_FILE_plus file;
  42   /* Following fields must match those in class procbuf (procbuf.h) */
  43   pid_t pid;
  44   struct _IO_proc_file *next;
  45 };
  46 typedef struct _IO_proc_file _IO_proc_file;
  47
  48 static struct _IO_proc_file *proc_file_chain;
  49
  50 #ifdef _IO_MTSAFE_IO
  51 static _IO_lock_t proc_file_chain_lock = _IO_lock_initializer;
  52
  53 static void
  54 unlock (void *not_used)
  55 {
  56   _IO_lock_unlock (proc_file_chain_lock);
  57 }
  58 #endif
  59
  60 /* POSIX states popen shall ensure that any streams from previous popen()
  61    calls that remain open in the parent process should be closed in the new
  62    child process.
  63    To avoid a race-condition between checking which file descriptors need to
  64    be close (by transversing the proc_file_chain list) and the insertion of a
  65    new one after a successful posix_spawn this function should be called
  66    with proc_file_chain_lock acquired.  */
  67 static int
  68 spawn_process (posix_spawn_file_actions_t *fa, FILE *fp, const char *command,
  69                int do_cloexec, int pipe_fds[2], int parent_end, int child_end,
  70                int child_pipe_fd)
  71 {
  72   int err = 0;
  73
  74   for (struct _IO_proc_file *p = proc_file_chain; p; p = p->next)
  75     {
  76       int fd = _IO_fileno ((FILE *) p);
  77
  78       /* If any stream from previous popen() calls has fileno
  79          child_pipe_fd, it has been already closed by the adddup2 action
  80          above.  */
  81       if (fd != child_pipe_fd)
  82         {
  83           err = __posix_spawn_file_actions_addclose (fa, fd);
  84           if (err != 0)
  85             return err;
  86         }
  87     }
  88
  89   err = __posix_spawn (&((_IO_proc_file *) fp)->pid, _PATH_BSHELL, fa, 0,
  90                        (char *const[]){ (char*) "sh", (char*) "-c", (char*) "--",
  91                        (char *) command, NULL }, __environ);
  92   if (err != 0)
  93     return err;
  94
  95   __close_nocancel (pipe_fds[child_end]);
  96
  97   if (!do_cloexec)
  98     /* Undo the effects of the pipe2 call which set the
  99        close-on-exec flag.  */
 100     __fcntl (pipe_fds[parent_end], F_SETFD, 0);
 101
 102   _IO_fileno (fp) = pipe_fds[parent_end];
 103
 104   ((_IO_proc_file *) fp)->next = proc_file_chain;
 105   proc_file_chain = (_IO_proc_file *) fp;
 106
 107   return 0;
 108 }
 109
 110 FILE *
 111 _IO_new_proc_open (FILE *fp, const char *command, const char *mode)
 112 {
 113   int read_or_write;
 114   /* These are indexes for pipe_fds.  */
 115   int parent_end, child_end;
 116   int pipe_fds[2];
 117   int child_pipe_fd;
 118   int err;
 119
 120   int do_read = 0;
 121   int do_write = 0;
 122   int do_cloexec = 0;
 123   while (*mode != '\0')
 124     switch (*mode++)
 125       {
 126       case 'r':
 127         do_read = 1;
 128         break;
 129       case 'w':
 130         do_write = 1;
 131         break;
 132       case 'e':
 133         do_cloexec = 1;
 134         break;
 135       default:
 136       errout:
 137         __set_errno (EINVAL);
 138         return NULL;
 139       }
 140
 141   if ((do_read ^ do_write) == 0)
 142     goto errout;
 143
 144   if (_IO_file_is_open (fp))
 145     return NULL;
 146
 147   /* Atomically set the O_CLOEXEC flag for the pipe end used by the
 148      child process (to avoid leaking the file descriptor in case of a
 149      concurrent fork).  This is later reverted in the child process.
 150      When popen returns, the parent pipe end can be O_CLOEXEC or not,
 151      depending on the 'e' open mode, but there is only one flag which
 152      controls both descriptors.  The parent end is adjusted below,
 153      after creating the child process.  (In the child process, the
 154      parent end should be closed on execve, so O_CLOEXEC remains set
 155      there.)  */
 156   if (__pipe2 (pipe_fds, O_CLOEXEC) < 0)
 157     return NULL;
 158
 159   if (do_read)
 160     {
 161       parent_end = 0;
 162       child_end = 1;
 163       read_or_write = _IO_NO_WRITES;
 164       child_pipe_fd = 1;
 165     }
 166   else
 167     {
 168       parent_end = 1;
 169       child_end = 0;
 170       read_or_write = _IO_NO_READS;
 171       child_pipe_fd = 0;
 172     }
 173
 174   posix_spawn_file_actions_t fa;
 175   /* posix_spawn_file_actions_init does not fail.  */
 176   __posix_spawn_file_actions_init (&fa);
 177
 178   /* The descriptor is already the one the child will use.  In this case
 179      it must be moved to another one otherwise, there is no safe way to
 180      remove the close-on-exec flag in the child without creating a FD leak
 181      race in the parent.  */
 182   if (pipe_fds[child_end] == child_pipe_fd)
 183     {
 184       int tmp = __fcntl (child_pipe_fd, F_DUPFD_CLOEXEC, 0);
 185       if (tmp < 0)
 186         goto spawn_failure;
 187       __close_nocancel (pipe_fds[child_end]);
 188       pipe_fds[child_end] = tmp;
 189     }
 190
 191   err = __posix_spawn_file_actions_adddup2 (&fa, pipe_fds[child_end],
 192                                             child_pipe_fd);
 193   if (err != 0)
 194     goto spawn_failure;
 195
 196 #ifdef _IO_MTSAFE_IO
 197   _IO_cleanup_region_start_noarg (unlock);
 198   _IO_lock_lock (proc_file_chain_lock);
 199 #endif
 200   err = spawn_process (&fa, fp, command, do_cloexec, pipe_fds, parent_end,
 201                        child_end, child_pipe_fd);
 202 #ifdef _IO_MTSAFE_IO
 203   _IO_lock_unlock (proc_file_chain_lock);
 204   _IO_cleanup_region_end (0);
 205 #endif
 206
 207   __posix_spawn_file_actions_destroy (&fa);
 208
 209   if (err != 0)
 210     {
 211       __set_errno (err);
 212     spawn_failure:
 213       __close_nocancel (pipe_fds[child_end]);
 214       __close_nocancel (pipe_fds[parent_end]);
 215       return NULL;
 216     }
 217
 218   _IO_mask_flags (fp, read_or_write, _IO_NO_READS|_IO_NO_WRITES);
 219   return fp;
 220 }
 221
 222 FILE *
 223 _IO_new_popen (const char *command, const char *mode)
 224 {
 225   struct locked_FILE
 226   {
 227     struct _IO_proc_file fpx;
 228 #ifdef _IO_MTSAFE_IO
 229     _IO_lock_t lock;
 230 #endif
 231   } *new_f;
 232   FILE *fp;
 233
 234   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 235   if (new_f == NULL)
 236     return NULL;
 237 #ifdef _IO_MTSAFE_IO
 238   new_f->fpx.file.file._lock = &new_f->lock;
 239 #endif
 240   fp = &new_f->fpx.file.file;
 241   _IO_init_internal (fp, 0);
 242   _IO_JUMPS (&new_f->fpx.file) = &_IO_proc_jumps;
 243   _IO_new_file_init_internal (&new_f->fpx.file);
 244   if (_IO_new_proc_open (fp, command, mode) != NULL)
 245     return (FILE *) &new_f->fpx.file;
 246   _IO_un_link (&new_f->fpx.file);
 247   free (new_f);
 248   return NULL;
 249 }
 250
 251 int
 252 _IO_new_proc_close (FILE *fp)
 253 {
 254   /* This is not name-space clean. FIXME! */
 255   int wstatus;
 256   _IO_proc_file **ptr = &proc_file_chain;
 257   pid_t wait_pid;
 258   int status = -1;
 259
 260   /* Unlink from proc_file_chain. */
 261 #ifdef _IO_MTSAFE_IO
 262   _IO_cleanup_region_start_noarg (unlock);
 263   _IO_lock_lock (proc_file_chain_lock);
 264 #endif
 265   for ( ; *ptr != NULL; ptr = &(*ptr)->next)
 266     {
 267       if (*ptr == (_IO_proc_file *) fp)
 268         {
 269           *ptr = (*ptr)->next;
 270           status = 0;
 271           break;
 272         }
 273     }
 274 #ifdef _IO_MTSAFE_IO
 275   _IO_lock_unlock (proc_file_chain_lock);
 276   _IO_cleanup_region_end (0);
 277 #endif
 278
 279   if (status < 0 || __close_nocancel (_IO_fileno(fp)) < 0)
 280     return -1;
 281   /* POSIX.2 Rationale:  "Some historical implementations either block
 282      or ignore the signals SIGINT, SIGQUIT, and SIGHUP while waiting
 283      for the child process to terminate.  Since this behavior is not
 284      described in POSIX.2, such implementations are not conforming." */
 285   do
 286     {
 287       int state;
 288       __pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &state);
 289       wait_pid = __waitpid (((_IO_proc_file *) fp)->pid, &wstatus, 0);
 290       __pthread_setcancelstate (state, NULL);
 291     }
 292   while (wait_pid == -1 && errno == EINTR);
 293   if (wait_pid == -1)
 294     return -1;
 295   return wstatus;
 296 }
 297
 298 strong_alias (_IO_new_popen, __new_popen)
 299 versioned_symbol (libc, _IO_new_popen, _IO_popen, GLIBC_2_1);
 300 versioned_symbol (libc, __new_popen, popen, GLIBC_2_1);
 301 versioned_symbol (libc, _IO_new_proc_open, _IO_proc_open, GLIBC_2_1);
 302 versioned_symbol (libc, _IO_new_proc_close, _IO_proc_close, GLIBC_2_1);