[vte] pty: spawn: Work around g_spawn_async non-cancellability



commit 048195077cee8f315d58fb4b059422cecd317f4a
Author: Christian Persch <chpe gnome org>
Date:   Fri Feb 3 21:16:16 2017 +0100

    pty: spawn: Work around g_spawn_async non-cancellability
    
    Until glib gets a fully cancelleable spawning API (either for g_spawn_* or
    GSubprocess), just use a trimmed-down copy of gspawn.c with cancellation
    added in.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=772354

 configure.ac     |    5 +
 po/POTFILES.skip |    1 +
 src/Makefile.am  |    2 +
 src/pty.cc       |   44 ++-
 src/vtespawn.cc  | 1261 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/vtespawn.hh  |   48 ++
 6 files changed, 1345 insertions(+), 16 deletions(-)
---
diff --git a/configure.ac b/configure.ac
index 1ead5df..e573c48 100644
--- a/configure.ac
+++ b/configure.ac
@@ -293,6 +293,11 @@ AC_CHECK_FUNCS([cfmakeraw fork setsid setpgid getpgid tcgetattr tcsetattr])
 # Misc I/O routines.
 AC_CHECK_FUNCS([pread pwrite])
 
+# for vtespawn
+AC_CHECK_HEADERS([sys/resource.h])
+AC_CHECK_FUNCS([fdwalk])
+
+# Math functions
 AC_CHECK_FUNC(floor,,AC_CHECK_LIB(m,floor,LIBS=["$LIBS -lm"]))
 AC_CHECK_FUNCS([ceil floor round])
 
diff --git a/po/POTFILES.skip b/po/POTFILES.skip
index f90d477..6a7b493 100644
--- a/po/POTFILES.skip
+++ b/po/POTFILES.skip
@@ -1,3 +1,4 @@
 src/app.ui
 src/search-popover.ui
 src/vteapp.c
+src/vtespawn.cc
diff --git a/src/Makefile.am b/src/Makefile.am
index da6c5d7..910eabe 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -80,6 +80,8 @@ libvte_@VTE_API_MAJOR_VERSION@_@VTE_API_MINOR_VERSION@_la_SOURCES = \
        vteregexinternal.hh \
        vterowdata.cc \
        vterowdata.h \
+       vtespawn.cc \
+       vtespawn.hh \
        vteseq.cc \
        vteseq-list.h \
        vtestream.cc \
diff --git a/src/pty.cc b/src/pty.cc
index 0916dd9..5006cc7 100644
--- a/src/pty.cc
+++ b/src/pty.cc
@@ -31,6 +31,7 @@
 #include <vte/vte.h>
 #include "vtepty-private.h"
 #include "vtetypes.hh"
+#include "vtespawn.hh"
 
 #include <sys/types.h>
 #include <sys/ioctl.h>
@@ -361,6 +362,10 @@ __vte_pty_spawn (VtePty *pty,
         char **envp2;
         gint i;
         GError *err = NULL;
+        GPollFD pollfd;
+
+        if (cancellable && !g_cancellable_make_pollfd(cancellable, &pollfd))
+                return FALSE;
 
         spawn_flags |= G_SPAWN_DO_NOT_REAP_CHILD;
 
@@ -390,27 +395,31 @@ __vte_pty_spawn (VtePty *pty,
        data->extra_child_setup = child_setup;
        data->extra_child_setup_data = child_setup_data;
 
-        ret = g_spawn_async_with_pipes(directory,
-                                       argv, envp2,
-                                       (GSpawnFlags) spawn_flags,
-                                       (GSpawnChildSetupFunc) vte_pty_child_setup,
-                                       pty,
-                                       child_pid,
-                                       NULL, NULL, NULL,
-                                       &err);
+        ret = vte_spawn_async_with_pipes_cancellable(directory,
+                                                     argv, envp2,
+                                                     (GSpawnFlags)spawn_flags,
+                                                     (GSpawnChildSetupFunc)vte_pty_child_setup,
+                                                     pty,
+                                                     child_pid,
+                                                     NULL, NULL, NULL,
+                                                     timeout,
+                                                     cancellable ? &pollfd : NULL,
+                                                     &err);
         if (!ret &&
             directory != NULL &&
             g_error_matches(err, G_SPAWN_ERROR, G_SPAWN_ERROR_CHDIR)) {
                 /* try spawning in our working directory */
                 g_clear_error(&err);
-                ret = g_spawn_async_with_pipes(NULL,
-                                               argv, envp2,
-                                               (GSpawnFlags) spawn_flags,
-                                               (GSpawnChildSetupFunc) vte_pty_child_setup,
-                                               pty,
-                                               child_pid,
-                                               NULL, NULL, NULL,
-                                               &err);
+                ret = vte_spawn_async_with_pipes_cancellable(NULL,
+                                                             argv, envp2,
+                                                             (GSpawnFlags)spawn_flags,
+                                                             (GSpawnChildSetupFunc)vte_pty_child_setup,
+                                                             pty,
+                                                             child_pid,
+                                                             NULL, NULL, NULL,
+                                                             timeout,
+                                                             cancellable ? &pollfd : NULL,
+                                                             &err);
         }
 
         g_strfreev (envp2);
@@ -418,6 +427,9 @@ __vte_pty_spawn (VtePty *pty,
        data->extra_child_setup = NULL;
        data->extra_child_setup_data = NULL;
 
+        if (cancellable)
+                g_cancellable_release_fd(cancellable);
+
         if (ret)
                 return TRUE;
 
diff --git a/src/vtespawn.cc b/src/vtespawn.cc
new file mode 100644
index 0000000..f0b4dae
--- /dev/null
+++ b/src/vtespawn.cc
@@ -0,0 +1,1261 @@
+/* gspawn.c - Process launching
+ *
+ *  Copyright 2000 Red Hat, Inc.
+ *  g_execvpe implementation based on GNU libc execvp:
+ *   Copyright 1991, 92, 95, 96, 97, 98, 99 Free Software Foundation, Inc.
+ *
+ * GLib is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * GLib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GLib; see the file COPYING.LIB.  If not, write
+ * to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <string.h>
+#include <stdlib.h>   /* for fdwalk */
+#include <dirent.h>
+
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif /* HAVE_SYS_RESOURCE_H */
+
+#include <glib/gstdio.h>
+#include <glib-unix.h>
+
+#include "vtespawn.hh"
+#include "reaper.hh"
+
+#define VTE_SPAWN_ERROR_TIMED_OUT (G_SPAWN_ERROR_FAILED + 1000)
+#define VTE_SPAWN_ERROR_CANCELLED (G_SPAWN_ERROR_FAILED + 1001)
+
+#define _(s) g_dgettext("glib-2.0", s)
+
+/*
+ * SECTION:spawn
+ * @Short_description: process launching
+ * @Title: Spawning Processes
+ *
+ * GLib supports spawning of processes with an API that is more
+ * convenient than the bare UNIX fork() and exec().
+ *
+ * The vte_spawn family of functions has synchronous (vte_spawn_sync())
+ * and asynchronous variants (vte_spawn_async(), vte_spawn_async_with_pipes(),
+ * vte_spawn_async_cancellable(), vte_spawn_async_with_pipes_cancellable),
+ * as well as convenience variants that take a complete shell-like
+ * commandline (vte_spawn_command_line_sync(), vte_spawn_command_line_async()).
+ *
+ * See #GSubprocess in GIO for a higher-level API that provides
+ * stream interfaces for communication with child processes.
+ */
+
+static gint g_execute (const gchar  *file,
+                       gchar **argv,
+                       gchar **envp,
+                       gboolean search_path,
+                       gboolean search_path_from_envp);
+
+static gboolean fork_exec_with_pipes (gboolean              intermediate_child,
+                                      const gchar          *working_directory,
+                                      gchar               **argv,
+                                      gchar               **envp,
+                                      gboolean              close_descriptors,
+                                      gboolean              search_path,
+                                      gboolean              search_path_from_envp,
+                                      gboolean              stdout_to_null,
+                                      gboolean              stderr_to_null,
+                                      gboolean              child_inherits_stdin,
+                                      gboolean              file_and_argv_zero,
+                                      gboolean              cloexec_pipes,
+                                      GSpawnChildSetupFunc  child_setup,
+                                      gpointer              user_data,
+                                      GPid                 *child_pid,
+                                      gint                 *standard_input,
+                                      gint                 *standard_output,
+                                      gint                 *standard_error,
+                                      gint                  timeout,
+                                      GPollFD              *pollfd,
+                                      GError              **error);
+
+/*
+ * vte_spawn_async_cancellable:
+ * @working_directory: (type filename) (allow-none): child's current working directory, or %NULL to inherit 
parent's
+ * @argv: (array zero-terminated=1): child's argument vector
+ * @envp: (array zero-terminated=1) (allow-none): child's environment, or %NULL to inherit parent's
+ * @flags: flags from #GSpawnFlags
+ * @child_setup: (scope async) (allow-none): function to run in the child just before exec()
+ * @user_data: (closure): user data for @child_setup
+ * @child_pid: (out) (allow-none): return location for child process reference, or %NULL
+ * @timeout: a timeout value in ms, or -1 to wait indefinitely
+ * @pollfd: (allow-none): a #GPollFD, or %NULL
+ * @error: return location for error
+ * 
+ * See vte_spawn_async_with_pipes_cancellable() for a full description; this function
+ * simply calls the vte_spawn_async_with_pipes_cancellable() without any pipes.
+ *
+ * You should call vte_spawn_close_pid() on the returned child process
+ * reference when you don't need it any more.
+ * 
+ * Note that the returned @child_pid on Windows is a handle to the child
+ * process and not its identifier. Process handles and process identifiers
+ * are different concepts on Windows.
+ *
+ * Returns: %TRUE on success, %FALSE if error is set
+ *
+ * Since: 2.52
+ **/
+gboolean
+vte_spawn_async_cancellable (const gchar          *working_directory,
+                             gchar               **argv,
+                             gchar               **envp,
+                             GSpawnFlags           flags,
+                             GSpawnChildSetupFunc  child_setup,
+                             gpointer              user_data,
+                             GPid                 *child_pid,
+                             gint                  timeout,
+                             GPollFD              *pollfd,
+                             GError              **error)
+{
+  return vte_spawn_async_with_pipes_cancellable (working_directory,
+                                               argv, envp,
+                                               flags,
+                                               child_setup,
+                                               user_data,
+                                               child_pid,
+                                               NULL, NULL, NULL,
+                                               timeout, pollfd,
+                                               error);
+}
+
+/* Avoids a danger in threaded situations (calling close()
+ * on a file descriptor twice, and another thread has
+ * re-opened it since the first close)
+ */
+static void
+close_and_invalidate (gint *fd)
+{
+  if (*fd < 0)
+    return;
+  else
+    {
+      (void) g_close (*fd, NULL);
+      *fd = -1;
+    }
+}
+
+/*
+ * vte_spawn_async_with_pipes_cancellable:
+ * @working_directory: (type filename) (allow-none): child's current working directory, or %NULL to inherit 
parent's, in the GLib file name encoding
+ * @argv: (array zero-terminated=1): child's argument vector, in the GLib file name encoding
+ * @envp: (array zero-terminated=1) (allow-none): child's environment, or %NULL to inherit parent's, in the 
GLib file name encoding
+ * @flags: flags from #GSpawnFlags
+ * @child_setup: (scope async) (allow-none): function to run in the child just before exec()
+ * @user_data: (closure): user data for @child_setup
+ * @child_pid: (out) (allow-none): return location for child process ID, or %NULL
+ * @standard_input: (out) (allow-none): return location for file descriptor to write to child's stdin, or 
%NULL
+ * @standard_output: (out) (allow-none): return location for file descriptor to read child's stdout, or %NULL
+ * @standard_error: (out) (allow-none): return location for file descriptor to read child's stderr, or %NULL
+ * @timeout: a timeout value in ms, or -1 to wait indefinitely
+ * @pollfd: (allow-none): a #GPollFD, or %NULL
+ * @error: return location for error
+ *
+ * Like vte_spawn_async_with_pipes(), but allows the spawning to be
+ * aborted.
+ *
+ * If @timeout is not -1, then the spawning will be aborted if
+ * the timeout is exceeded before spawning has completed.
+ *
+ * If @pollfd is not %NULL, then the spawning will be aborted if
+ * the @pollfd.fd becomes readable. Usually, you want to create
+ * this parameter with g_cancellable_make_pollfd().
+ *
+ * Returns: %TRUE on success, %FALSE if an error occurred or the
+ *  spawning was aborted
+ *
+ * Since: 2.52
+ */
+gboolean
+vte_spawn_async_with_pipes_cancellable (const gchar          *working_directory,
+                                        gchar               **argv,
+                                        gchar               **envp,
+                                        GSpawnFlags           flags,
+                                        GSpawnChildSetupFunc  child_setup,
+                                        gpointer              user_data,
+                                        GPid                 *child_pid,
+                                        gint                 *standard_input,
+                                        gint                 *standard_output,
+                                        gint                 *standard_error,
+                                        gint                  timeout,
+                                        GPollFD              *pollfd,
+                                        GError              **error)
+{
+  g_return_val_if_fail (argv != NULL, FALSE);
+  g_return_val_if_fail (standard_output == NULL ||
+                        !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
+  g_return_val_if_fail (standard_error == NULL ||
+                        !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
+  /* can't inherit stdin if we have an input pipe. */
+  g_return_val_if_fail (standard_input == NULL ||
+                        !(flags & G_SPAWN_CHILD_INHERITS_STDIN), FALSE);
+  
+  return fork_exec_with_pipes (!(flags & G_SPAWN_DO_NOT_REAP_CHILD),
+                               working_directory,
+                               argv,
+                               envp,
+                               !(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN),
+                               (flags & G_SPAWN_SEARCH_PATH) != 0,
+                               (flags & G_SPAWN_SEARCH_PATH_FROM_ENVP) != 0,
+                               (flags & G_SPAWN_STDOUT_TO_DEV_NULL) != 0,
+                               (flags & G_SPAWN_STDERR_TO_DEV_NULL) != 0,
+                               (flags & G_SPAWN_CHILD_INHERITS_STDIN) != 0,
+                               (flags & G_SPAWN_FILE_AND_ARGV_ZERO) != 0,
+                               (flags & G_SPAWN_CLOEXEC_PIPES) != 0,
+                               child_setup,
+                               user_data,
+                               child_pid,
+                               standard_input,
+                               standard_output,
+                               standard_error,
+                               timeout,
+                               pollfd,
+                               error);
+}
+
+static gint
+exec_err_to_g_error (gint en)
+{
+  switch (en)
+    {
+#ifdef EACCES
+    case EACCES:
+      return G_SPAWN_ERROR_ACCES;
+      break;
+#endif
+
+#ifdef EPERM
+    case EPERM:
+      return G_SPAWN_ERROR_PERM;
+      break;
+#endif
+
+#ifdef E2BIG
+    case E2BIG:
+      return G_SPAWN_ERROR_TOO_BIG;
+      break;
+#endif
+
+#ifdef ENOEXEC
+    case ENOEXEC:
+      return G_SPAWN_ERROR_NOEXEC;
+      break;
+#endif
+
+#ifdef ENAMETOOLONG
+    case ENAMETOOLONG:
+      return G_SPAWN_ERROR_NAMETOOLONG;
+      break;
+#endif
+
+#ifdef ENOENT
+    case ENOENT:
+      return G_SPAWN_ERROR_NOENT;
+      break;
+#endif
+
+#ifdef ENOMEM
+    case ENOMEM:
+      return G_SPAWN_ERROR_NOMEM;
+      break;
+#endif
+
+#ifdef ENOTDIR
+    case ENOTDIR:
+      return G_SPAWN_ERROR_NOTDIR;
+      break;
+#endif
+
+#ifdef ELOOP
+    case ELOOP:
+      return G_SPAWN_ERROR_LOOP;
+      break;
+#endif
+      
+#ifdef ETXTBUSY
+    case ETXTBUSY:
+      return G_SPAWN_ERROR_TXTBUSY;
+      break;
+#endif
+
+#ifdef EIO
+    case EIO:
+      return G_SPAWN_ERROR_IO;
+      break;
+#endif
+
+#ifdef ENFILE
+    case ENFILE:
+      return G_SPAWN_ERROR_NFILE;
+      break;
+#endif
+
+#ifdef EMFILE
+    case EMFILE:
+      return G_SPAWN_ERROR_MFILE;
+      break;
+#endif
+
+#ifdef EINVAL
+    case EINVAL:
+      return G_SPAWN_ERROR_INVAL;
+      break;
+#endif
+
+#ifdef EISDIR
+    case EISDIR:
+      return G_SPAWN_ERROR_ISDIR;
+      break;
+#endif
+
+#ifdef ELIBBAD
+    case ELIBBAD:
+      return G_SPAWN_ERROR_LIBBAD;
+      break;
+#endif
+      
+    default:
+      return G_SPAWN_ERROR_FAILED;
+      break;
+    }
+}
+
+static gssize
+write_all (gint fd, gconstpointer vbuf, gsize to_write)
+{
+  gchar *buf = (gchar *) vbuf;
+  
+  while (to_write > 0)
+    {
+      gssize count = write (fd, buf, to_write);
+      if (count < 0)
+        {
+          if (errno != EINTR)
+            return FALSE;
+        }
+      else
+        {
+          to_write -= count;
+          buf += count;
+        }
+    }
+  
+  return TRUE;
+}
+
+G_GNUC_NORETURN
+static void
+write_err_and_exit (gint fd, gint msg)
+{
+  gint en = errno;
+  
+  write_all (fd, &msg, sizeof(msg));
+  write_all (fd, &en, sizeof(en));
+  
+  _exit (1);
+}
+
+static int
+fd_set_cloexec(int fd)
+{
+        int flags = fcntl(fd, F_GETFD, 0);
+        if (flags < 0)
+                return flags;
+
+        return fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
+}
+
+static int
+fd_set_nonblocking(int fd)
+{
+        int flags = fcntl(fd, F_GETFL, 0);
+        if (flags < 0)
+                return -1;
+        if ((flags & O_NONBLOCK) != 0)
+                return 0;
+        return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+}
+
+static int
+set_cloexec (void *data, gint fd)
+{
+  if (fd >= GPOINTER_TO_INT (data))
+    fd_set_cloexec (fd);
+
+  return 0;
+}
+
+#ifndef HAVE_FDWALK
+static int
+fdwalk (int (*cb)(void *data, int fd), void *data)
+{
+  gint open_max;
+  gint fd;
+  gint res = 0;
+  
+#ifdef HAVE_SYS_RESOURCE_H
+  struct rlimit rl;
+#endif
+
+#ifdef __linux__  
+  DIR *d;
+
+  if ((d = opendir("/proc/self/fd"))) {
+      struct dirent *de;
+
+      while ((de = readdir(d))) {
+          glong l;
+          gchar *e = NULL;
+
+          if (de->d_name[0] == '.')
+              continue;
+            
+          errno = 0;
+          l = strtol(de->d_name, &e, 10);
+          if (errno != 0 || !e || *e)
+              continue;
+
+          fd = (gint) l;
+
+          if ((glong) fd != l)
+              continue;
+
+          if (fd == dirfd(d))
+              continue;
+
+          if ((res = cb (data, fd)) != 0)
+              break;
+        }
+      
+      closedir(d);
+      return res;
+  }
+
+  /* If /proc is not mounted or not accessible we fall back to the old
+   * rlimit trick */
+
+#endif
+  
+#ifdef HAVE_SYS_RESOURCE_H
+      
+  if (getrlimit(RLIMIT_NOFILE, &rl) == 0 && rl.rlim_max != RLIM_INFINITY)
+      open_max = rl.rlim_max;
+  else
+#endif
+      open_max = sysconf (_SC_OPEN_MAX);
+
+  for (fd = 0; fd < open_max; fd++)
+      if ((res = cb (data, fd)) != 0)
+          break;
+
+  return res;
+}
+#endif
+
+static gint
+sane_dup2 (gint fd1, gint fd2)
+{
+  gint ret;
+
+ retry:
+  ret = dup2 (fd1, fd2);
+  if (ret < 0 && errno == EINTR)
+    goto retry;
+
+  return ret;
+}
+
+static gint
+sane_open (const char *path, gint mode)
+{
+  gint ret;
+
+ retry:
+  ret = open (path, mode);
+  if (ret < 0 && errno == EINTR)
+    goto retry;
+
+  return ret;
+}
+
+enum
+{
+  CHILD_CHDIR_FAILED,
+  CHILD_EXEC_FAILED,
+  CHILD_DUP2_FAILED,
+  CHILD_FORK_FAILED
+};
+
+static void
+do_exec (gint                  child_err_report_fd,
+         gint                  stdin_fd,
+         gint                  stdout_fd,
+         gint                  stderr_fd,
+         const gchar          *working_directory,
+         gchar               **argv,
+         gchar               **envp,
+         gboolean              close_descriptors,
+         gboolean              search_path,
+         gboolean              search_path_from_envp,
+         gboolean              stdout_to_null,
+         gboolean              stderr_to_null,
+         gboolean              child_inherits_stdin,
+         gboolean              file_and_argv_zero,
+         GSpawnChildSetupFunc  child_setup,
+         gpointer              user_data)
+{
+  if (working_directory && chdir (working_directory) < 0)
+    write_err_and_exit (child_err_report_fd,
+                        CHILD_CHDIR_FAILED);
+
+  /* Close all file descriptors but stdin stdout and stderr as
+   * soon as we exec. Note that this includes
+   * child_err_report_fd, which keeps the parent from blocking
+   * forever on the other end of that pipe.
+   */
+  if (close_descriptors)
+    {
+      fdwalk (set_cloexec, GINT_TO_POINTER(3));
+    }
+  else
+    {
+      /* We need to do child_err_report_fd anyway */
+      set_cloexec (GINT_TO_POINTER(0), child_err_report_fd);
+    }
+  
+  /* Redirect pipes as required */
+  
+  if (stdin_fd >= 0)
+    {
+      /* dup2 can't actually fail here I don't think */
+          
+      if (sane_dup2 (stdin_fd, 0) < 0)
+        write_err_and_exit (child_err_report_fd,
+                            CHILD_DUP2_FAILED);
+
+      /* ignore this if it doesn't work */
+      close_and_invalidate (&stdin_fd);
+    }
+  else if (!child_inherits_stdin)
+    {
+      /* Keep process from blocking on a read of stdin */
+      gint read_null = open ("/dev/null", O_RDONLY);
+      g_assert (read_null != -1);
+      sane_dup2 (read_null, 0);
+      close_and_invalidate (&read_null);
+    }
+
+  if (stdout_fd >= 0)
+    {
+      /* dup2 can't actually fail here I don't think */
+          
+      if (sane_dup2 (stdout_fd, 1) < 0)
+        write_err_and_exit (child_err_report_fd,
+                            CHILD_DUP2_FAILED);
+
+      /* ignore this if it doesn't work */
+      close_and_invalidate (&stdout_fd);
+    }
+  else if (stdout_to_null)
+    {
+      gint write_null = sane_open ("/dev/null", O_WRONLY);
+      g_assert (write_null != -1);
+      sane_dup2 (write_null, 1);
+      close_and_invalidate (&write_null);
+    }
+
+  if (stderr_fd >= 0)
+    {
+      /* dup2 can't actually fail here I don't think */
+          
+      if (sane_dup2 (stderr_fd, 2) < 0)
+        write_err_and_exit (child_err_report_fd,
+                            CHILD_DUP2_FAILED);
+
+      /* ignore this if it doesn't work */
+      close_and_invalidate (&stderr_fd);
+    }
+  else if (stderr_to_null)
+    {
+      gint write_null = sane_open ("/dev/null", O_WRONLY);
+      sane_dup2 (write_null, 2);
+      close_and_invalidate (&write_null);
+    }
+  
+  /* Call user function just before we exec */
+  if (child_setup)
+    {
+      (* child_setup) (user_data);
+    }
+
+  g_execute (argv[0],
+             file_and_argv_zero ? argv + 1 : argv,
+             envp, search_path, search_path_from_envp);
+
+  /* Exec failed */
+  write_err_and_exit (child_err_report_fd,
+                      CHILD_EXEC_FAILED);
+}
+
+static gboolean
+read_ints (int      fd,
+           gint*    buf,
+           gint     n_ints_in_buf,    
+           gint    *n_ints_read,
+           gint     timeout,
+           GPollFD *cancellable_pollfd,
+           GError **error)
+{
+  gsize bytes = 0;
+  GPollFD pollfds[2];
+  guint n_pollfds;
+  gint64 start_time;
+
+  if (timeout >= 0 || cancellable_pollfd != NULL)
+    {
+      if (fd_set_nonblocking(fd) < 0)
+        {
+          int errsv = errno;
+          g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+                       _("Failed to set pipe nonblocking: %s"), g_strerror (errsv));
+          return FALSE;
+        }
+
+      pollfds[0].fd = fd;
+      pollfds[0].events = G_IO_IN | G_IO_HUP | G_IO_ERR;
+      n_pollfds = 1;
+
+      if (cancellable_pollfd != NULL)
+        {
+          pollfds[1] = *cancellable_pollfd;
+          n_pollfds = 2;
+        }
+    }
+  else
+    n_pollfds = 0;
+
+  if (timeout >= 0)
+    start_time = g_get_monotonic_time ();
+
+  while (TRUE)
+    {
+      gssize chunk;    
+
+      if (bytes >= sizeof(gint)*2)
+        break; /* give up, who knows what happened, should not be
+                * possible.
+                */
+          
+    again:
+      if (n_pollfds != 0)
+        {
+          int r;
+
+          pollfds[0].revents = pollfds[1].revents = 0;
+
+          r = g_poll (pollfds, n_pollfds, timeout);
+
+          /* Update timeout */
+          if (timeout >= 0)
+            {
+              timeout -= (g_get_monotonic_time () - start_time) / 1000;
+              if (timeout < 0)
+                timeout = 0;
+            }
+
+          if (r < 0 && errno == EINTR)
+            goto again;
+          if (r < 0)
+            {
+              int errsv = errno;
+              g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+                           _("poll error: %s"), g_strerror (errsv));
+              return FALSE;
+            }
+          if (r == 0)
+            {
+              g_set_error_literal (error, G_SPAWN_ERROR, VTE_SPAWN_ERROR_TIMED_OUT,
+                                   _("Operation timed out"));
+              return FALSE;
+            }
+
+          /* If the passed-in poll FD becomes readable, that's the signal
+           * to cancel the operation. We do NOT actually read from its FD!
+           */
+          if (n_pollfds == 2 && pollfds[1].revents)
+            {
+              g_set_error_literal (error, G_SPAWN_ERROR, VTE_SPAWN_ERROR_CANCELLED,
+                                   _("Operation was cancelled"));
+              return FALSE;
+            }
+
+          /* Now we know we can try to read from the child */
+        }
+
+      chunk = read (fd,
+                    ((gchar*)buf) + bytes,
+                    sizeof(gint) * n_ints_in_buf - bytes);
+      if (chunk < 0 && errno == EINTR)
+        goto again;
+          
+      if (chunk < 0)
+        {
+          int errsv = errno;
+
+          /* Some weird shit happened, bail out */
+          g_set_error (error,
+                       G_SPAWN_ERROR,
+                       G_SPAWN_ERROR_FAILED,
+                       _("Failed to read from child pipe (%s)"),
+                       g_strerror (errsv));
+
+          return FALSE;
+        }
+      else if (chunk == 0)
+        break; /* EOF */
+      else /* chunk > 0 */
+       bytes += chunk;
+    }
+
+  *n_ints_read = (gint)(bytes / sizeof(gint));
+
+  return TRUE;
+}
+
+static gboolean
+fork_exec_with_pipes (gboolean              intermediate_child,
+                      const gchar          *working_directory,
+                      gchar               **argv,
+                      gchar               **envp,
+                      gboolean              close_descriptors,
+                      gboolean              search_path,
+                      gboolean              search_path_from_envp,
+                      gboolean              stdout_to_null,
+                      gboolean              stderr_to_null,
+                      gboolean              child_inherits_stdin,
+                      gboolean              file_and_argv_zero,
+                      gboolean              cloexec_pipes,
+                      GSpawnChildSetupFunc  child_setup,
+                      gpointer              user_data,
+                      GPid                 *child_pid,
+                      gint                 *standard_input,
+                      gint                 *standard_output,
+                      gint                 *standard_error,
+                      gint                  timeout,
+                      GPollFD              *pollfd,
+                      GError              **error)     
+{
+  GPid pid = -1;
+  gint stdin_pipe[2] = { -1, -1 };
+  gint stdout_pipe[2] = { -1, -1 };
+  gint stderr_pipe[2] = { -1, -1 };
+  gint child_err_report_pipe[2] = { -1, -1 };
+  gint child_pid_report_pipe[2] = { -1, -1 };
+  guint pipe_flags = cloexec_pipes ? FD_CLOEXEC : 0;
+  gint status;
+  
+  if (!g_unix_open_pipe (child_err_report_pipe, pipe_flags, error))
+    return FALSE;
+
+  if (intermediate_child && !g_unix_open_pipe (child_pid_report_pipe, pipe_flags, error))
+    goto cleanup_and_fail;
+  
+  if (standard_input && !g_unix_open_pipe (stdin_pipe, pipe_flags, error))
+    goto cleanup_and_fail;
+  
+  if (standard_output && !g_unix_open_pipe (stdout_pipe, pipe_flags, error))
+    goto cleanup_and_fail;
+
+  if (standard_error && !g_unix_open_pipe (stderr_pipe, FD_CLOEXEC, error))
+    goto cleanup_and_fail;
+
+  pid = fork ();
+
+  if (pid < 0)
+    {
+      int errsv = errno;
+
+      g_set_error (error,
+                   G_SPAWN_ERROR,
+                   G_SPAWN_ERROR_FORK,
+                   _("Failed to fork (%s)"),
+                   g_strerror (errsv));
+
+      goto cleanup_and_fail;
+    }
+  else if (pid == 0)
+    {
+      /* Immediate child. This may or may not be the child that
+       * actually execs the new process.
+       */
+
+      /* Reset some signal handlers that we may use */
+      signal (SIGCHLD, SIG_DFL);
+      signal (SIGINT, SIG_DFL);
+      signal (SIGTERM, SIG_DFL);
+      signal (SIGHUP, SIG_DFL);
+      
+      /* Be sure we crash if the parent exits
+       * and we write to the err_report_pipe
+       */
+      signal (SIGPIPE, SIG_DFL);
+
+      /* Close the parent's end of the pipes;
+       * not needed in the close_descriptors case,
+       * though
+       */
+      close_and_invalidate (&child_err_report_pipe[0]);
+      close_and_invalidate (&child_pid_report_pipe[0]);
+      close_and_invalidate (&stdin_pipe[1]);
+      close_and_invalidate (&stdout_pipe[0]);
+      close_and_invalidate (&stderr_pipe[0]);
+      
+      if (intermediate_child)
+        {
+          /* We need to fork an intermediate child that launches the
+           * final child. The purpose of the intermediate child
+           * is to exit, so we can waitpid() it immediately.
+           * Then the grandchild will not become a zombie.
+           */
+          GPid grandchild_pid;
+
+          grandchild_pid = fork ();
+
+          if (grandchild_pid < 0)
+            {
+              /* report -1 as child PID */
+              write_all (child_pid_report_pipe[1], &grandchild_pid,
+                         sizeof(grandchild_pid));
+              
+              write_err_and_exit (child_err_report_pipe[1],
+                                  CHILD_FORK_FAILED);              
+            }
+          else if (grandchild_pid == 0)
+            {
+              close_and_invalidate (&child_pid_report_pipe[1]);
+              do_exec (child_err_report_pipe[1],
+                       stdin_pipe[0],
+                       stdout_pipe[1],
+                       stderr_pipe[1],
+                       working_directory,
+                       argv,
+                       envp,
+                       close_descriptors,
+                       search_path,
+                       search_path_from_envp,
+                       stdout_to_null,
+                       stderr_to_null,
+                       child_inherits_stdin,
+                       file_and_argv_zero,
+                       child_setup,
+                       user_data);
+            }
+          else
+            {
+              write_all (child_pid_report_pipe[1], &grandchild_pid, sizeof(grandchild_pid));
+              close_and_invalidate (&child_pid_report_pipe[1]);
+              
+              _exit (0);
+            }
+        }
+      else
+        {
+          /* Just run the child.
+           */
+
+          do_exec (child_err_report_pipe[1],
+                   stdin_pipe[0],
+                   stdout_pipe[1],
+                   stderr_pipe[1],
+                   working_directory,
+                   argv,
+                   envp,
+                   close_descriptors,
+                   search_path,
+                   search_path_from_envp,
+                   stdout_to_null,
+                   stderr_to_null,
+                   child_inherits_stdin,
+                   file_and_argv_zero,
+                   child_setup,
+                   user_data);
+        }
+    }
+  else
+    {
+      /* Parent */
+      
+      gint buf[2];
+      gint n_ints = 0;    
+
+      /* Close the uncared-about ends of the pipes */
+      close_and_invalidate (&child_err_report_pipe[1]);
+      close_and_invalidate (&child_pid_report_pipe[1]);
+      close_and_invalidate (&stdin_pipe[0]);
+      close_and_invalidate (&stdout_pipe[1]);
+      close_and_invalidate (&stderr_pipe[1]);
+
+      /* If we had an intermediate child, reap it */
+      if (intermediate_child)
+        {
+        wait_again:
+          if (waitpid (pid, &status, 0) < 0)
+            {
+              if (errno == EINTR)
+                goto wait_again;
+              else if (errno == ECHILD)
+                ; /* do nothing, child already reaped */
+              else
+                g_warning ("waitpid() should not fail in "
+                          "'fork_exec_with_pipes'");
+            }
+        }
+      
+
+      if (!read_ints (child_err_report_pipe[0],
+                      buf, 2, &n_ints,
+                      timeout, pollfd,
+                      error))
+        goto cleanup_and_fail;
+        
+      if (n_ints >= 2)
+        {
+          /* Error from the child. */
+
+          switch (buf[0])
+            {
+            case CHILD_CHDIR_FAILED:
+              g_set_error (error,
+                           G_SPAWN_ERROR,
+                           G_SPAWN_ERROR_CHDIR,
+                           _("Failed to change to directory “%s” (%s)"),
+                           working_directory,
+                           g_strerror (buf[1]));
+
+              break;
+              
+            case CHILD_EXEC_FAILED:
+              g_set_error (error,
+                           G_SPAWN_ERROR,
+                           exec_err_to_g_error (buf[1]),
+                           _("Failed to execute child process “%s” (%s)"),
+                           argv[0],
+                           g_strerror (buf[1]));
+
+              break;
+              
+            case CHILD_DUP2_FAILED:
+              g_set_error (error,
+                           G_SPAWN_ERROR,
+                           G_SPAWN_ERROR_FAILED,
+                           _("Failed to redirect output or input of child process (%s)"),
+                           g_strerror (buf[1]));
+
+              break;
+
+            case CHILD_FORK_FAILED:
+              g_set_error (error,
+                           G_SPAWN_ERROR,
+                           G_SPAWN_ERROR_FORK,
+                           _("Failed to fork child process (%s)"),
+                           g_strerror (buf[1]));
+              break;
+              
+            default:
+              g_set_error (error,
+                           G_SPAWN_ERROR,
+                           G_SPAWN_ERROR_FAILED,
+                           _("Unknown error executing child process “%s”"),
+                           argv[0]);
+              break;
+            }
+
+          goto cleanup_and_fail;
+        }
+
+      /* Get child pid from intermediate child pipe. */
+      if (intermediate_child)
+        {
+          n_ints = 0;
+          
+          if (!read_ints (child_pid_report_pipe[0],
+                          buf, 1, &n_ints,
+                          timeout, pollfd,
+                          error))
+            goto cleanup_and_fail;
+
+          if (n_ints < 1)
+            {
+              int errsv = errno;
+
+              g_set_error (error,
+                           G_SPAWN_ERROR,
+                           G_SPAWN_ERROR_FAILED,
+                           _("Failed to read enough data from child pid pipe (%s)"),
+                           g_strerror (errsv));
+              goto cleanup_and_fail;
+            }
+          else
+            {
+              /* we have the child pid */
+              pid = buf[0];
+            }
+        }
+      
+      /* Success against all odds! return the information */
+      close_and_invalidate (&child_err_report_pipe[0]);
+      close_and_invalidate (&child_pid_report_pipe[0]);
+ 
+      if (child_pid)
+        *child_pid = pid;
+
+      if (standard_input)
+        *standard_input = stdin_pipe[1];
+      if (standard_output)
+        *standard_output = stdout_pipe[0];
+      if (standard_error)
+        *standard_error = stderr_pipe[0];
+      
+      return TRUE;
+    }
+
+ cleanup_and_fail:
+
+  /* There was an error from the Child, reap the child to avoid it being
+     a zombie.
+   */
+
+  if (pid > 0)
+    {
+      vte_reaper_add_child(pid);
+     }
+
+  close_and_invalidate (&child_err_report_pipe[0]);
+  close_and_invalidate (&child_err_report_pipe[1]);
+  close_and_invalidate (&child_pid_report_pipe[0]);
+  close_and_invalidate (&child_pid_report_pipe[1]);
+  close_and_invalidate (&stdin_pipe[0]);
+  close_and_invalidate (&stdin_pipe[1]);
+  close_and_invalidate (&stdout_pipe[0]);
+  close_and_invalidate (&stdout_pipe[1]);
+  close_and_invalidate (&stderr_pipe[0]);
+  close_and_invalidate (&stderr_pipe[1]);
+
+  return FALSE;
+}
+
+/* Based on execvp from GNU C Library */
+
+static void
+script_execute (const gchar *file,
+                gchar      **argv,
+                gchar      **envp)
+{
+  /* Count the arguments.  */
+  int argc = 0;
+  while (argv[argc])
+    ++argc;
+  
+  /* Construct an argument list for the shell.  */
+  {
+    gchar **new_argv;
+
+    new_argv = g_new0 (gchar*, argc + 2); /* /bin/sh and NULL */
+    
+    new_argv[0] = (char *) "/bin/sh";
+    new_argv[1] = (char *) file;
+    while (argc > 0)
+      {
+       new_argv[argc + 1] = argv[argc];
+       --argc;
+      }
+
+    /* Execute the shell. */
+    if (envp)
+      execve (new_argv[0], new_argv, envp);
+    else
+      execv (new_argv[0], new_argv);
+    
+    g_free (new_argv);
+  }
+}
+
+static gchar*
+my_strchrnul (const gchar *str, gchar c)
+{
+  gchar *p = (gchar*) str;
+  while (*p && (*p != c))
+    ++p;
+
+  return p;
+}
+
+static gint
+g_execute (const gchar *file,
+           gchar      **argv,
+           gchar      **envp,
+           gboolean     search_path,
+           gboolean     search_path_from_envp)
+{
+  if (*file == '\0')
+    {
+      /* We check the simple case first. */
+      errno = ENOENT;
+      return -1;
+    }
+
+  if (!(search_path || search_path_from_envp) || strchr (file, '/') != NULL)
+    {
+      /* Don't search when it contains a slash. */
+      if (envp)
+        execve (file, argv, envp);
+      else
+        execv (file, argv);
+      
+      if (errno == ENOEXEC)
+       script_execute (file, argv, envp);
+    }
+  else
+    {
+      gboolean got_eacces = 0;
+      const gchar *path, *p;
+      gchar *name, *freeme;
+      gsize len;
+      gsize pathlen;
+
+      path = NULL;
+      if (search_path_from_envp)
+        path = g_environ_getenv (envp, "PATH");
+      if (search_path && path == NULL)
+        path = g_getenv ("PATH");
+
+      if (path == NULL)
+       {
+         /* There is no 'PATH' in the environment.  The default
+          * search path in libc is the current directory followed by
+          * the path 'confstr' returns for '_CS_PATH'.
+           */
+
+          /* In GLib we put . last, for security, and don't use the
+           * unportable confstr(); UNIX98 does not actually specify
+           * what to search if PATH is unset. POSIX may, dunno.
+           */
+          
+          path = "/bin:/usr/bin:.";
+       }
+
+      len = strlen (file) + 1;
+      pathlen = strlen (path);
+      freeme = name = (char*)g_malloc (pathlen + len + 1);
+      
+      /* Copy the file name at the top, including '\0'  */
+      memcpy (name + pathlen + 1, file, len);
+      name = name + pathlen;
+      /* And add the slash before the filename  */
+      *name = '/';
+
+      p = path;
+      do
+       {
+         char *startp;
+
+         path = p;
+         p = my_strchrnul (path, ':');
+
+         if (p == path)
+           /* Two adjacent colons, or a colon at the beginning or the end
+             * of 'PATH' means to search the current directory.
+             */
+           startp = name + 1;
+         else
+            startp = (char*)memcpy (name - (p - path), path, p - path);
+
+         /* Try to execute this name.  If it works, execv will not return.  */
+          if (envp)
+            execve (startp, argv, envp);
+          else
+            execv (startp, argv);
+          
+         if (errno == ENOEXEC)
+           script_execute (startp, argv, envp);
+
+         switch (errno)
+           {
+           case EACCES:
+             /* Record the we got a 'Permission denied' error.  If we end
+               * up finding no executable we can use, we want to diagnose
+               * that we did find one but were denied access.
+               */
+             got_eacces = TRUE;
+
+              /* FALL THRU */
+              
+           case ENOENT:
+#ifdef ESTALE
+           case ESTALE:
+#endif
+#ifdef ENOTDIR
+           case ENOTDIR:
+#endif
+             /* Those errors indicate the file is missing or not executable
+               * by us, in which case we want to just try the next path
+               * directory.
+               */
+             break;
+
+           case ENODEV:
+           case ETIMEDOUT:
+             /* Some strange filesystems like AFS return even
+              * stranger error numbers.  They cannot reasonably mean anything
+              * else so ignore those, too.
+              */
+             break;
+
+           default:
+             /* Some other error means we found an executable file, but
+               * something went wrong executing it; return the error to our
+               * caller.
+               */
+              g_free (freeme);
+             return -1;
+           }
+       }
+      while (*p++ != '\0');
+
+      /* We tried every element and none of them worked.  */
+      if (got_eacces)
+       /* At least one failure was due to permissions, so report that
+         * error.
+         */
+        errno = EACCES;
+
+      g_free (freeme);
+    }
+
+  /* Return the error from the last attempt (probably ENOENT).  */
+  return -1;
+}
diff --git a/src/vtespawn.hh b/src/vtespawn.hh
new file mode 100644
index 0000000..6b75e3e
--- /dev/null
+++ b/src/vtespawn.hh
@@ -0,0 +1,48 @@
+/* gspawn.h - Process launching
+ *
+ *  Copyright 2000 Red Hat, Inc.
+ *
+ * GLib is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * GLib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GLib; see the file COPYING.LIB.  If not, write
+ * to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#pragma once
+
+#include <glib.h>
+
+gboolean vte_spawn_async_cancellable (const gchar          *working_directory,
+                                      gchar               **argv,
+                                      gchar               **envp,
+                                      GSpawnFlags           flags,
+                                      GSpawnChildSetupFunc  child_setup,
+                                      gpointer              user_data,
+                                      GPid                 *child_pid,
+                                      gint                  timeout,
+                                      GPollFD              *pollfd,
+                                      GError              **error);
+
+gboolean vte_spawn_async_with_pipes_cancellable (const gchar          *working_directory,
+                                                 gchar               **argv,
+                                                 gchar               **envp,
+                                                 GSpawnFlags           flags,
+                                                 GSpawnChildSetupFunc  child_setup,
+                                                 gpointer              user_data,
+                                                 GPid                 *child_pid,
+                                                 gint                 *standard_input,
+                                                 gint                 *standard_output,
+                                                 gint                 *standard_error,
+                                                 gint                  timeout,
+                                                 GPollFD              *pollfd,
+                                                 GError              **error);



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]