GSubprocess: New class for spawning child processeswip/latest-gsubprocess

There are a number of nice things this class brings:

0) Has a race-free termination API on all platforms (on UNIX, calls to
   kill() and waitpid() are coordinated as not to cause problems).
1) Operates in terms of G{Input,Output}Stream, not file descriptors
2) Standard GIO-style async API for wait() with cancellation
3) Makes some simple cases easy, like synchronously spawning a
   process with an argument list
4) Makes hard cases possible, like asynchronously running a process
   with stdout/stderr merged, output directly to a file path

Much rewriting and code review from Ryan Lortie <desrt@desrt.ca>

https://bugzilla.gnome.org/show_bug.cgi?id=672102

17 files changed, 3795 insertions, 54 deletions

diff --git a/docs/reference/gio/gio-docs.xml b/docs/reference/gio/gio-docs.xml
index b2ddae2f7..f8fa04d2b 100644
--- a/docs/reference/gio/gio-docs.xml
+++ b/docs/reference/gio/gio-docs.xml
@@ -108,6 +108,10 @@
         <xi:include href="xml/ginitable.xml"/>
         <xi:include href="xml/gasyncinitable.xml"/>
     </chapter>
+    <chapter id="subprocesses">
+      <title>Subprocesses</title>
+      <xi:include href="xml/gsubprocess.xml"/>
+    </chapter>
     <chapter id="networking">
       <title>Low-level network support</title>
       <xi:include href="xml/gsocket.xml"/>
diff --git a/docs/reference/gio/gio-sections.txt b/docs/reference/gio/gio-sections.txt
index c85cfef56..4f01b0b7b 100644
--- a/docs/reference/gio/gio-sections.txt
+++ b/docs/reference/gio/gio-sections.txt
@@ -4072,3 +4072,37 @@ G_IS_SIMPLE_PROXY_RESOLVER_CLASS
 G_SIMPLE_PROXY_RESOLVER_GET_CLASS
 g_simple_proxy_resolver_get_type
 </SECTION>
+
+<FILE>gsubprocess</FILE>
+<TITLE>GSubprocess</TITLE>
+GSubprocess
+g_subprocess_new
+g_subprocess_newv
+<SUBSECTION IO>
+g_subprocess_get_stdin_pipe
+g_subprocess_get_stdout_pipe
+g_subprocess_get_stderr_pipe
+<SUBSECTION Waiting>
+g_subprocess_wait
+g_subprocess_wait_sync
+g_subprocess_wait_finish
+g_subprocess_wait_check
+g_subprocess_wait_check_sync
+g_subprocess_wait_check_finish
+<SUBSECTION Status>
+g_subprocess_get_successful
+g_subprocess_get_if_exited
+g_subprocess_get_exit_status
+g_subprocess_get_if_signaled
+g_subprocess_get_term_sig
+g_subprocess_get_status
+<SUBSECTION Control>
+g_subprocess_send_signal
+g_subprocess_force_exit
+<SUBSECTION Standard>
+G_IS_SUBPROCESS
+G_TYPE_SUBPROCESS
+G_SUBPROCESS
+<SUBSECTION Private>
+g_subprocess_get_type
+</SECTION>
diff --git a/docs/reference/gio/gio.types b/docs/reference/gio/gio.types
index 8e4825df5..8f5600b7b 100644
--- a/docs/reference/gio/gio.types
+++ b/docs/reference/gio/gio.types
@@ -137,3 +137,4 @@ g_test_dbus_get_type
 g_test_dbus_flags_get_type
 g_task_get_type
 g_simple_proxy_resolver_get_type
+g_subprocess_get_type
diff --git a/gio/Makefile.am b/gio/Makefile.am
index 20d7c60b5..8965c05d3 100644
--- a/gio/Makefile.am
+++ b/gio/Makefile.am
@@ -428,6 +428,9 @@ libgio_2_0_la_SOURCES =		\
 	gsocketoutputstream.h	\
 	gsocketservice.c	\
 	gsrvtarget.c		\
+	gsubprocesslauncher.c	\
+	gsubprocess.c		\
+	gsubprocesslauncher-private.h	\
 	gsimpleproxyresolver.c	\
 	gtask.c			\
 	gtcpconnection.c	\
@@ -590,6 +593,8 @@ gio_headers =			\
 	gsrvtarget.h		\
 	gsimpleproxyresolver.h	\
 	gtask.h			\
+	gsubprocess.h		\
+	gsubprocesslauncher.h	\
 	gtcpconnection.h	\
 	gtcpwrapperconnection.h \
 	gthreadedsocketservice.h\
diff --git a/gio/gio.h b/gio/gio.h
index fadcd58a6..04a8770d9 100644
--- a/gio/gio.h
+++ b/gio/gio.h
@@ -126,6 +126,8 @@
 #include <gio/gsrvtarget.h>
 #include <gio/gsimpleproxyresolver.h>
 #include <gio/gtask.h>
+#include <gio/gsubprocess.h>
+#include <gio/gsubprocesslauncher.h>
 #include <gio/gtcpconnection.h>
 #include <gio/gtcpwrapperconnection.h>
 #include <gio/gtestdbus.h>
diff --git a/gio/gioenums.h b/gio/gioenums.h
index 976722639..44f881879 100644
--- a/gio/gioenums.h
+++ b/gio/gioenums.h
@@ -1666,6 +1666,56 @@ typedef enum /*< flags >*/ {
   G_TEST_DBUS_NONE = 0
 } GTestDBusFlags;
 
+/**
+ * GSubprocessFlags:
+ * @G_SUBPROCESS_FLAGS_NONE: No flags.
+ * @G_SUBPROCESS_FLAGS_STDIN_PIPE: create a pipe for the stdin of the
+ *   spawned process that can be accessed with
+ *   g_subprocess_get_stdin_pipe().
+ * @G_SUBPROCESS_FLAGS_STDIN_INHERIT: stdin is inherited from the
+ *   calling process.
+ * @G_SUBPROCESS_FLAGS_STDOUT_PIPE: create a pipe for the stdout of the
+ *   spawned process that can be accessed with
+ *   g_subprocess_get_stdout_pipe().
+ * @G_SUBPROCESS_FLAGS_STDOUT_SILENCE: silence the stdout of the spawned
+ *   process (ie: redirect to /dev/null).
+ * @G_SUBPROCESS_FLAGS_STDERR_PIPE: create a pipe for the stderr of the
+ *   spawned process that can be accessed with
+ *   g_subprocess_get_stderr_pipe().
+ * @G_SUBPROCESS_FLAGS_STDERR_SILENCE: silence the stderr of the spawned
+ *   process (ie: redirect to /dev/null).
+ * @G_SUBPROCESS_FLAGS_STDERR_MERGE: merge the stderr of the spawned
+ *   process with whatever the stdout happens to be.  This is a good way
+ *   of directing both streams to a common log file, for example.
+ * @G_SUBPROCESS_FLAGS_INHERIT_FDS: spawned processes will inherit the
+ *   file descriptors of their parent, unless those descriptors have
+ *   been explicitly marked as close-on-exec.  This flag has no effect
+ *   over the "standard" file descriptors (stdin, stdout, stderr).
+ *
+ * Flags to define the behaviour of a #GSubprocess.
+ *
+ * Note that the default for stdin is to redirect from /dev/null.  For
+ * stdout and stderr the default are for them to inherit the
+ * corresponding descriptor from the calling process.
+ *
+ * Note that it is a programmer error to mix 'incompatible' flags.  For
+ * example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
+ * %G_SUBPROCESS_FLAGS_STDOUT_SILENCE.
+ *
+ * Since: 2.36
+ **/
+typedef enum {
+  G_SUBPROCESS_FLAGS_NONE                  = 0,
+  G_SUBPROCESS_FLAGS_STDIN_PIPE            = (1u << 0),
+  G_SUBPROCESS_FLAGS_STDIN_INHERIT         = (1u << 1),
+  G_SUBPROCESS_FLAGS_STDOUT_PIPE           = (1u << 2),
+  G_SUBPROCESS_FLAGS_STDOUT_SILENCE        = (1u << 3),
+  G_SUBPROCESS_FLAGS_STDERR_PIPE           = (1u << 4),
+  G_SUBPROCESS_FLAGS_STDERR_SILENCE        = (1u << 5),
+  G_SUBPROCESS_FLAGS_STDERR_MERGE          = (1u << 6),
+  G_SUBPROCESS_FLAGS_INHERIT_FDS           = (1u << 7)
+} GSubprocessFlags;
+
 G_END_DECLS
 
 #endif /* __GIO_ENUMS_H__ */
diff --git a/gio/giotypes.h b/gio/giotypes.h
index adcbdae67..db81f832b 100644
--- a/gio/giotypes.h
+++ b/gio/giotypes.h
@@ -137,6 +137,7 @@ typedef struct _GIOStream                     GIOStream;
 typedef struct _GPollableInputStream          GPollableInputStream; /* Dummy typedef */
 typedef struct _GPollableOutputStream         GPollableOutputStream; /* Dummy typedef */
 typedef struct _GResolver                     GResolver;
+
 /**
  * GResource:
  *
@@ -470,6 +471,23 @@ typedef GType (*GDBusProxyTypeFunc) (GDBusObjectManagerClient   *manager,
 
 typedef struct _GTestDBus GTestDBus;
 
+/**
+ * GSubprocess:
+ *
+ * A child process.
+ *
+ * Since: 2.36
+ */
+typedef struct _GSubprocess                   GSubprocess;
+/**
+ * GSubprocessLauncher:
+ *
+ * Options for launching a child process.
+ *
+ * Since: 2.36
+ */
+typedef struct _GSubprocessLauncher           GSubprocessLauncher;
+
 G_END_DECLS
 
 #endif /* __GIO_TYPES_H__ */
diff --git a/gio/glib-compile-resources.c b/gio/glib-compile-resources.c
index 6ec3076f4..d7dd58014 100644
--- a/gio/glib-compile-resources.c
+++ b/gio/glib-compile-resources.c
@@ -297,9 +297,8 @@ end_element (GMarkupParseContext  *context,
 
           if (xml_stripblanks && xmllint != NULL)
             {
-              gchar *argv[8];
-              int status, fd, argc;
-              gchar *stderr_child = NULL;
+              int fd;
+	      GSubprocess *proc;
 
               tmp_file = g_strdup ("resource-XXXXXXXX");
               if ((fd = g_mkstemp (tmp_file)) == -1)
@@ -315,43 +314,29 @@ end_element (GMarkupParseContext  *context,
                 }
               close (fd);
 
-              argc = 0;
-              argv[argc++] = (gchar *) xmllint;
-              argv[argc++] = "--nonet";
-              argv[argc++] = "--noblanks";
-              argv[argc++] = "--output";
-              argv[argc++] = tmp_file;
-              argv[argc++] = real_file;
-              argv[argc++] = NULL;
-              g_assert (argc <= G_N_ELEMENTS (argv));
-
-              if (!g_spawn_sync (NULL /* cwd */, argv, NULL /* envv */,
-                                 G_SPAWN_STDOUT_TO_DEV_NULL,
-                                 NULL, NULL, NULL, &stderr_child, &status, &my_error))
-                {
-                  g_propagate_error (error, my_error);
-                  goto cleanup;
-                }
-	      
-	      /* Ugly...we shoud probably just let stderr be inherited */
-	      if (!g_spawn_check_exit_status (status, NULL))
-                {
-                  g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
-                               _("Error processing input file with xmllint:\n%s"), stderr_child);
-                  g_free (stderr_child);
+              proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error,
+                                       xmllint, "--nonet", "--noblanks", "--output", tmp_file, real_file, NULL);
+              g_free (real_file);
+	      real_file = NULL;
+
+	      if (!proc)
+		goto cleanup;
+
+	      if (!g_subprocess_wait_check (proc, NULL, error))
+		{
+		  g_object_unref (proc);
                   goto cleanup;
                 }
 
-              g_free (stderr_child);
-              g_free (real_file);
+	      g_object_unref (proc);
+
               real_file = g_strdup (tmp_file);
             }
 
           if (to_pixdata)
             {
-              gchar *argv[4];
-              gchar *stderr_child = NULL;
-              int status, fd, argc;
+              int fd;
+	      GSubprocess *proc;
 
               if (gdk_pixbuf_pixdata == NULL)
                 {
@@ -375,31 +360,19 @@ end_element (GMarkupParseContext  *context,
                 }
               close (fd);
 
-              argc = 0;
-              argv[argc++] = (gchar *) gdk_pixbuf_pixdata;
-              argv[argc++] = real_file;
-              argv[argc++] = tmp_file2;
-              argv[argc++] = NULL;
-              g_assert (argc <= G_N_ELEMENTS (argv));
+              proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error,
+                                       gdk_pixbuf_pixdata, real_file, tmp_file2, NULL);
+              g_free (real_file);
+              real_file = NULL;
 
-              if (!g_spawn_sync (NULL /* cwd */, argv, NULL /* envv */,
-                                 G_SPAWN_STDOUT_TO_DEV_NULL,
-                                 NULL, NULL, NULL, &stderr_child, &status, &my_error))
-                {
-                  g_propagate_error (error, my_error);
-                  goto cleanup;
-                }
-	      
-	      if (!g_spawn_check_exit_status (status, NULL))
-                {
-                  g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
-			       _("Error processing input file with to-pixdata:\n%s"), stderr_child);
-                  g_free (stderr_child);
+	      if (!g_subprocess_wait_check (proc, NULL, error))
+		{
+		  g_object_unref (proc);
                   goto cleanup;
-                }
+		}
+
+	      g_object_unref (proc);
 
-              g_free (stderr_child);
-              g_free (real_file);
               real_file = g_strdup (tmp_file2);
             }
 	}
diff --git a/gio/gsubprocess.c b/gio/gsubprocess.c
new file mode 100644
index 000000000..26f9eb1be
--- /dev/null
+++ b/gio/gsubprocess.c
@@ -0,0 +1,1695 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright © 2012 Red Hat, Inc.
+ * Copyright © 2012-2013 Canonical Limited
+ *
+ * This program 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 licence or (at
+ * your option) any later version.
+ *
+ * See the included COPYING file for more information.
+ *
+ * Authors: Colin Walters <walters@verbum.org>
+ *          Ryan Lortie <desrt@desrt.ca>
+ */
+
+/**
+ * SECTION:gsubprocess
+ * @title: GSubprocess
+ * @short_description: Child processes
+ * @see_also: #GSubprocessLauncher
+ *
+ * #GSubprocess allows the creation of and interaction with child
+ * processes.
+ *
+ * Processes can be communicated with using standard GIO-style APIs (ie:
+ * #GInputStream, #GOutputStream).  There are GIO-style APIs to wait for
+ * process termination (ie: cancellable and with an asynchronous
+ * variant).
+ *
+ * There is an API to force a process to terminate, as well as a
+ * race-free API for sending UNIX signals to a subprocess.
+ *
+ * One major advantage that GIO brings over the core GLib library is
+ * comprehensive API for asynchronous I/O, such
+ * g_output_stream_splice_async().  This makes GSubprocess
+ * significantly more powerful and flexible than equivalent APIs in
+ * some other languages such as the <literal>subprocess.py</literal>
+ * included with Python.  For example, using #GSubprocess one could
+ * create two child processes, reading standard output from the first,
+ * processing it, and writing to the input stream of the second, all
+ * without blocking the main loop.
+ *
+ * A powerful g_subprocess_communicate() API is provided similar to the
+ * <literal>communicate()</literal> method of
+ * <literal>subprocess.py</literal>.  This enables very easy interaction
+ * with a subprocess that has been opened with pipes.
+ *
+ * #GSubprocess defaults to tight control over the file descriptors open
+ * in the child process, avoiding dangling-fd issues that are caused by
+ * a simple fork()/exec().  The only open file descriptors in the
+ * spawned process are ones that were explicitly specified by the
+ * #GSubprocess API (unless %G_SUBPROCESS_FLAGS_INHERIT_FDS was
+ * specified).
+ *
+ * #GSubprocess will quickly reap all child processes as they exit,
+ * avoiding "zombie processes" remaining around for long periods of
+ * time.  g_subprocess_wait() can be used to wait for this to happen,
+ * but it will happen even without the call being explicitly made.
+ *
+ * As a matter of principle, #GSubprocess has no API that accepts
+ * shell-style space-separated strings.  It will, however, match the
+ * typical shell behaviour of searching the PATH for executables that do
+ * not contain a directory separator in their name.
+ *
+ * #GSubprocess attempts to have a very simple API for most uses (ie:
+ * spawning a subprocess with arguments and support for most typical
+ * kinds of input and output redirection).  See g_subprocess_new(). The
+ * #GSubprocessLauncher API is provided for more complicated cases
+ * (advanced types of redirection, environment variable manipulation,
+ * change of working directory, child setup functions, etc).
+ *
+ * A typical use of #GSubprocess will involve calling
+ * g_subprocess_new(), followed by g_subprocess_wait() or
+ * g_subprocess_wait_sync().  After the process exits, the status can be
+ * checked using functions such as g_subprocess_get_if_exited() (which
+ * are similar to the familiar WIFEXITED-style POSIX macros).
+ *
+ * Since: 2.36
+ **/
+
+#include "config.h"
+
+#include "gsubprocess.h"
+#include "gsubprocesslauncher-private.h"
+#include "gasyncresult.h"
+#include "giostream.h"
+#include "gmemoryinputstream.h"
+#include "glibintl.h"
+#include "glib-private.h"
+
+#include <string.h>
+#ifdef G_OS_UNIX
+#include <gio/gunixoutputstream.h>
+#include <gio/gfiledescriptorbased.h>
+#include <gio/gunixinputstream.h>
+#include <gstdio.h>
+#include <glib-unix.h>
+#include <fcntl.h>
+#endif
+#ifdef G_OS_WIN32
+#define _WIN32_WINNT 0x0500
+#include <windows.h>
+#include "giowin32-priv.h"
+#endif
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+#define COMMUNICATE_READ_SIZE 4096
+
+/* A GSubprocess can have two possible states: running and not.
+ *
+ * These two states are reflected by the value of 'pid'.  If it is
+ * non-zero then the process is running, with that pid.
+ *
+ * When a GSubprocess is first created with g_object_new() it is not
+ * running.  When it is finalized, it is also not running.
+ *
+ * During initable_init(), if the g_spawn() is successful then we
+ * immediately register a child watch and take an extra ref on the
+ * subprocess.  That reference doesn't drop until the child has quit,
+ * which is why finalize can only happen in the non-running state.  In
+ * the event that the g_spawn() failed we will still be finalizing a
+ * non-running GSubprocess (before returning from g_subprocess_new())
+ * with NULL.
+ *
+ * We make extensive use of the glib worker thread to guarantee
+ * race-free operation.  As with all child watches, glib calls waitpid()
+ * in the worker thread.  It reports the child exiting to us via the
+ * worker thread (which means that we can do synchronous waits without
+ * running a separate loop).  We also send signals to the child process
+ * via the worker thread so that we don't race with waitpid() and
+ * accidentally send a signal to an already-reaped child.
+ */
+static void initable_iface_init (GInitableIface         *initable_iface);
+
+typedef GObjectClass GSubprocessClass;
+
+struct _GSubprocess
+{
+  GObject parent;
+
+  /* only used during construction */
+  GSubprocessLauncher *launcher;
+  GSubprocessFlags flags;
+  gchar **argv;
+
+  /* state tracking variables */
+  gchar identifier[24];
+  int status;
+  GPid pid;
+
+  /* list of GTask */
+  GMutex pending_waits_lock;
+  GSList *pending_waits;
+
+  /* These are the streams created if a pipe is requested via flags. */
+  GOutputStream *stdin_pipe;
+  GInputStream  *stdout_pipe;
+  GInputStream  *stderr_pipe;
+};
+
+G_DEFINE_TYPE_WITH_CODE (GSubprocess, g_subprocess, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init));
+
+enum
+{
+  PROP_0,
+  PROP_FLAGS,
+  PROP_ARGV,
+  N_PROPS
+};
+
+typedef struct
+{
+  gint                 fds[3];
+  GSpawnChildSetupFunc child_setup_func;
+  gpointer             child_setup_data;
+} ChildData;
+
+static void
+child_setup (gpointer user_data)
+{
+  ChildData *child_data = user_data;
+  gint i;
+
+  /* We're on the child side now.  "Rename" the file descriptors in
+   * child_data.fds[] to stdin/stdout/stderr.
+   *
+   * We don't close the originals.  It's possible that the originals
+   * should not be closed and if they should be closed then they should
+   * have been created O_CLOEXEC.
+   */
+  for (i = 0; i < 3; i++)
+    if (child_data->fds[i] != -1 && child_data->fds[i] != i)
+      {
+        gint result;
+
+        do
+          result = dup2 (child_data->fds[i], i);
+        while (result == -1 && errno == EINTR);
+      }
+
+  if (child_data->child_setup_func)
+    child_data->child_setup_func (child_data->child_setup_data);
+}
+
+static GInputStream *
+platform_input_stream_from_spawn_fd (gint fd)
+{
+  if (fd < 0)
+    return NULL;
+
+#ifdef G_OS_UNIX
+  return g_unix_input_stream_new (fd, TRUE);
+#else
+  return g_win32_input_stream_new_from_fd (fd, TRUE);
+#endif
+}
+
+static GOutputStream *
+platform_output_stream_from_spawn_fd (gint fd)
+{
+  if (fd < 0)
+    return NULL;
+
+#ifdef G_OS_UNIX
+  return g_unix_output_stream_new (fd, TRUE);
+#else
+  return g_win32_output_stream_new_from_fd (fd, TRUE);
+#endif
+}
+
+#ifdef G_OS_UNIX
+static gint
+unix_open_file (const char  *filename,
+                gint         mode,
+                GError     **error)
+{
+  gint my_fd;
+
+  my_fd = g_open (filename, mode | O_BINARY | O_CLOEXEC, 0666);
+
+  /* If we return -1 we should also set the error */
+  if (my_fd < 0)
+    {
+      gint saved_errno = errno;
+      char *display_name;
+
+      display_name = g_filename_display_name (filename);
+      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (saved_errno),
+                   _("Error opening file '%s': %s"), display_name,
+                   g_strerror (saved_errno));
+      g_free (display_name);
+      /* fall through... */
+    }
+
+  return my_fd;
+}
+#endif
+
+static void
+g_subprocess_set_property (GObject      *object,
+                           guint         prop_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  GSubprocess *self = G_SUBPROCESS (object);
+
+  switch (prop_id)
+    {
+    case PROP_FLAGS:
+      self->flags = g_value_get_flags (value);
+      break;
+
+    case PROP_ARGV:
+      self->argv = g_value_dup_boxed (value);
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static gboolean
+g_subprocess_exited (GPid     pid,
+                     gint     status,
+                     gpointer user_data)
+{
+  GSubprocess *self = user_data;
+  GSList *tasks;
+
+  g_assert (self->pid == pid);
+
+  g_mutex_lock (&self->pending_waits_lock);
+  self->status = status;
+  tasks = self->pending_waits;
+  self->pending_waits = NULL;
+  self->pid = 0;
+  g_mutex_unlock (&self->pending_waits_lock);
+
+  /* Signal anyone in g_subprocess_wait_async() to wake up now */
+  while (tasks)
+    {
+      g_task_return_boolean (tasks->data, TRUE);
+      tasks = g_slist_delete_link (tasks, tasks);
+    }
+
+  g_spawn_close_pid (pid);
+
+  return FALSE;
+}
+
+static gboolean
+initable_init (GInitable     *initable,
+               GCancellable  *cancellable,
+               GError       **error)
+{
+  GSubprocess *self = G_SUBPROCESS (initable);
+  ChildData child_data = { { -1, -1, -1 } };
+  gint *pipe_ptrs[3] = { NULL, NULL, NULL };
+  gint pipe_fds[3] = { -1, -1, -1 };
+  gint close_fds[3] = { -1, -1, -1 };
+  GSpawnFlags spawn_flags = 0;
+  gboolean success = FALSE;
+  gint i;
+
+  /* this is a programmer error */
+  if (!self->argv || !self->argv[0] || !self->argv[0][0])
+    return FALSE;
+
+  if (g_cancellable_set_error_if_cancelled (cancellable, error))
+    return FALSE;
+
+  /* We must setup the three fds that will end up in the child as stdin,
+   * stdout and stderr.
+   *
+   * First, stdin.
+   */
+  if (self->flags & G_SUBPROCESS_FLAGS_STDIN_INHERIT)
+    spawn_flags |= G_SPAWN_CHILD_INHERITS_STDIN;
+  else if (self->flags & G_SUBPROCESS_FLAGS_STDIN_PIPE)
+    pipe_ptrs[0] = &pipe_fds[0];
+#ifdef G_OS_UNIX
+  else if (self->launcher)
+    {
+      if (self->launcher->stdin_fd != -1)
+        child_data.fds[0] = self->launcher->stdin_fd;
+      else if (self->launcher->stdin_path != NULL)
+        {
+          child_data.fds[0] = close_fds[0] = unix_open_file (self->launcher->stdin_path, O_RDONLY, error);
+          if (child_data.fds[0] == -1)
+            goto out;
+        }
+    }
+#endif
+
+  /* Next, stdout. */
+  if (self->flags & G_SUBPROCESS_FLAGS_STDOUT_SILENCE)
+    spawn_flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
+  else if (self->flags & G_SUBPROCESS_FLAGS_STDOUT_PIPE)
+    pipe_ptrs[1] = &pipe_fds[1];
+#ifdef G_OS_UNIX
+  else if (self->launcher)
+    {
+      if (self->launcher->stdout_fd != -1)
+        child_data.fds[1] = self->launcher->stdout_fd;
+      else if (self->launcher->stdout_path != NULL)
+        {
+          child_data.fds[1] = close_fds[1] = unix_open_file (self->launcher->stdout_path, O_CREAT | O_WRONLY, error);
+          if (child_data.fds[1] == -1)
+            goto out;
+        }
+    }
+#endif
+
+  /* Finally, stderr. */
+  if (self->flags & G_SUBPROCESS_FLAGS_STDERR_SILENCE)
+    spawn_flags |= G_SPAWN_STDERR_TO_DEV_NULL;
+  else if (self->flags & G_SUBPROCESS_FLAGS_STDERR_PIPE)
+    pipe_ptrs[2] = &pipe_fds[2];
+  else if (self->flags & G_SUBPROCESS_FLAGS_STDERR_MERGE)
+    /* This will work because stderr gets setup after stdout. */
+    child_data.fds[2] = 1;
+#ifdef G_OS_UNIX
+  else if (self->launcher)
+    {
+      if (self->launcher->stderr_fd != -1)
+        child_data.fds[2] = self->launcher->stderr_fd;
+      else if (self->launcher->stderr_path != NULL)
+        {
+          child_data.fds[2] = close_fds[2] = unix_open_file (self->launcher->stderr_path, O_CREAT | O_WRONLY, error);
+          if (child_data.fds[2] == -1)
+            goto out;
+        }
+    }
+#endif
+
+  /* argv0 has no '/' in it?  We better do a PATH lookup. */
+  if (strchr (self->argv[0], G_DIR_SEPARATOR) == NULL)
+    {
+      if (self->launcher && self->launcher->path_from_envp)
+        spawn_flags |= G_SPAWN_SEARCH_PATH_FROM_ENVP;
+      else
+        spawn_flags |= G_SPAWN_SEARCH_PATH;
+    }
+
+  if (self->flags & G_SUBPROCESS_FLAGS_INHERIT_FDS)
+    spawn_flags |= G_SPAWN_LEAVE_DESCRIPTORS_OPEN;
+
+  spawn_flags |= G_SPAWN_DO_NOT_REAP_CHILD;
+  spawn_flags |= G_SPAWN_CLOEXEC_PIPES;
+
+  child_data.child_setup_func = self->launcher ? self->launcher->child_setup_func : NULL;
+  child_data.child_setup_data = self->launcher ? self->launcher->child_setup_user_data : NULL;
+  success = g_spawn_async_with_pipes (self->launcher ? self->launcher->cwd : NULL,
+                                      self->argv,
+                                      self->launcher ? self->launcher->envp : NULL,
+                                      spawn_flags,
+                                      child_setup, &child_data,
+                                      &self->pid,
+                                      pipe_ptrs[0], pipe_ptrs[1], pipe_ptrs[2],
+                                      error);
+  g_assert (success == (self->pid != 0));
+
+  {
+    guint64 identifier;
+    gint s;
+
+#ifdef G_OS_WIN32
+    identifier = (guint64) GetProcessId (self->pid);
+#else
+    identifier = (guint64) self->pid;
+#endif
+
+    s = snprintf (self->identifier, sizeof self->identifier, "%"G_GUINT64_FORMAT, identifier);
+    g_assert (0 < s && s < sizeof self->identifier);
+  }
+
+  /* Start attempting to reap the child immediately */
+  if (success)
+    {
+      GMainContext *worker_context;
+      GSource *source;
+
+      worker_context = GLIB_PRIVATE_CALL (g_get_worker_context) ();
+      source = g_child_watch_source_new (self->pid);
+      g_source_set_callback (source, (GSourceFunc) g_subprocess_exited, g_object_ref (self), g_object_unref);
+      g_source_attach (source, worker_context);
+      g_source_unref (source);
+    }
+
+out:
+  /* we don't need this past init... */
+  self->launcher = NULL;
+
+  for (i = 0; i < 3; i++)
+    if (close_fds[i] != -1)
+      close (close_fds[i]);
+
+  self->stdin_pipe = platform_output_stream_from_spawn_fd (pipe_fds[0]);
+  self->stdout_pipe = platform_input_stream_from_spawn_fd (pipe_fds[1]);
+  self->stderr_pipe = platform_input_stream_from_spawn_fd (pipe_fds[2]);
+
+  return success;
+}
+
+static void
+g_subprocess_finalize (GObject *object)
+{
+  GSubprocess *self = G_SUBPROCESS (object);
+
+  g_assert (self->pending_waits == NULL);
+  g_assert (self->pid == 0);
+
+  g_clear_object (&self->stdin_pipe);
+  g_clear_object (&self->stdout_pipe);
+  g_clear_object (&self->stderr_pipe);
+  g_free (self->argv);
+
+  G_OBJECT_CLASS (g_subprocess_parent_class)->finalize (object);
+}
+
+static void
+g_subprocess_init (GSubprocess  *self)
+{
+}
+
+static void
+initable_iface_init (GInitableIface *initable_iface)
+{
+  initable_iface->init = initable_init;
+}
+
+static void
+g_subprocess_class_init (GSubprocessClass *class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+  gobject_class->finalize = g_subprocess_finalize;
+  gobject_class->set_property = g_subprocess_set_property;
+
+  g_object_class_install_property (gobject_class, PROP_FLAGS,
+                                   g_param_spec_flags ("flags", P_("Flags"), P_("Subprocess flags"),
+                                                       G_TYPE_SUBPROCESS_FLAGS, 0, G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_ARGV,
+                                   g_param_spec_boxed ("argv", P_("Arguments"), P_("Argument vector"),
+                                                       G_TYPE_STRV, G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+}
+
+/**
+ * g_subprocess_new: (skip)
+ *
+ * Create a new process with the given flags and varargs argument list.
+ *
+ * The argument list must be terminated with %NULL.
+ *
+ * Returns: A newly created #GSubprocess, or %NULL on error (and @error
+ *   will be set)
+ *
+ * Since: 2.36
+ */
+GSubprocess *
+g_subprocess_new (GSubprocessFlags   flags,
+                  GError           **error,
+                  const gchar       *argv0,
+                  ...)
+{
+  GSubprocess *result;
+  GPtrArray *args;
+  const gchar *arg;
+  va_list ap;
+
+  g_return_val_if_fail (argv0 != NULL && argv0[0] != '\0', NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
+  args = g_ptr_array_new ();
+
+  va_start (ap, argv0);
+  g_ptr_array_add (args, (gchar *) argv0);
+  while ((arg = va_arg (ap, const gchar *)))
+    g_ptr_array_add (args, (gchar *) arg);
+  g_ptr_array_add (args, NULL);
+
+  result = g_subprocess_newv ((const gchar * const *) args->pdata, flags, error);
+
+  g_ptr_array_free (args, TRUE);
+
+  return result;
+}
+
+/**
+ * g_subprocess_newv:
+ *
+ * Create a new process with the given flags and argument list.
+ *
+ * The argument list is expected to be %NULL-terminated.
+ *
+ * Returns: A newly created #GSubprocess, or %NULL on error (and @error
+ *   will be set)
+ *
+ * Since: 2.36
+ * Rename to: g_subprocess_new
+ */
+GSubprocess *
+g_subprocess_newv (const gchar * const  *argv,
+                   GSubprocessFlags      flags,
+                   GError              **error)
+{
+  g_return_val_if_fail (argv != NULL && argv[0] != NULL && argv[0][0] != '\0', NULL);
+
+  return g_initable_new (G_TYPE_SUBPROCESS, NULL, error,
+                         "argv", argv,
+                         "flags", flags,
+                         NULL);
+}
+
+const gchar *
+g_subprocess_get_identifier (GSubprocess *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), NULL);
+
+  if (self->pid)
+    return self->identifier;
+  else
+    return NULL;
+}
+
+GOutputStream *
+g_subprocess_get_stdin_pipe (GSubprocess       *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), NULL);
+  g_return_val_if_fail (self->stdin_pipe, NULL);
+
+  return self->stdin_pipe;
+}
+
+GInputStream *
+g_subprocess_get_stdout_pipe (GSubprocess      *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), NULL);
+  g_return_val_if_fail (self->stdout_pipe, NULL);
+
+  return self->stdout_pipe;
+}
+
+GInputStream *
+g_subprocess_get_stderr_pipe (GSubprocess      *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), NULL);
+  g_return_val_if_fail (self->stderr_pipe, NULL);
+
+  return self->stderr_pipe;
+}
+
+static void
+g_subprocess_wait_cancelled (GCancellable *cancellable,
+                             gpointer      user_data)
+{
+  GTask *task = user_data;
+  GSubprocess *self;
+
+  self = g_task_get_source_object (task);
+
+  g_mutex_lock (&self->pending_waits_lock);
+  self->pending_waits = g_slist_remove (self->pending_waits, task);
+  g_mutex_unlock (&self->pending_waits_lock);
+
+  g_task_return_boolean (task, FALSE);
+  g_object_unref (task);
+}
+
+void
+g_subprocess_wait_async (GSubprocess         *self,
+                         GCancellable        *cancellable,
+                         GAsyncReadyCallback  callback,
+                         gpointer             user_data)
+{
+  GTask *task;
+
+  task = g_task_new (self, cancellable, callback, user_data);
+
+  g_mutex_lock (&self->pending_waits_lock);
+  if (self->pid)
+    {
+      /* Only bother with cancellable if we're putting it in the list.
+       * If not, it's going to dispatch immediately anyway and we will
+       * see the cancellation in the _finish().
+       */
+      if (cancellable)
+        g_signal_connect_object (cancellable, "cancelled", G_CALLBACK (g_subprocess_wait_cancelled), task, 0);
+
+      self->pending_waits = g_slist_prepend (self->pending_waits, task);
+      task = NULL;
+    }
+  g_mutex_unlock (&self->pending_waits_lock);
+
+  /* If we still have task then it's because did_exit is already TRUE */
+  if (task != NULL)
+    {
+      g_task_return_boolean (task, TRUE);
+      g_object_unref (task);
+    }
+}
+
+gboolean
+g_subprocess_wait_finish (GSubprocess   *self,
+                          GAsyncResult  *result,
+                          GError       **error)
+{
+  return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+/* Some generic helpers for emulating synchronous operations using async
+ * operations.
+ */
+static void
+g_subprocess_sync_setup (void)
+{
+  g_main_context_push_thread_default (g_main_context_new ());
+}
+
+static void
+g_subprocess_sync_done (GObject      *source_object,
+                        GAsyncResult *result,
+                        gpointer      user_data)
+{
+  GAsyncResult **result_ptr = user_data;
+
+  *result_ptr = g_object_ref (result);
+}
+
+static void
+g_subprocess_sync_complete (GAsyncResult **result)
+{
+  GMainContext *context = g_main_context_get_thread_default ();
+
+  while (!*result)
+    g_main_context_iteration (context, TRUE);
+
+  g_main_context_pop_thread_default (context);
+  g_main_context_unref (context);
+}
+
+/**
+ * g_subprocess_wait:
+ * @self: a #GSubprocess
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Synchronously wait for the subprocess to terminate, returning the
+ * status code in @out_exit_status.  See the documentation of
+ * g_spawn_check_exit_status() for how to interpret it.  Note that if
+ * @error is set, then @out_exit_status will be left uninitialized.
+ *
+ * Returns: %TRUE on success, %FALSE if @cancellable was cancelled
+ *
+ * Since: 2.36
+ */
+gboolean
+g_subprocess_wait (GSubprocess   *self,
+                   GCancellable  *cancellable,
+                   GError       **error)
+{
+  GAsyncResult *result = NULL;
+  gboolean success;
+
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+
+  /* Synchronous waits are actually the 'more difficult' case because we
+   * need to deal with the possibility of cancellation.  That more or
+   * less implies that we need a main context (to dispatch either of the
+   * possible reasons for the operation ending).
+   *
+   * So we make one and then do this async...
+   */
+
+  if (g_cancellable_set_error_if_cancelled (cancellable, error))
+    return FALSE;
+
+  /* We can shortcut in the case that the process already quit (but only
+   * after we checked the cancellable).
+   */
+  if (self->pid == 0)
+    return TRUE;
+
+  /* Otherwise, we need to do this the long way... */
+  g_subprocess_sync_setup ();
+  g_subprocess_wait_async (self, cancellable, g_subprocess_sync_done, &result);
+  g_subprocess_sync_complete (&result);
+  success = g_subprocess_wait_finish (self, result, error);
+  g_object_unref (result);
+
+  return success;
+}
+
+/**
+ * g_subprocess_wait_sync_check:
+ * @self: a #GSubprocess
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Combines g_subprocess_wait_sync() with g_spawn_check_exit_status().
+ *
+ * Returns: %TRUE on success, %FALSE if process exited abnormally, or @cancellable was cancelled
+ *
+ * Since: 2.36
+ */
+gboolean
+g_subprocess_wait_check (GSubprocess   *self,
+                         GCancellable  *cancellable,
+                         GError       **error)
+{
+  return g_subprocess_wait (self, cancellable, error) &&
+         g_spawn_check_exit_status (self->status, error);
+}
+
+void
+g_subprocess_wait_check_async (GSubprocess         *self,
+                               GCancellable        *cancellable,
+                               GAsyncReadyCallback  callback,
+                               gpointer             user_data)
+{
+  g_subprocess_wait_async (self, cancellable, callback, user_data);
+}
+
+gboolean
+g_subprocess_wait_check_finish (GSubprocess   *self,
+                                GAsyncResult  *result,
+                                GError       **error)
+{
+  return g_subprocess_wait_finish (self, result, error) &&
+         g_spawn_check_exit_status (self->status, error);
+}
+
+#ifdef G_OS_UNIX
+typedef struct
+{
+  GSubprocess *subprocess;
+  gint signalnum;
+} SignalRecord;
+
+static gboolean
+g_subprocess_actually_send_signal (gpointer user_data)
+{
+  SignalRecord *signal_record = user_data;
+
+  /* The pid is set to zero from the worker thread as well, so we don't
+   * need to take a lock in order to prevent it from changing under us.
+   */
+  if (signal_record->subprocess->pid)
+    kill (signal_record->subprocess->pid, signal_record->signalnum);
+
+  g_object_unref (signal_record->subprocess);
+
+  g_slice_free (SignalRecord, signal_record);
+
+  return FALSE;
+}
+
+static void
+g_subprocess_dispatch_signal (GSubprocess *self,
+                              gint         signalnum)
+{
+  SignalRecord signal_record = { g_object_ref (self), signalnum };
+
+  g_return_if_fail (G_IS_SUBPROCESS (self));
+
+  /* This MUST be a lower priority than the priority that the child
+   * watch source uses in initable_init().
+   *
+   * Reaping processes, reporting the results back to GSubprocess and
+   * sending signals is all done in the glib worker thread.  We cannot
+   * have a kill() done after the reap and before the report without
+   * risking killing a process that's no longer there so the kill()
+   * needs to have the lower priority.
+   *
+   * G_PRIORITY_HIGH_IDLE is lower priority than G_PRIORITY_DEFAULT.
+   */
+  g_main_context_invoke_full (GLIB_PRIVATE_CALL (g_get_worker_context) (),
+                              G_PRIORITY_HIGH_IDLE,
+                              g_subprocess_actually_send_signal,
+                              g_slice_dup (SignalRecord, &signal_record),
+                              NULL);
+}
+
+/**
+ * g_subprocess_send_signal:
+ * @self: a #GSubprocess
+ * @signal_num: the signal number to send
+ *
+ * Sends the UNIX signal @signal_num to the subprocess, if it is still
+ * running.
+ *
+ * This API is race-free.  If the subprocess has terminated, it will not
+ * be signalled.
+ *
+ * This API is not available on Windows.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_send_signal (GSubprocess *self,
+                          gint         signal_num)
+{
+  g_return_if_fail (G_IS_SUBPROCESS (self));
+
+  g_subprocess_dispatch_signal (self, signal_num);
+}
+#endif
+
+/**
+ * g_subprocess_force_exit:
+ * @self: a #GSubprocess
+ *
+ * Use an operating-system specific method to attempt an immediate,
+ * forceful termination of the process.  There is no mechanism to
+ * determine whether or not the request itself was successful;
+ * however, you can use g_subprocess_wait() to monitor the status of
+ * the process after calling this function.
+ *
+ * On Unix, this function sends %SIGKILL.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_force_exit (GSubprocess *self)
+{
+  g_return_if_fail (G_IS_SUBPROCESS (self));
+
+#ifdef G_OS_UNIX
+  g_subprocess_dispatch_signal (self, SIGKILL);
+#else
+  TerminateProcess (self->pid, 1);
+#endif
+}
+
+/**
+ * g_subprocess_get_status:
+ * @self: a #GSubprocess
+ *
+ * Gets the raw status code of the process, as from waitpid().
+ *
+ * This value has no particular meaning, but it can be used with the
+ * macros defined by the system headers such as WIFEXITED.  It can also
+ * be used with g_spawn_check_exit_status().
+ *
+ * It is more likely that you want to use g_subprocess_get_if_exited()
+ * followed by g_subprocess_get_exit_status().
+ *
+ * It is an error to call this function before g_subprocess_wait() has
+ * returned.
+ *
+ * Returns: the (meaningless) waitpid() exit status from the kernel
+ *
+ * Since: 2.36
+ **/
+gint
+g_subprocess_get_status (GSubprocess *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+  g_return_val_if_fail (self->pid == 0, FALSE);
+
+  return self->status;
+}
+
+/**
+ * g_subprocess_get_successful:
+ * @self: a #GSubprocess
+ *
+ * Checks if the process was "successful".  A process is considered
+ * successful if it exited cleanly with an exit status of 0, either by
+ * way of the exit() system call or return from main().
+ *
+ * It is an error to call this function before g_subprocess_wait() has
+ * returned.
+ *
+ * Returns: %TRUE if the process exited cleanly with a exit status of 0
+ *
+ * Since: 2.36
+ **/
+gboolean
+g_subprocess_get_successful (GSubprocess *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+  g_return_val_if_fail (self->pid == 0, FALSE);
+
+  return WIFEXITED (self->status) && WEXITSTATUS (self->status) == 0;
+}
+
+/**
+ * g_subprocess_get_if_exited:
+ * @self: a #GSubprocess
+ *
+ * Check if the given subprocess exited normally (ie: by way of exit()
+ * or return from main()).
+ *
+ * This is equivalent to the system WIFEXITED macro.
+ *
+ * It is an error to call this function before g_subprocess_wait() has
+ * returned.
+ *
+ * Returns: %TRUE if the case of a normal exit
+ *
+ * Since: 2.36
+ **/
+gboolean
+g_subprocess_get_if_exited (GSubprocess *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+  g_return_val_if_fail (self->pid == 0, FALSE);
+
+  return WIFEXITED (self->status);
+}
+
+/**
+ * g_subprocess_get_exit_status:
+ * @self: a #GSubprocess
+ *
+ * Check the exit status of the subprocess, given that it exited
+ * normally.  This is the value passed to the exit() system call or the
+ * return value from main.
+ *
+ * This is equivalent to the system WEXITSTATUS macro.
+ *
+ * It is an error to call this function before g_subprocess_wait() and
+ * unless g_subprocess_get_if_exited() returned %TRUE.
+ *
+ * Returns: the exit status
+ *
+ * Since: 2.36
+ **/
+gint
+g_subprocess_get_exit_status (GSubprocess *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), 1);
+  g_return_val_if_fail (self->pid == 0, 1);
+  g_return_val_if_fail (WIFEXITED (self->status), 1);
+
+  return WEXITSTATUS (self->status);
+}
+
+/**
+ * g_subprocess_get_if_signaled:
+ * @self: a #GSubprocess
+ *
+ * Check if the given subprocess terminated in response to a signal.
+ *
+ * This is equivalent to the system WIFSIGNALED macro.
+ *
+ * It is an error to call this function before g_subprocess_wait() has
+ * returned.
+ *
+ * Returns: %TRUE if the case of termination due to a signal
+ *
+ * Since: 2.36
+ **/
+gboolean
+g_subprocess_get_if_signaled (GSubprocess *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+  g_return_val_if_fail (self->pid == 0, FALSE);
+
+  return WIFSIGNALED (self->status);
+}
+
+/**
+ * g_subprocess_get_term_sig:
+ * @self: a #GSubprocess
+ *
+ * Get the signal number that caused the subprocess to terminate, given
+ * that it terminated due to a signal.
+ *
+ * This is equivalent to the system WTERMSIG macro.
+ *
+ * It is an error to call this function before g_subprocess_wait() and
+ * unless g_subprocess_get_if_signaled() returned %TRUE.
+ *
+ * Returns: the signal causing termination
+ *
+ * Since: 2.36
+ **/
+gint
+g_subprocess_get_term_sig (GSubprocess *self)
+{
+  g_return_val_if_fail (G_IS_SUBPROCESS (self), 0);
+  g_return_val_if_fail (self->pid == 0, 0);
+  g_return_val_if_fail (WIFSIGNALED (self->status), 0);
+
+  return WTERMSIG (self->status);
+}
+
+/*< private >*/
+void
+g_subprocess_set_launcher (GSubprocess         *subprocess,
+                           GSubprocessLauncher *launcher)
+{
+  subprocess->launcher = launcher;
+}
+
+/* g_subprocess_communicate implementation below:
+ *
+ * This is a tough problem.  We have to watch 5 things at the same time:
+ *
+ *  - writing to stdin made progress
+ *  - reading from stdout made progress
+ *  - reading from stderr made progress
+ *  - process terminated
+ *  - cancellable being cancelled by caller
+ *
+ * We use a GMainContext for all of these (either as async function
+ * calls or as a GSource (in the case of the cancellable).  That way at
+ * least we don't have to worry about threading.
+ *
+ * For the sync case we use the usual trick of creating a private main
+ * context and iterating it until completion.
+ *
+ * It's very possible that the process will dump a lot of data to stdout
+ * just before it quits, so we can easily have data to read from stdout
+ * and see the process has terminated at the same time.  We want to make
+ * sure that we read all of the data from the pipes first, though, so we
+ * do IO operations at a higher priority than the wait operation (which
+ * is at G_IO_PRIORITY_DEFAULT).  Even in the case that we have to do
+ * multiple reads to get this data, the pipe() will always be polling
+ * as ready and with the async result for the read at a higher priority,
+ * the main context will not dispatch the completion for the wait().
+ *
+ * We keep our own private GCancellable.  In the event that any of the
+ * above suffers from an error condition (including the user cancelling
+ * their cancellable) we immediately dispatch the GTask with the error
+ * result and fire our cancellable to cleanup any pending operations.
+ * In the case that the error is that the user's cancellable was fired,
+ * it's vaguely wasteful to report an error because GTask will handle
+ * this automatically, so we just return FALSE.
+ *
+ * We let each pending sub-operation take a ref on the GTask of the
+ * communicate operation.  We have to be careful that we don't report
+ * the task completion more than once, though, so we keep a flag for
+ * that.
+ */
+typedef struct
+{
+  const gchar *stdin_data;
+  gsize stdin_length;
+  gsize stdin_offset;
+
+  /* Not actually GString.  Just borrowing the struct. */
+  GString stdout_string;
+  GString stderr_string;
+
+  GBytes *unref_this_later;
+  gchar  *free_this_later;
+
+  GCancellable *cancellable;
+  GSource      *cancellable_source;
+
+  gboolean      completion_reported;
+} CommunicateState;
+
+static void
+ensure_string_allocated (GString *str)
+{
+  /* This will work because the first time we will set it to
+   * COMMUNICATE_READ_SIZE and then all future attempts will grow by at
+   * least that much (as a result of multiplying the existing value by
+   * 2).
+   */
+  if (str->len + COMMUNICATE_READ_SIZE > str->allocated_len)
+    {
+      str->allocated_len = MAX(COMMUNICATE_READ_SIZE, str->allocated_len * 2);
+      str->str = g_realloc (str->str, str->allocated_len);
+    }
+}
+
+static void
+g_subprocess_communicate_made_progress (GObject      *source_object,
+                                        GAsyncResult *result,
+                                        gpointer      user_data)
+{
+  CommunicateState *state;
+  GSubprocess *subprocess;
+  GError *error = NULL;
+  gpointer source;
+  GTask *task;
+
+  g_assert (source_object != NULL);
+
+  task = user_data;
+  subprocess = g_task_get_source_object (task);
+  state = g_task_get_task_data (task);
+  source = source_object;
+
+  if (source == subprocess->stdin_pipe)
+    {
+      gssize s;
+
+      s = g_output_stream_write_finish (subprocess->stdin_pipe, result, &error);
+      g_assert (s != 0);
+
+      if (s != -1)
+        {
+          g_assert (0 < s && s < state->stdin_length);
+          g_assert (state->stdin_offset + s <= state->stdin_length);
+          state->stdin_offset += s;
+
+          if (state->stdin_offset != state->stdin_length)
+            {
+              /* write more... */
+              g_output_stream_write_async (subprocess->stdin_pipe,
+                                           state->stdin_data + state->stdin_offset,
+                                           state->stdin_length - state->stdin_offset,
+                                           G_PRIORITY_DEFAULT,
+                                           state->cancellable,
+                                           g_subprocess_communicate_made_progress,
+                                           task);
+              return;
+            }
+        }
+    }
+  else if (source == subprocess->stdout_pipe)
+    {
+      gssize s;
+
+      s = g_input_stream_read_finish (subprocess->stdout_pipe, result, &error);
+      g_assert (s <= COMMUNICATE_READ_SIZE);
+
+      /* If s is 0 then we have EOF and should not read more, but should
+       * continue to try the other event sources.
+       *
+       * If s is -1 then error will be set and we deal with that below.
+       *
+       * Only have to handle the result > 0 case.
+       */
+      if (s > 0)
+        {
+          state->stdout_string.len += s;
+
+          ensure_string_allocated (&state->stdout_string);
+
+          g_input_stream_read_async (subprocess->stdout_pipe, state->stdout_string.str + state->stdout_string.len,
+                                     COMMUNICATE_READ_SIZE, G_PRIORITY_DEFAULT - 1, state->cancellable,
+                                     g_subprocess_communicate_made_progress, g_object_ref (task));
+          return;
+        }
+    }
+  else if (source == subprocess->stderr_pipe)
+    {
+      gssize s;
+
+      s = g_input_stream_read_finish (subprocess->stdout_pipe, result, &error);
+      g_assert (s <= COMMUNICATE_READ_SIZE);
+
+      /* As above... */
+      if (s > 0)
+        {
+          state->stderr_string.len += s;
+
+          ensure_string_allocated (&state->stderr_string);
+
+          g_input_stream_read_async (subprocess->stderr_pipe, state->stderr_string.str + state->stderr_string.len,
+                                     COMMUNICATE_READ_SIZE, G_PRIORITY_DEFAULT - 1, state->cancellable,
+                                     g_subprocess_communicate_made_progress, g_object_ref (task));
+          return;
+        }
+    }
+  else if (source == subprocess)
+    {
+      if (g_subprocess_wait_finish (subprocess, result, &error))
+        {
+          /* It is not possible that we had a successful completion if
+           * the task was already completed because we flag our own
+           * cancellable in that case.
+           */
+          g_assert (!state->completion_reported);
+          state->completion_reported = TRUE;
+          g_task_return_boolean (task, TRUE);
+        }
+    }
+  else
+    g_assert_not_reached ();
+
+  if (error)
+    {
+      /* Only report the first error we see.
+       *
+       * We might be seeing an error as a result of the cancellation
+       * done when the process quits.
+       */
+      if (!state->completion_reported)
+        {
+          state->completion_reported = TRUE;
+
+          g_cancellable_cancel (state->cancellable);
+          g_task_return_error (task, error);
+        }
+      else
+        g_error_free (error);
+    }
+
+  g_object_unref (task);
+}
+
+static gboolean
+g_subprocess_communicate_cancelled (gpointer user_data)
+{
+  CommunicateState *state = user_data;
+
+  g_cancellable_cancel (state->cancellable);
+
+  return FALSE;
+}
+
+static void
+g_subprocess_communicate_state_free (gpointer data)
+{
+  CommunicateState *state = data;
+
+  g_free (state->stdout_string.str);
+  g_free (state->stderr_string.str);
+  g_free (state->free_this_later);
+
+  if (!g_source_is_destroyed (state->cancellable_source))
+    g_source_destroy (state->cancellable_source);
+  g_source_unref (state->cancellable_source);
+
+  if (state->unref_this_later)
+    g_bytes_unref (state->unref_this_later);
+
+  g_slice_free (CommunicateState, state);
+}
+
+static CommunicateState *
+g_subprocess_communicate_internal (GSubprocess         *subprocess,
+                                   GBytes              *stdin_bytes,
+                                   const gchar         *stdin_data,
+                                   gssize               stdin_length,
+                                   GCancellable        *cancellable,
+                                   GAsyncReadyCallback  callback,
+                                   gpointer             user_data)
+{
+  CommunicateState *state;
+  GTask *task;
+
+  task = g_task_new (subprocess, cancellable, callback, user_data);
+  state = g_slice_new0 (CommunicateState);
+  g_task_set_task_data (task, state, g_subprocess_communicate_state_free);
+
+  if (stdin_bytes)
+    {
+      g_assert (!stdin_data && !stdin_length && (subprocess->flags & G_SUBPROCESS_FLAGS_STDIN_PIPE));
+      state->stdin_data = g_bytes_get_data (stdin_bytes, &state->stdin_length);
+      state->unref_this_later = g_bytes_ref (stdin_bytes);
+    }
+  else if (stdin_data)
+    {
+      g_assert (subprocess->flags & G_SUBPROCESS_FLAGS_STDIN_PIPE);
+      if (stdin_length < 0)
+        state->stdin_length = strlen (stdin_data);
+      else
+        state->stdin_length = stdin_length;
+
+      state->free_this_later = g_memdup (stdin_data, state->stdin_length);
+      state->stdin_data = state->free_this_later;
+    }
+
+  state->cancellable = g_cancellable_new ();
+
+  if (cancellable)
+    {
+      state->cancellable_source = g_cancellable_source_new (cancellable);
+      /* No ref held here, but we unref the source from state's free function */
+      g_source_set_callback (state->cancellable_source, g_subprocess_communicate_cancelled, state, NULL);
+      g_source_attach (state->cancellable_source, g_main_context_get_thread_default ());
+    }
+
+  if (subprocess->stdin_pipe && state->stdin_length)
+    g_output_stream_write_async (subprocess->stdin_pipe, state->stdin_data, state->stdin_length, G_PRIORITY_DEFAULT,
+                                 state->cancellable, g_subprocess_communicate_made_progress, g_object_ref (task));
+
+  if (subprocess->stdout_pipe)
+    {
+      ensure_string_allocated (&state->stdout_string);
+
+      g_input_stream_read_async (subprocess->stdout_pipe, state->stdout_string.str, COMMUNICATE_READ_SIZE,
+                                 G_PRIORITY_DEFAULT - 1, state->cancellable,
+                                 g_subprocess_communicate_made_progress, g_object_ref (task));
+    }
+
+  if (subprocess->stderr_pipe)
+    {
+      ensure_string_allocated (&state->stderr_string);
+
+      g_input_stream_read_async (subprocess->stderr_pipe, state->stderr_string.str, COMMUNICATE_READ_SIZE,
+                                 G_PRIORITY_DEFAULT - 1, state->cancellable,
+                                 g_subprocess_communicate_made_progress, g_object_ref (task));
+    }
+
+  g_subprocess_wait_async (subprocess, state->cancellable,
+                           g_subprocess_communicate_made_progress, g_object_ref (task));
+
+  return state;
+}
+
+/**
+ * g_Subprocess_communicate:
+ * @self: a #GSubprocess
+ * @stdin_data: data to send to the stdin of the subprocess, or %NULL
+ * @stdin_length: the length of @stdin_data, or -1
+ * @cancellable: a #GCancellable
+ * @stdout_data: (out): data read from the subprocess stdout
+ * @stdout_length: (out): the length of @stdout_data returned
+ * @stderr_data: (out): data read from the subprocess stderr
+ * @stderr_length: (out): the length of @stderr_data returned
+ * @error: a pointer to a %NULL #GError pointer, or %NULL
+ *
+ * Communicate with the subprocess until it terminates.
+ *
+ * If @stdin_data is given, the subprocess must have been created with
+ * %G_SUBPROCESS_FLAGS_STDIN_PIPE.  The given data is fed to the
+ * stdin of the subprocess and the pipe is closed (ie: EOF).
+ *
+ * At the same time (as not to cause blocking when dealing with large
+ * amounts of data), if %G_SUBPROCESS_FLAGS_STDOUT_PIPE or
+ * %G_SUBPROCESS_FLAGS_STDERR_PIPE were used, reads from those streams.
+ * The data that was read is returned in @stdout_data and/or
+ * @stderr_data.
+ *
+ * @stdin_length specifies the length of @stdin_data.  If it is -1 then
+ * @stdin_data is taken to be a nul-terminated string.  If the
+ * subprocess was not created with %G_SUBPROCESS_FLAGS_STDIN_PIPE then
+ * you must pass %NULL for @stdin_data and 0 for @stdin_length.
+ *
+ * If the subprocess was created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
+ * @stdout_data will contain the data read from stdout, plus a
+ * terminating nul character; it will always be non-%NULL (ie:
+ * containing at least the nul).  @stdout_length will be the length of
+ * the data, excluding the added nul.  For subprocesses not created with
+ * %G_SUBPROCESS_FLAGS_STDOUT_PIPE, @stdout_data will be set to %NULL
+ * and @stdout_length will be set to zero.  stderr is handled in the
+ * same way.
+ *
+ * None of stdin, stdout or stderr are assumed to be in any particular
+ * format.  They are the binary sent to or received directly from the
+ * process.  Do not assume UTF-8.
+ *
+ * As usual, any output variable may be given as %NULL to ignore it.
+ *
+ * If you desire the stdout and stderr data to be interleaved, create
+ * the subprocess with %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
+ * %G_SUBPROCESS_FLAGS_STDERR_MERGE.  The merged result will be returned
+ * in @stdout_data and @stderr_data will be set to %NULL.
+ *
+ * In case of any error (including cancellation), %FALSE will be
+ * returned with @error set.  Some or all of the stdin data may have
+ * been written.  Any stdout or stderr data that has been read will be
+ * discarded. None of the out variables (aside from @error) will have
+ * been set to anything in particular and should not be inspected.
+ *
+ * In the case that %TRUE is returned, the subprocess has exited and the
+ * exit status inspection APIs (eg: g_subprocess_get_if_exited(),
+ * g_subprocess_get_exit_status()) may be used.
+ *
+ * You should not attempt to use any of the subprocess pipes after
+ * starting this function, since they may be left in strange states,
+ * even if the operation was cancelled.  You should especially not
+ * attempt to interact with the pipes while the operation is in progress
+ * (either from another thread or if using the asynchronous version).
+ *
+ * Returns: %TRUE if successful
+ *
+ * Since: 2.36
+ **/
+gboolean
+g_subprocess_communicate (GSubprocess   *subprocess,
+                          const gchar   *stdin_data,
+                          gssize         stdin_length,
+                          GCancellable  *cancellable,
+                          gchar        **stdout_data,
+                          gsize         *stdout_length,
+                          gchar        **stderr_data,
+                          gsize         *stderr_length,
+                          GError       **error)
+{
+  GAsyncResult *result = NULL;
+  gboolean success;
+
+  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), FALSE);
+  g_return_val_if_fail (stdin_length == 0 || stdin_data != NULL, FALSE);
+  g_return_val_if_fail (stdin_data == NULL || (subprocess->flags & G_SUBPROCESS_FLAGS_STDIN_PIPE), FALSE);
+  g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  g_subprocess_sync_setup ();
+  g_subprocess_communicate_internal (subprocess, NULL, stdin_data, stdin_length,
+                                     cancellable, g_subprocess_sync_done, &result);
+  g_subprocess_sync_complete (&result);
+  success = g_subprocess_communicate_finish (subprocess, result,
+                                             stdout_data, stdout_length,
+                                             stderr_data, stderr_length, error);
+  g_object_unref (result);
+
+  return success;
+}
+
+/**
+ * g_subprocess_communicate_async:
+ * @subprocess: a #GSubprocess
+ * @stdout_bytes: (out): the data read from stdout
+ * @stderr_bytes: (out): the data read from stderr
+ * @error: a pointer to a %NULL #GError pointer, or %NULL
+ *
+ * This is the asynchronous variant of g_subprocess_communicate().
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_communicate_async (GSubprocess         *subprocess,
+                                const gchar         *stdin_data,
+                                gssize               stdin_length,
+                                GCancellable        *cancellable,
+                                GAsyncReadyCallback  callback,
+                                gpointer             user_data)
+{
+  g_return_if_fail (G_IS_SUBPROCESS (subprocess));
+  g_return_if_fail (stdin_length == 0 || stdin_data != NULL);
+  g_return_if_fail (stdin_data == NULL || (subprocess->flags & G_SUBPROCESS_FLAGS_STDIN_PIPE));
+  g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
+
+  g_subprocess_communicate_internal (subprocess, NULL, stdin_data, stdin_length, cancellable, callback, user_data);
+}
+
+/**
+ * g_subprocess_communicate_finish:
+ * @subprocess: a #GSubprocess
+ * @stdout_data: (out): data read from the subprocess stdout
+ * @stdout_length: (out): the length of @stdout_data returned
+ * @stderr_data: (out): data read from the subprocess stderr
+ * @stderr_length: (out): the length of @stderr_data returned
+ * @error: a pointer to a %NULL #GError pointer, or %NULL
+ *
+ * Collect the result from g_subprocess_communicate_async().
+ *
+ * Returns: %TRUE if the subprocess finished successfully, otherwise
+ *   %FALSE with @error set
+ *
+ * Since: 2.36
+ **/
+gboolean
+g_subprocess_communicate_finish (GSubprocess   *subprocess,
+                                 GAsyncResult  *result,
+                                 gchar        **stdout_data,
+                                 gsize         *stdout_length,
+                                 gchar        **stderr_data,
+                                 gsize         *stderr_length,
+                                 GError       **error)
+{
+  CommunicateState *state;
+  gboolean success;
+  GTask *task;
+
+  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), FALSE);
+  g_return_val_if_fail (g_task_is_valid (result, subprocess), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  task = G_TASK (result);
+  state = g_task_get_task_data (task);
+
+  success = g_task_propagate_boolean (task, error);
+
+  if (success)
+    {
+      if (stdout_data)
+        {
+          gchar *string;
+
+          string = g_realloc (state->stdout_string.str, state->stdout_string.len + 1);
+          string[state->stdout_string.len] = '\0';
+          state->stdout_string.str = NULL;
+          *stdout_data = string;
+        }
+
+      if (stdout_length)
+        *stdout_length = state->stdout_string.len;
+
+      if (stderr_data)
+        {
+          gchar *string;
+
+          string = g_realloc (state->stderr_string.str, state->stderr_string.len + 1);
+          string[state->stderr_string.len] = '\0';
+          state->stderr_string.str = NULL;
+          *stderr_data = string;
+        }
+
+      if (stderr_length)
+        *stderr_length = state->stderr_string.len;
+    }
+
+  return success;
+}
+
+/**
+ * g_subprocess_communicate_bytes:
+ * @subprocess: a #GSubprocess
+ * @stdin_bytes: (allow none): the data to write to stdin
+ * @cancellable: a #GCancellable
+ * @stdout_bytes: (out): the data read from stdout
+ * @stderr_bytes: (out): the data read from stderr
+ * @error: a pointer to a %NULL #GError pointer, or %NULL
+ *
+ * Communicate with the subprocess until it terminates.
+ *
+ * See the documentation for g_subprocess_communicate().  The only
+ * different here is that this function deals in #GBytes.
+ *
+ * @stdin_bytes must be %NULL if %G_SUBPROCESS_FLAG_STDIN_PIPE was not
+ * used.  @stdout_bytes will be set to %NULL unless
+ * %G_SUBPROCESS_FLAG_STDOUT_PIPE was given.
+ *
+ * Returns: %TRUE if the subprocess finished successfully, otherwise
+ *   %FALSE with @error set
+ *
+ * Since: 2.36
+ **/
+gboolean
+g_subprocess_communicate_bytes (GSubprocess   *subprocess,
+                                GBytes        *stdin_bytes,
+                                GCancellable  *cancellable,
+                                GBytes       **stdout_bytes,
+                                GBytes       **stderr_bytes,
+                                GError       **error)
+{
+  GAsyncResult *result = NULL;
+  gboolean success;
+
+  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), FALSE);
+  g_return_val_if_fail (stdin_bytes == NULL || (subprocess->flags & G_SUBPROCESS_FLAGS_STDIN_PIPE), FALSE);
+  g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  g_subprocess_sync_setup ();
+  g_subprocess_communicate_internal (subprocess, stdin_bytes, NULL, 0, cancellable, g_subprocess_sync_done, &result);
+  g_subprocess_sync_complete (&result);
+  success = g_subprocess_communicate_bytes_finish (subprocess, result, stdout_bytes, stderr_bytes, error);
+  g_object_unref (result);
+
+  return success;
+}
+
+/**
+ * g_subprocess_communicate_bytes_async:
+ * @subprocess: a #GSubprocess
+ * @result: the #GAsyncResult
+ * @stdout_bytes: (out): the data read from stdout
+ * @stderr_bytes: (out): the data read from stderr
+ * @error: a pointer to a %NULL #GError pointer, or %NULL
+ *
+ * This is the asynchronous variant of g_subprocess_communicate_bytes().
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_communicate_bytes_async (GSubprocess         *subprocess,
+                                      GBytes              *stdin_bytes,
+                                      GCancellable        *cancellable,
+                                      GAsyncReadyCallback  callback,
+                                      gpointer             user_data)
+{
+  g_return_if_fail (G_IS_SUBPROCESS (subprocess));
+  g_return_if_fail (stdin_bytes == NULL || (subprocess->flags & G_SUBPROCESS_FLAGS_STDIN_PIPE));
+  g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
+
+  g_subprocess_communicate_internal (subprocess, stdin_bytes, NULL, 0, cancellable, callback, user_data);
+}
+
+/**
+ * g_subprocess_communicate_bytes_finish:
+ * @subprocess: a #GSubprocess
+ * @stdout_bytes: (out): the data read from stdout
+ * @stderr_bytes: (out): the data read from stderr
+ * @error: a pointer to a %NULL #GError pointer, or %NULL
+ *
+ * Collect the result from g_subprocess_communicate_bytes_async().
+ *
+ * Returns: %TRUE if the subprocess finished successfully, otherwise
+ *   %FALSE with @error set
+ *
+ * Since: 2.36
+ **/
+gboolean
+g_subprocess_communicate_bytes_finish (GSubprocess   *subprocess,
+                                       GAsyncResult  *result,
+                                       GBytes       **stdout_bytes,
+                                       GBytes       **stderr_bytes,
+                                       GError       **error)
+{
+  gboolean success;
+  gchar *stdout_data;
+  gsize stdout_length;
+  gchar *stderr_data;
+  gsize stderr_length;
+
+  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), FALSE);
+  g_return_val_if_fail (g_task_is_valid (result, subprocess), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  success = g_subprocess_communicate_finish (subprocess, result,
+                                             stdout_bytes ? &stdout_data : NULL,
+                                             stdout_bytes ? &stdout_length : NULL,
+                                             stderr_bytes ? &stderr_data : NULL,
+                                             stderr_bytes ? &stderr_length : NULL,
+                                             error);
+
+  if (success)
+    {
+      if (stdout_bytes)
+        {
+          if (stdout_data)
+            *stdout_bytes = g_bytes_new_take (stdout_data, stdout_length);
+          else
+            *stdout_bytes = NULL;
+
+          if (stderr_bytes)
+            *stderr_bytes = g_bytes_new_take (stderr_data, stderr_length);
+          else
+            *stderr_bytes = NULL;
+        }
+    }
+
+  return success;
+}
diff --git a/gio/gsubprocess.h b/gio/gsubprocess.h
new file mode 100644
index 000000000..8ae002beb
--- /dev/null
+++ b/gio/gsubprocess.h
@@ -0,0 +1,174 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2012 Colin Walters <walters@verbum.org>
+ *
+ * This library 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.
+ *
+ * This library 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 this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: Colin Walters <walters@verbum.org>
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_SUBPROCESS_H__
+#define __G_SUBPROCESS_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SUBPROCESS         (g_subprocess_get_type ())
+#define G_SUBPROCESS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_SUBPROCESS, GSubprocess))
+#define G_IS_SUBPROCESS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_SUBPROCESS))
+
+GLIB_AVAILABLE_IN_2_36
+GType            g_subprocess_get_type                  (void) G_GNUC_CONST;
+
+/**** Core API ****/
+
+GLIB_AVAILABLE_IN_2_36
+GSubprocess *    g_subprocess_new                       (GSubprocessFlags        flags,
+                                                         GError                **error,
+                                                         const gchar            *argv0,
+                                                         ...) G_GNUC_NULL_TERMINATED;
+GLIB_AVAILABLE_IN_2_36
+GSubprocess *    g_subprocess_newv                      (const gchar * const  *argv,
+                                                         GSubprocessFlags      flags,
+                                                         GError              **error);
+
+GLIB_AVAILABLE_IN_2_36
+GOutputStream *  g_subprocess_get_stdin_pipe            (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+GInputStream *   g_subprocess_get_stdout_pipe           (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+GInputStream *   g_subprocess_get_stderr_pipe           (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+const gchar *    g_subprocess_get_identifier            (GSubprocess          *self);
+
+#ifdef G_OS_UNIX
+GLIB_AVAILABLE_IN_2_36
+void             g_subprocess_send_signal               (GSubprocess          *self,
+                                                         gint                  signal_num);
+#endif
+
+GLIB_AVAILABLE_IN_2_36
+void             g_subprocess_force_exit                (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_wait                      (GSubprocess          *self,
+                                                         GCancellable         *cancellable,
+                                                         GError              **error);
+
+GLIB_AVAILABLE_IN_2_36
+void             g_subprocess_wait_async                (GSubprocess          *self,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_wait_finish               (GSubprocess          *self,
+                                                         GAsyncResult         *result,
+                                                         GError              **error);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_wait_check                (GSubprocess          *self,
+                                                         GCancellable         *cancellable,
+                                                         GError              **error);
+
+GLIB_AVAILABLE_IN_2_36
+void             g_subprocess_wait_check_async          (GSubprocess          *self,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_wait_check_finish         (GSubprocess          *self,
+                                                         GAsyncResult         *result,
+                                                         GError              **error);
+
+
+GLIB_AVAILABLE_IN_2_36
+gint             g_subprocess_get_status                (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_get_successful            (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_get_if_exited             (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+gint             g_subprocess_get_exit_status           (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_get_if_signaled           (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+gint             g_subprocess_get_term_sig              (GSubprocess          *self);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean         g_subprocess_communicate               (GSubprocess          *subprocess,
+                                                         const gchar          *stdin_data,
+                                                         gssize                stdin_length,
+                                                         GCancellable         *cancellable,
+                                                         gchar               **stdout_data,
+                                                         gsize                *stdout_length,
+                                                         gchar               **stderr_data,
+                                                         gsize                *stderr_length,
+                                                         GError              **error);
+GLIB_AVAILABLE_IN_2_36
+void            g_subprocess_communicate_async          (GSubprocess          *subprocess,
+                                                         const gchar          *stdin_data,
+                                                         gssize                stdin_length,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean        g_subprocess_communicate_finish         (GSubprocess          *subprocess,
+                                                         GAsyncResult         *result,
+                                                         gchar               **stdout_data,
+                                                         gsize                *stdout_length,
+                                                         gchar               **stderr_data,
+                                                         gsize                *stderr_length,
+                                                         GError              **error);
+
+GLIB_AVAILABLE_IN_2_36
+gboolean        g_subprocess_communicate_bytes          (GSubprocess          *subprocess,
+                                                         GBytes               *stdin_bytes,
+                                                         GCancellable         *cancellable,
+                                                         GBytes              **stdout_bytes,
+                                                         GBytes              **stderr_bytes,
+                                                         GError              **error);
+GLIB_AVAILABLE_IN_2_36
+void            g_subprocess_communicate_bytes_async    (GSubprocess          *subprocess,
+                                                         GBytes               *stdin_bytes,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+GLIB_AVAILABLE_IN_2_36
+gboolean        g_subprocess_communicate_bytes_finish   (GSubprocess          *subprocess,
+                                                         GAsyncResult         *result,
+                                                         GBytes              **stdout_bytes,
+                                                         GBytes              **stderr_bytes,
+                                                         GError              **error);
+
+G_END_DECLS
+
+#endif /* __G_SUBPROCESS_H__ */
diff --git a/gio/gsubprocesslauncher-private.h b/gio/gsubprocesslauncher-private.h
new file mode 100644
index 000000000..55c608e87
--- /dev/null
+++ b/gio/gsubprocesslauncher-private.h
@@ -0,0 +1,58 @@
+/* GIO - GLib Input, Output and Streaming Library
+ * 
+ * Copyright (C) 2012 Colin Walters <walters@verbum.org>
+ *
+ * This library 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.
+ *
+ * This library 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 this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_SUBPROCESS_CONTEXT_PRIVATE_H__
+#define __G_SUBPROCESS_CONTEXT_PRIVATE_H__
+
+#include "gsubprocesslauncher.h"
+
+G_BEGIN_DECLS
+
+struct _GSubprocessLauncher
+{
+  GObject parent;
+
+  GSubprocessFlags flags;
+  gboolean path_from_envp;
+  char **envp;
+  char *cwd;
+
+#ifdef G_OS_UNIX
+  gint stdin_fd;
+  gchar *stdin_path;
+
+  gint stdout_fd;
+  gchar *stdout_path;
+
+  gint stderr_fd;
+  gchar *stderr_path;
+
+  GSpawnChildSetupFunc child_setup_func;
+  gpointer child_setup_user_data;
+  GDestroyNotify child_setup_destroy_notify;
+#endif
+};
+
+void g_subprocess_set_launcher (GSubprocess         *subprocess,
+                                GSubprocessLauncher *launcher);
+
+G_END_DECLS
+
+#endif
diff --git a/gio/gsubprocesslauncher.c b/gio/gsubprocesslauncher.c
new file mode 100644
index 000000000..d0ecd93f8
--- /dev/null
+++ b/gio/gsubprocesslauncher.c
@@ -0,0 +1,654 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright © 2012 Red Hat, Inc.
+ * Copyright © 2012-2013 Canonical Limited
+ *
+ * This program 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 licence or (at
+ * your option) any later version.
+ *
+ * See the included COPYING file for more information.
+ *
+ * Authors: Colin Walters <walters@verbum.org>
+ *          Ryan Lortie <desrt@desrt.ca>
+ */
+
+/**
+ * SECTION:gsubprocess
+ * @title: GSubprocess Launcher
+ * @short_description: Environment options for launching a child process
+ *
+ * This class contains a set of options for launching child processes,
+ * such as where its standard input and output will be directed, the
+ * argument list, the environment, and more.
+ *
+ * While the #GSubprocess class has high level functions covering
+ * popular cases, use of this class allows access to more advanced
+ * options.  It can also be used to launch multiple subprocesses with
+ * a similar configuration.
+ *
+ * Since: 2.36
+ */
+
+#define ALL_STDIN_FLAGS         (G_SUBPROCESS_FLAGS_STDIN_PIPE |        \
+                                 G_SUBPROCESS_FLAGS_STDIN_INHERIT)
+#define ALL_STDOUT_FLAGS        (G_SUBPROCESS_FLAGS_STDOUT_PIPE |       \
+                                 G_SUBPROCESS_FLAGS_STDOUT_SILENCE)
+#define ALL_STDERR_FLAGS        (G_SUBPROCESS_FLAGS_STDERR_PIPE |       \
+                                 G_SUBPROCESS_FLAGS_STDERR_SILENCE |    \
+                                 G_SUBPROCESS_FLAGS_STDERR_MERGE)
+
+#include "config.h"
+
+#include "gsubprocesslauncher-private.h"
+#include "gioenumtypes.h"
+#include "gsubprocess.h"
+#include "ginitable.h"
+
+#ifdef G_OS_UNIX
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+typedef GObjectClass GSubprocessLauncherClass;
+
+G_DEFINE_TYPE (GSubprocessLauncher, g_subprocess_launcher, G_TYPE_OBJECT);
+
+static gboolean
+verify_disposition (const gchar      *stream_name,
+                    GSubprocessFlags  filtered_flags,
+                    gint              fd,
+                    const gchar      *filename)
+{
+  guint n_bits;
+
+  if (!filtered_flags)
+    n_bits = 0;
+  else if (((filtered_flags - 1) & filtered_flags) == 0)
+    n_bits = 1;
+  else
+    n_bits = 2; /* ...or more */
+
+  if (n_bits + (fd >= 0) + (filename != NULL) > 1)
+    {
+      GString *err;
+
+      err = g_string_new (NULL);
+      if (n_bits)
+        {
+          GFlagsClass *class;
+          GFlagsValue *value;
+
+          class = g_type_class_peek (G_TYPE_SUBPROCESS_FLAGS);
+          while ((value = g_flags_get_first_value (class, filtered_flags)))
+            {
+              g_string_append_printf (err, " %s", value->value_name);
+              filtered_flags &= value->value;
+            }
+
+          g_type_class_unref (class);
+        }
+
+      if (fd >= 0)
+        g_string_append_printf (err, " g_subprocess_launcher_take_%s_fd()", stream_name);
+
+      if (filename)
+        g_string_append_printf (err, " g_subprocess_launcher_set_%s_file_path()", stream_name);
+
+      g_critical ("You may specify at most one disposition for the %s stream, but you specified:%s.",
+                  stream_name, err->str);
+      g_string_free (err, TRUE);
+
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+verify_flags (GSubprocessFlags flags)
+{
+  return verify_disposition ("stdin", flags & ALL_STDIN_FLAGS, -1, NULL) &&
+         verify_disposition ("stdout", flags & ALL_STDOUT_FLAGS, -1, NULL) &&
+         verify_disposition ("stderr", flags & ALL_STDERR_FLAGS, -1, NULL);
+}
+
+static void
+g_subprocess_launcher_set_property (GObject *object, guint prop_id,
+                                    const GValue *value, GParamSpec *pspec)
+{
+  GSubprocessLauncher *launcher = G_SUBPROCESS_LAUNCHER (object);
+
+  g_assert (prop_id == 1);
+
+  if (verify_flags (g_value_get_flags (value)))
+    launcher->flags = g_value_get_flags (value);
+}
+
+static void
+g_subprocess_launcher_finalize (GObject *object)
+{
+  GSubprocessLauncher *self = G_SUBPROCESS_LAUNCHER (object);
+
+  g_strfreev (self->envp);
+  g_free (self->cwd);
+
+#ifdef G_OS_UNIX
+  g_free (self->stdin_path);
+  g_free (self->stdout_path);
+  g_free (self->stderr_path);
+
+  if (self->stdin_fd != -1)
+    close (self->stdin_fd);
+
+  if (self->stdout_fd != -1)
+    close (self->stdout_fd);
+
+  if (self->stderr_fd != -1)
+    close (self->stderr_fd);
+#endif
+
+  if (self->child_setup_destroy_notify)
+    (* self->child_setup_destroy_notify) (self->child_setup_user_data);
+
+  G_OBJECT_CLASS (g_subprocess_launcher_parent_class)->finalize (object);
+}
+
+static void
+g_subprocess_launcher_init (GSubprocessLauncher  *self)
+{
+  self->envp = g_listenv ();
+
+  self->stdin_fd = -1;
+  self->stdout_fd = -1;
+  self->stderr_fd = -1;
+}
+
+static void
+g_subprocess_launcher_class_init (GSubprocessLauncherClass *class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+  gobject_class->set_property = g_subprocess_launcher_set_property;
+  gobject_class->finalize = g_subprocess_launcher_finalize;
+
+  g_object_class_install_property (gobject_class, 1,
+                                   g_param_spec_flags ("flags", "Flags", "GSubprocessFlags for launched processes",
+                                                       G_TYPE_SUBPROCESS_FLAGS, 0, G_PARAM_WRITABLE |
+                                                       G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY));
+}
+
+/**
+ * g_subprocess_launcher_new:
+ *
+ * Creates a new #GSubprocessLauncher.
+ *
+ * The launcher is created with the default options.  A copy of the
+ * environment of the calling process is made at the time of this call
+ * and will be used as the environment that the process is launched in.
+ *
+ * Since: 2.36
+ **/
+GSubprocessLauncher *
+g_subprocess_launcher_new (GSubprocessFlags flags)
+{
+  if (!verify_flags (flags))
+    return NULL;
+
+  return g_object_new (G_TYPE_SUBPROCESS_LAUNCHER,
+                       "flags", flags,
+                       NULL);
+}
+
+/**
+ * g_subprocess_launcher_set_environ:
+ * @self: a #GSubprocess
+ * @environ: the replacement environment
+ *
+ * Replace the entire environment of processes launched from this
+ * launcher with the given 'environ' variable.
+ *
+ * Typically you will build this variable by using g_listenv() to copy
+ * the process 'environ' and using the functions g_environ_setenv(),
+ * g_environ_unsetenv(), etc.
+ *
+ * As an alternative, you can use g_subprocess_launcher_setenv(),
+ * g_subprocess_launcher_unsetenv(), etc.
+ *
+ * All strings in this array are expected to be in the GLib file name
+ * encoding.  On UNIX, this means that they can be arbitrary byte
+ * strings.  On Windows, they should be in UTF-8.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_set_environ (GSubprocessLauncher  *self,
+                                   gchar               **environ)
+{
+  g_strfreev (self->envp);
+  self->envp = g_strdupv (environ);
+}
+
+/**
+ * g_subprocess_launcher_setenv:
+ * @self: a #GSubprocess
+ * @variable: the environment variable to set, must not contain '='
+ * @value: the new value for the variable
+ * @overwrite: whether to change the variable if it already exists
+ *
+ * Sets the environment variable @variable in the environment of
+ * processes launched from this launcher.
+ *
+ * Both the variable's name and value should be in the GLib file name
+ * encoding. On UNIX, this means that they can be arbitrary byte
+ * strings. On Windows, they should be in UTF-8.
+ *
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_setenv (GSubprocessLauncher *self,
+                              const gchar         *variable,
+                              const gchar         *value,
+                              gboolean             overwrite)
+{
+  self->envp = g_environ_setenv (self->envp, variable, value, overwrite);
+}
+
+/**
+ * g_subprocess_launcher_unsetsenv:
+ * @self: a #GSubprocess
+ * @variable: the environment variable to unset, must not contain '='
+ *
+ * Removes the environment variable @variable from the environment of
+ * processes launched from this launcher.
+ *
+ * The variable name should be in the GLib file name encoding.  On UNIX,
+ * this means that they can be arbitrary byte strings.  On Windows, they
+ * should be in UTF-8.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_unsetenv (GSubprocessLauncher *self,
+                                const gchar         *variable)
+{
+  self->envp = g_environ_unsetenv (self->envp, variable);
+}
+
+/**
+ * g_subprocess_launcher_getenv:
+ * @self: a #GSubprocess
+ * @variable: the environment variable to get
+ *
+ * Returns the value of the environment variable @variable in the
+ * environment of processes launched from this launcher.
+ *
+ * The returned string is in the GLib file name encoding.  On UNIX, this
+ * means that it can be an arbitrary byte string.  On Windows, it will
+ * be UTF-8.
+ *
+ * Returns: the value of the environment variable, %NULL if unset
+ *
+ * Since: 2.36
+ **/
+const gchar *
+g_subprocess_launcher_getenv (GSubprocessLauncher *self,
+                              const gchar         *variable)
+{
+  return g_environ_getenv (self->envp, variable);
+}
+
+/**
+ * g_subprocess_launcher_set_cwd:
+ * @self: a #GSubprocess
+ * @cwd: the cwd for launched processes
+ *
+ * Sets the current working directory that processes will be launched
+ * with.
+ *
+ * By default processes are launched with the current working directory
+ * of the launching process at the time of launch.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_set_cwd (GSubprocessLauncher *self,
+                               const gchar         *cwd)
+{
+  g_free (self->cwd);
+  self->cwd = g_strdup (cwd);
+}
+
+/**
+ * g_subprocess_launcher_set_flags:
+ * @self: a #GSubprocessLauncher
+ * @flags: #GSubprocessFlags
+ *
+ * Sets the flags on the launcher.
+ *
+ * The default flags are %G_SUBPROCESS_FLAGS_NONE.
+ *
+ * You may not set flags that specify conflicting options for how to
+ * handle a particular stdio stream (eg: specifying both
+ * %G_SUBPROCESS_FLAGS_STDIN_PIPE and
+ * %G_SUBPROCESS_FLAGS_STDIN_INHERIT).
+ *
+ * You may also not set a flag that conflicts with a previous call to a
+ * function like g_subprocess_launcher_set_stdin_file_path() or
+ * g_subprocess_launcher_take_stdout_fd().
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_set_flags (GSubprocessLauncher *self,
+                                 GSubprocessFlags     flags)
+{
+  if (verify_disposition ("stdin", flags & ALL_STDIN_FLAGS, self->stdin_fd, self->stdin_path) &&
+      verify_disposition ("stdout", flags & ALL_STDOUT_FLAGS, self->stdout_fd, self->stdout_path) &&
+      verify_disposition ("stderr", flags & ALL_STDERR_FLAGS, self->stderr_fd, self->stderr_path))
+    self->flags = flags;
+}
+
+#ifdef G_OS_UNIX
+static void
+assign_fd (gint *fd_ptr, gint fd)
+{
+  gint flags;
+
+  if (*fd_ptr != -1)
+    close (*fd_ptr);
+
+  *fd_ptr = fd;
+
+  if (fd != -1)
+    {
+      /* best effort */
+      flags = fcntl (fd, F_GETFD);
+      if (~flags & FD_CLOEXEC)
+        fcntl (fd, F_SETFD, flags | FD_CLOEXEC);
+    }
+}
+
+/**
+ * g_subprocess_launcher_set_stdin_file_path:
+ * @self: a #GSubprocessLauncher
+ * @path: a filename or %NULL
+ *
+ * Sets the file path to use as the stdin for spawned processes.
+ *
+ * If @path is %NULL then any previously given path is unset.
+ *
+ * The file must exist or spawning the process will fail.
+ *
+ * You may not set a stdin file path if a stdin fd is already set or if
+ * the launcher flags contain any flags directing stdin elsewhere.
+ *
+ * This feature is only available on UNIX.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_set_stdin_file_path (GSubprocessLauncher *self,
+                                           const gchar         *path)
+{
+  if (verify_disposition ("stdin", self->flags & ALL_STDIN_FLAGS, self->stdin_fd, path))
+    {
+      g_free (self->stdin_path);
+      self->stdin_path = g_strdup (path);
+    }
+}
+
+/**
+ * g_subprocess_launcher_take_stdin_fd:
+ * @self: a #GSubprocessLauncher
+ * @fd: a file descriptor, or -1
+ *
+ * Sets the file descriptor to use as the stdin for spawned processes.
+ *
+ * If @fd is -1 then any previously given fd is unset.
+ *
+ * Note that if your intention is to have the stdin of the calling
+ * process inherited by the child then %G_SUBPROCESS_FLAGS_STDIN_INHERIT
+ * is a better way to go about doing that.
+ *
+ * The passed @fd is noted but will not be touched in the current
+ * process.  It is therefore necessary that it be kept open by the
+ * caller until the subprocess is spawned.  The file descriptor will
+ * also not be explicitly closed on the child side, so it must be marked
+ * O_CLOEXEC if that's what you want.
+ *
+ * You may not set a stdin fd if a stdin file path is already set or if
+ * the launcher flags contain any flags directing stdin elsewhere.
+ *
+ * This feature is only available on UNIX.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_take_stdin_fd (GSubprocessLauncher *self,
+                                     gint                 fd)
+{
+  if (verify_disposition ("stdin", self->flags & ALL_STDIN_FLAGS, fd, self->stdin_path))
+    assign_fd (&self->stdin_fd, fd);
+}
+
+/**
+ * g_subprocess_launcher_set_stdout_file_path:
+ * @self: a #GSubprocessLauncher
+ * @path: a filename or %NULL
+ *
+ * Sets the file path to use as the stdout for spawned processes.
+ *
+ * If @path is %NULL then any previously given path is unset.
+ *
+ * The file will be created or truncated when the process is spawned, as
+ * would be the case if using '>' at the shell.
+ *
+ * You may not set a stdout file path if a stdout fd is already set or
+ * if the launcher flags contain any flags directing stdout elsewhere.
+ *
+ * This feature is only available on UNIX.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_set_stdout_file_path (GSubprocessLauncher *self,
+                                            const gchar         *path)
+{
+  if (verify_disposition ("stdout", self->flags & ALL_STDOUT_FLAGS, self->stdout_fd, path))
+    {
+      g_free (self->stdout_path);
+      self->stdout_path = g_strdup (path);
+    }
+}
+
+/**
+ * g_subprocess_launcher_take_stdout_fd:
+ * @self: a #GSubprocessLauncher
+ * @fd: a file descriptor, or -1
+ *
+ * Sets the file descriptor to use as the stdout for spawned processes.
+ *
+ * If @fd is -1 then any previously given fd is unset.
+ *
+ * Note that the default behaviour is to pass stdout through to the
+ * stdout of the parent process.
+ *
+ * The passed @fd is noted but will not be touched in the current
+ * process.  It is therefore necessary that it be kept open by the
+ * caller until the subprocess is spawned.  The file descriptor will
+ * also not be explicitly closed on the child side, so it must be marked
+ * O_CLOEXEC if that's what you want.
+ *
+ * You may not set a stdout fd if a stdout file path is already set or
+ * if the launcher flags contain any flags directing stdout elsewhere.
+ *
+ * This feature is only available on UNIX.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_take_stdout_fd (GSubprocessLauncher *self,
+                                      gint                 fd)
+{
+  if (verify_disposition ("stdout", self->flags & ALL_STDOUT_FLAGS, fd, self->stdout_path))
+    assign_fd (&self->stdout_fd, fd);
+}
+
+/**
+ * g_subprocess_launcher_set_stderr_file_path:
+ * @self: a #GSubprocessLauncher
+ * @path: a filename or %NULL
+ *
+ * Sets the file path to use as the stderr for spawned processes.
+ *
+ * If @path is %NULL then any previously given path is unset.
+ *
+ * The file will be created or truncated when the process is spawned, as
+ * would be the case if using '2>' at the shell.
+ *
+ * If you want to send both stdout and stderr to the same file then use
+ * %G_SUBPROCESS_FLAGS_STDERR_MERGE.
+ *
+ * You may not set a stderr file path if a stderr fd is already set or
+ * if the launcher flags contain any flags directing stderr elsewhere.
+ *
+ * This feature is only available on UNIX.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_set_stderr_file_path (GSubprocessLauncher *self,
+                                            const gchar         *path)
+{
+  if (verify_disposition ("stderr", self->flags & ALL_STDERR_FLAGS, self->stderr_fd, path))
+    {
+      g_free (self->stderr_path);
+      self->stderr_path = g_strdup (path);
+    }
+}
+
+/**
+ * g_subprocess_launcher_take_stderr_fd:
+ * @self: a #GSubprocessLauncher
+ * @fd: a file descriptor, or -1
+ *
+ * Sets the file descriptor to use as the stderr for spawned processes.
+ *
+ * If @fd is -1 then any previously given fd is unset.
+ *
+ * Note that the default behaviour is to pass stderr through to the
+ * stderr of the parent process.
+ *
+ * The passed @fd belongs to the #GSubprocessLauncher.  It will be
+ * automatically closed when the launcher is finalized.  The file
+ * descriptor will also be closed on the child side when executing the
+ * spawned process.
+ *
+ * You may not set a stderr fd if a stderr file path is already set or
+ * if the launcher flags contain any flags directing stderr elsewhere.
+ *
+ * This feature is only available on UNIX.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_take_stderr_fd (GSubprocessLauncher *self,
+                                     gint                 fd)
+{
+  if (verify_disposition ("stderr", self->flags & ALL_STDERR_FLAGS, fd, self->stderr_path))
+    assign_fd (&self->stderr_fd, fd);
+}
+
+/**
+ * g_subprocess_launcher_set_child_setup:
+ * @self: a #GSubprocessLauncher
+ * @child_setup: a #GSpawnChildSetupFunc to use as the child setup function
+ * @user_data: user data for @child_setup
+ * @destroy_notify: a #GDestroyNotify for @user_data
+ *
+ * Sets up a child setup function.
+ *
+ * The child setup function will be called after fork() but before
+ * exec() on the child's side.
+ *
+ * @destroy_notify will not be automatically called on the child's side
+ * of the fork().  It will only be called when the last reference on the
+ * #GSubprocessLauncher is dropped or when a new child setup function is
+ * given.
+ *
+ * %NULL can be given as @child_setup to disable the functionality.
+ *
+ * Child setup functions are only available on UNIX.
+ *
+ * Since: 2.36
+ **/
+void
+g_subprocess_launcher_set_child_setup (GSubprocessLauncher  *self,
+                                       GSpawnChildSetupFunc  child_setup,
+                                       gpointer              user_data,
+                                       GDestroyNotify        destroy_notify)
+{
+  if (self->child_setup_destroy_notify)
+    (* self->child_setup_destroy_notify) (self->child_setup_user_data);
+
+  self->child_setup_func = child_setup;
+  self->child_setup_user_data = user_data;
+  self->child_setup_destroy_notify = destroy_notify;
+}
+#endif
+
+GSubprocess *
+g_subprocess_launcher_spawn (GSubprocessLauncher  *launcher,
+                             GError              **error,
+                             const gchar          *argv0,
+                             ...)
+{
+  GSubprocess *result;
+  GPtrArray *args;
+  const gchar *arg;
+  va_list ap;
+
+  g_return_val_if_fail (argv0 != NULL && argv0[0] != '\0', NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
+  args = g_ptr_array_new ();
+
+  va_start (ap, argv0);
+  g_ptr_array_add (args, (gchar *) argv0);
+  while ((arg = va_arg (ap, const gchar *)))
+    g_ptr_array_add (args, (gchar *) arg);
+
+  result = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
+
+  g_ptr_array_free (args, TRUE);
+
+  return result;
+
+}
+
+GSubprocess *
+g_subprocess_launcher_spawnv (GSubprocessLauncher  *launcher,
+                              const gchar * const  *argv,
+                              GError              **error)
+{
+  GSubprocess *subprocess;
+
+  g_return_val_if_fail (argv != NULL && argv[0] != NULL && argv[0][0] != '\0', NULL);
+
+  subprocess = g_object_new (G_TYPE_SUBPROCESS,
+                             "argv", argv,
+                             "flags", launcher->flags,
+                             NULL);
+  g_subprocess_set_launcher (subprocess, launcher);
+
+  if (!g_initable_init (G_INITABLE (subprocess), NULL, error))
+    {
+      g_object_unref (subprocess);
+      return NULL;
+    }
+
+  return subprocess;
+}
diff --git a/gio/gsubprocesslauncher.h b/gio/gsubprocesslauncher.h
new file mode 100644
index 000000000..41b065224
--- /dev/null
+++ b/gio/gsubprocesslauncher.h
@@ -0,0 +1,113 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright © 2012 Colin Walters <walters@verbum.org>
+ * Copyright © 2012 Canonical Limited
+ *
+ * This library 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.
+ *
+ * This library 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 this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: Ryan Lortie <desrt@desrt.ca>
+ * Author: Colin Walters <walters@verbum.org>
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_SUBPROCESS_LAUNCHER_H__
+#define __G_SUBPROCESS_LAUNCHER_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SUBPROCESS_LAUNCHER         (g_subprocess_launcher_get_type ())
+#define G_SUBPROCESS_LAUNCHER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_SUBPROCESS_LAUNCHER, GSubprocessLauncher))
+#define G_IS_SUBPROCESS_LAUNCHER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_SUBPROCESS_LAUNCHER))
+
+GLIB_AVAILABLE_IN_2_36
+GType                   g_subprocess_launcher_get_type                  (void) G_GNUC_CONST;
+
+GLIB_AVAILABLE_IN_2_36
+GSubprocessLauncher *   g_subprocess_launcher_new                       (GSubprocessFlags       flags);
+
+GLIB_AVAILABLE_IN_2_36
+GSubprocess *           g_subprocess_launcher_spawn                     (GSubprocessLauncher   *self,
+                                                                         GError               **error,
+                                                                         const gchar           *argv0,
+                                                                         ...);
+
+GLIB_AVAILABLE_IN_2_36
+GSubprocess *           g_subprocess_launcher_spawnv                    (GSubprocessLauncher   *self,
+                                                                         const gchar * const   *argv,
+                                                                         GError               **error);
+
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_set_environ               (GSubprocessLauncher   *self,
+                                                                         gchar                **environ);
+
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_setenv                    (GSubprocessLauncher   *self,
+                                                                         const gchar           *variable,
+                                                                         const gchar           *value,
+                                                                         gboolean               overwrite);
+
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_unsetenv                  (GSubprocessLauncher *self,
+                                                                         const gchar         *variable);
+
+GLIB_AVAILABLE_IN_2_36
+const gchar *           g_subprocess_launcher_getenv                    (GSubprocessLauncher   *self,
+                                                                         const gchar           *variable);
+
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_set_cwd                   (GSubprocessLauncher   *self,
+                                                                         const gchar           *cwd);
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_set_flags                 (GSubprocessLauncher   *self,
+                                                                         GSubprocessFlags       flags);
+
+/* Extended I/O control, only available on UNIX */
+#ifdef G_OS_UNIX
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_set_stdin_file_path       (GSubprocessLauncher   *self,
+                                                                         const gchar           *path);
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_take_stdin_fd             (GSubprocessLauncher   *self,
+                                                                         gint                   fd);
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_set_stdout_file_path      (GSubprocessLauncher   *self,
+                                                                         const gchar           *path);
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_take_stdout_fd            (GSubprocessLauncher   *self,
+                                                                         gint                   fd);
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_set_stderr_file_path      (GSubprocessLauncher   *self,
+                                                                         const gchar           *path);
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_take_stderr_fd            (GSubprocessLauncher   *self,
+                                                                         gint                   fd);
+
+/* Child setup, only available on UNIX */
+GLIB_AVAILABLE_IN_2_36
+void                    g_subprocess_launcher_set_child_setup           (GSubprocessLauncher   *self,
+                                                                         GSpawnChildSetupFunc   child_setup,
+                                                                         gpointer               user_data,
+                                                                         GDestroyNotify         destroy_notify);
+#endif
+
+G_END_DECLS
+
+#endif /* __G_SUBPROCESS_H__ */
diff --git a/gio/tests/.gitignore b/gio/tests/.gitignore
index f9e0587d7..32649fd03 100644
--- a/gio/tests/.gitignore
+++ b/gio/tests/.gitignore
@@ -68,6 +68,8 @@ gdbus-test-codegen-generated*
 gdbus-test-fixture
 gdbus-testserver
 gdbus-threading
+gsubprocess
+gsubprocess-testprog
 g-file
 g-file-info
 g-icon
diff --git a/gio/tests/Makefile.am b/gio/tests/Makefile.am
index 131b42a78..28be06a87 100644
--- a/gio/tests/Makefile.am
+++ b/gio/tests/Makefile.am
@@ -33,6 +33,7 @@ test_programs = \
 	g-icon					\
 	gdbus-addresses				\
 	gdbus-message				\
+	gsubprocess				\
 	inet-address				\
 	io-stream				\
 	memory-input-stream			\
@@ -94,6 +95,7 @@ uninstalled_test_extra_programs = \
 test_extra_programs = \
 	gdbus-connection-flush-helper		\
 	gdbus-testserver			\
+	gsubprocess-testprog			\
 	$(NULL)
 
 dist_uninstalled_test_data += $(addprefix schema-tests/,$(schema_tests))
diff --git a/gio/tests/gsubprocess-testprog.c b/gio/tests/gsubprocess-testprog.c
new file mode 100644
index 000000000..3d8e5cc9a
--- /dev/null
+++ b/gio/tests/gsubprocess-testprog.c
@@ -0,0 +1,172 @@
+#include <gio/gio.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#ifdef G_OS_UNIX
+#include <gio/gunixinputstream.h>
+#include <gio/gunixoutputstream.h>
+#endif
+
+static GOptionEntry options[] = {
+  {NULL}
+};
+
+static void
+write_all (int           fd,
+	   const guint8* buf,
+	   gsize         len)
+{
+  while (len > 0)
+    {
+      ssize_t bytes_written = write (fd, buf, len);
+      if (bytes_written < 0)
+	g_error ("Failed to write to fd %d: %s",
+		 fd, strerror (errno));
+      buf += bytes_written;
+      len -= bytes_written;
+    }
+}
+
+static int
+echo_mode (int argc,
+	   char **argv)
+{
+  int i;
+
+  for (i = 2; i < argc; i++)
+    {
+      write_all (1, (guint8*)argv[i], strlen (argv[i]));
+      write_all (1, (guint8*)"\n", 1);
+    }
+
+  return 0;
+}
+
+static int
+echo_stdout_and_stderr_mode (int argc,
+			     char **argv)
+{
+  int i;
+
+  for (i = 2; i < argc; i++)
+    {
+      write_all (1, (guint8*)argv[i], strlen (argv[i]));
+      write_all (1, (guint8*)"\n", 1);
+      write_all (2, (guint8*)argv[i], strlen (argv[i]));
+      write_all (2, (guint8*)"\n", 1);
+    }
+
+  return 0;
+}
+
+static int
+cat_mode (int argc,
+	  char **argv)
+{
+  GIOChannel *chan_stdin;
+  GIOChannel *chan_stdout;
+  GIOStatus status;
+  char buf[1024];
+  gsize bytes_read, bytes_written;
+  GError *local_error = NULL;
+  GError **error = &local_error;
+
+  chan_stdin = g_io_channel_unix_new (0);
+  g_io_channel_set_encoding (chan_stdin, NULL, error);
+  g_assert_no_error (local_error);
+  chan_stdout = g_io_channel_unix_new (1);
+  g_io_channel_set_encoding (chan_stdout, NULL, error);
+  g_assert_no_error (local_error);
+
+  while (TRUE)
+    {
+      do
+	status = g_io_channel_read_chars (chan_stdin, buf, sizeof (buf),
+					  &bytes_read, error);
+      while (status == G_IO_STATUS_AGAIN);
+
+      if (status == G_IO_STATUS_EOF || status == G_IO_STATUS_ERROR)
+	break;
+
+      do
+	status = g_io_channel_write_chars (chan_stdout, buf, bytes_read,
+					   &bytes_written, error);
+      while (status == G_IO_STATUS_AGAIN);
+
+      if (status == G_IO_STATUS_EOF || status == G_IO_STATUS_ERROR)
+	break;
+    }
+
+  g_io_channel_unref (chan_stdin);
+  g_io_channel_unref (chan_stdout);
+
+  if (local_error)
+    {
+      g_printerr ("I/O error: %s\n", local_error->message);
+      g_clear_error (&local_error);
+      return 1;
+    }
+  return 0;
+}
+
+static gint
+sleep_forever_mode (int argc,
+		    char **argv)
+{
+  GMainLoop *loop;
+  
+  loop = g_main_loop_new (NULL, TRUE);
+  g_main_loop_run (loop);
+
+  return 0;
+}
+
+int
+main (int argc, char **argv)
+{
+  GOptionContext *context;
+  GError *error = NULL;
+  const char *mode;
+
+  context = g_option_context_new ("MODE - Test GSubprocess stuff");
+  g_option_context_add_main_entries (context, options, NULL);
+  if (!g_option_context_parse (context, &argc, &argv, &error))
+    {
+      g_printerr ("%s: %s\n", argv[0], error->message);
+      return 1;
+    }
+
+  if (argc < 2)
+    {
+      g_printerr ("MODE argument required\n");
+      return 1;
+    }
+
+  mode = argv[1];
+  if (strcmp (mode, "noop") == 0)
+    return 0;
+  else if (strcmp (mode, "exit1") == 0)
+    return 1;
+  else if (strcmp (mode, "assert-argv0") == 0)
+    {
+      if (strcmp (argv[0], "moocow") == 0)
+	return 0;
+      g_printerr ("argv0=%s != moocow\n", argv[0]);
+      return 1;
+    }
+  else if (strcmp (mode, "echo") == 0)
+    return echo_mode (argc, argv);
+  else if (strcmp (mode, "echo-stdout-and-stderr") == 0)
+    return echo_stdout_and_stderr_mode (argc, argv);
+  else if (strcmp (mode, "cat") == 0)
+    return cat_mode (argc, argv);
+  else if (strcmp (mode, "sleep-forever") == 0)
+    return sleep_forever_mode (argc, argv);
+  else
+    {
+      g_printerr ("Unknown MODE %s\n", argv[1]);
+      return 1;
+    }
+
+  return TRUE;
+}
diff --git a/gio/tests/gsubprocess.c b/gio/tests/gsubprocess.c
new file mode 100644
index 000000000..0c007e931
--- /dev/null
+++ b/gio/tests/gsubprocess.c
@@ -0,0 +1,784 @@
+#include <gio/gio.h>
+#include <string.h>
+
+#ifdef G_OS_UNIX
+#include <sys/wait.h>
+#include <gio/gfiledescriptorbased.h>
+#endif
+
+static GPtrArray *
+get_test_subprocess_args (const char *mode,
+                          ...) G_GNUC_NULL_TERMINATED;
+
+static GPtrArray *
+get_test_subprocess_args (const char *mode,
+                          ...)
+{
+  GPtrArray *ret;
+  const char *binname;
+  va_list args;
+  gpointer arg;
+
+#ifdef G_OS_WIN32
+  binname = "gsubprocess-testprog.exe";
+#else
+  binname = "gsubprocess-testprog";
+#endif
+
+  ret = g_ptr_array_new_with_free_func (g_free);
+  g_ptr_array_add (ret, g_test_build_filename (G_TEST_BUILT, binname, NULL));
+  g_ptr_array_add (ret, g_strdup (mode));
+
+  va_start (args, mode);
+  while ((arg = va_arg (args, gpointer)) != NULL)
+    g_ptr_array_add (ret, g_strdup (arg));
+  va_end (args);
+
+  g_ptr_array_add (ret, NULL);
+  return ret;
+}
+
+static void
+test_noop (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GPtrArray *args;
+  GSubprocess *proc;
+
+  args = get_test_subprocess_args ("noop", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_object_unref (proc);
+}
+
+static void
+test_noop_all_to_null (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GPtrArray *args;
+  GSubprocess *proc;
+
+  args = get_test_subprocess_args ("noop", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata,
+                            G_SUBPROCESS_FLAGS_STDOUT_SILENCE | G_SUBPROCESS_FLAGS_STDERR_SILENCE,
+                            error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_object_unref (proc);
+}
+
+static void
+test_noop_no_wait (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GPtrArray *args;
+  GSubprocess *proc;
+
+  args = get_test_subprocess_args ("noop", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  g_object_unref (proc);
+}
+
+static void
+test_noop_stdin_inherit (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GPtrArray *args;
+  GSubprocess *proc;
+
+  args = get_test_subprocess_args ("noop", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_STDIN_INHERIT, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_object_unref (proc);
+}
+
+#ifdef G_OS_UNIX
+static void
+test_search_path (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocess *proc;
+
+  proc = g_subprocess_new (G_SUBPROCESS_FLAGS_NONE, error, "true", NULL);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_object_unref (proc);
+}
+#endif
+
+static void
+test_exit1 (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GPtrArray *args;
+  GSubprocess *proc;
+
+  args = get_test_subprocess_args ("exit1", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+  g_assert_error (local_error, G_SPAWN_EXIT_ERROR, 1);
+  g_clear_error (error);
+
+  g_object_unref (proc);
+}
+
+static gchar *
+splice_to_string (GInputStream   *stream,
+                  GError        **error)
+{
+  GMemoryOutputStream *buffer = NULL;
+  char *ret = NULL;
+
+  buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
+  if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
+    goto out;
+
+  if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
+    goto out;
+
+  if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
+    goto out;
+
+  ret = g_memory_output_stream_steal_data (buffer);
+ out:
+  g_clear_object (&buffer);
+  return ret;
+}
+
+static void
+test_echo1 (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocess *proc;
+  GPtrArray *args;
+  GInputStream *stdout;
+  gchar *result;
+
+  args = get_test_subprocess_args ("echo", "hello", "world!", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_STDOUT_PIPE, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  stdout = g_subprocess_get_stdout_pipe (proc);
+
+  result = splice_to_string (stdout, error);
+  g_assert_no_error (local_error);
+
+  g_assert_cmpstr (result, ==, "hello\nworld!\n");
+
+  g_free (result);
+  g_object_unref (proc);
+}
+
+#ifdef G_OS_UNIX
+static void
+test_echo_merged (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocess *proc;
+  GPtrArray *args;
+  GInputStream *stdout;
+  gchar *result;
+
+  args = get_test_subprocess_args ("echo-stdout-and-stderr", "merge", "this", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata,
+                            G_SUBPROCESS_FLAGS_STDOUT_PIPE | G_SUBPROCESS_FLAGS_STDERR_MERGE,
+                            error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  stdout = g_subprocess_get_stdout_pipe (proc);
+  result = splice_to_string (stdout, error);
+  g_assert_no_error (local_error);
+
+  g_assert_cmpstr (result, ==, "merge\nmerge\nthis\nthis\n");
+
+  g_free (result);
+  g_object_unref (proc);
+}
+#endif
+
+typedef struct {
+  guint events_pending;
+  GMainLoop *loop;
+} TestCatData;
+
+static void
+test_cat_on_input_splice_complete (GObject      *object,
+                                   GAsyncResult *result,
+                                   gpointer      user_data)
+{
+  TestCatData *data = user_data;
+  GError *error = NULL;
+
+  (void)g_output_stream_splice_finish ((GOutputStream*)object, result, &error);
+  g_assert_no_error (error);
+
+  data->events_pending--;
+  if (data->events_pending == 0)
+    g_main_loop_quit (data->loop);
+}
+
+static void
+test_cat_utf8 (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocess *proc;
+  GPtrArray *args;
+  GBytes *input_buf;
+  GBytes *output_buf;
+  GInputStream *input_buf_stream = NULL;
+  GOutputStream *output_buf_stream = NULL;
+  GOutputStream *stdin_stream = NULL;
+  GInputStream *stdout_stream = NULL;
+  TestCatData data;
+
+  memset (&data, 0, sizeof (data));
+  data.loop = g_main_loop_new (NULL, TRUE);
+
+  args = get_test_subprocess_args ("cat", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata,
+                            G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE,
+                            error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  stdin_stream = g_subprocess_get_stdin_pipe (proc);
+  stdout_stream = g_subprocess_get_stdout_pipe (proc);
+
+  input_buf = g_bytes_new_static ("hello, world!", strlen ("hello, world!"));
+  input_buf_stream = g_memory_input_stream_new_from_bytes (input_buf);
+  g_bytes_unref (input_buf);
+
+  output_buf_stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
+
+  g_output_stream_splice_async (stdin_stream, input_buf_stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
+                                G_PRIORITY_DEFAULT, NULL, test_cat_on_input_splice_complete,
+                                &data);
+  data.events_pending++;
+  g_output_stream_splice_async (output_buf_stream, stdout_stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
+                                G_PRIORITY_DEFAULT, NULL, test_cat_on_input_splice_complete,
+                                &data);
+  data.events_pending++;
+
+  g_main_loop_run (data.loop);
+
+  g_subprocess_wait_check (proc, NULL, error);
+  g_assert_no_error (local_error);
+
+  output_buf = g_memory_output_stream_steal_as_bytes ((GMemoryOutputStream*)output_buf_stream);
+
+  g_assert_cmpint (g_bytes_get_size (output_buf), ==, 13);
+  g_assert_cmpint (memcmp (g_bytes_get_data (output_buf, NULL), "hello, world!", 13), ==, 0);
+
+  g_bytes_unref (output_buf);
+  g_main_loop_unref (data.loop);
+  g_object_unref (input_buf_stream);
+  g_object_unref (output_buf_stream);
+  g_object_unref (proc);
+}
+
+static gpointer
+cancel_soon (gpointer user_data)
+{
+  GCancellable *cancellable = user_data;
+
+  g_usleep (G_TIME_SPAN_SECOND);
+  g_cancellable_cancel (cancellable);
+  g_object_unref (cancellable);
+
+  return NULL;
+}
+
+static void
+test_cat_eof (void)
+{
+  GCancellable *cancellable;
+  GError *error = NULL;
+  GSubprocess *cat;
+  gboolean result;
+  gchar buffer;
+  gssize s;
+
+  /* Spawn 'cat' */
+  cat = g_subprocess_new (G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE, &error, "cat", NULL);
+  g_assert_no_error (error);
+  g_assert (cat);
+
+  /* Make sure that reading stdout blocks (until we cancel) */
+  cancellable = g_cancellable_new ();
+  g_thread_unref (g_thread_new ("cancel thread", cancel_soon, g_object_ref (cancellable)));
+  s = g_input_stream_read (g_subprocess_get_stdout_pipe (cat), &buffer, sizeof buffer, cancellable, &error);
+  g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
+  g_assert_cmpint (s, ==, -1);
+  g_object_unref (cancellable);
+  g_clear_error (&error);
+
+  /* Close the stream (EOF on cat's stdin) */
+  result = g_output_stream_close (g_subprocess_get_stdin_pipe (cat), NULL, &error);
+  g_assert_no_error (error);
+  g_assert (result);
+
+  /* Now check that reading cat's stdout gets us an EOF (since it quit) */
+  s = g_input_stream_read (g_subprocess_get_stdout_pipe (cat), &buffer, sizeof buffer, NULL, &error);
+  g_assert_no_error (error);
+  g_assert (!s);
+
+  /* Check that the process has exited as a result of the EOF */
+  result = g_subprocess_wait (cat, NULL, &error);
+  g_assert_no_error (error);
+  g_assert (g_subprocess_get_if_exited (cat));
+  g_assert_cmpint (g_subprocess_get_exit_status (cat), ==, 0);
+  g_assert (result);
+
+  g_object_unref (cat);
+}
+
+typedef struct {
+  guint events_pending;
+  gboolean caught_error;
+  GError *error;
+  GMainLoop *loop;
+
+  gint counter;
+  GOutputStream *first_stdin;
+} TestMultiSpliceData;
+
+static void
+on_one_multi_splice_done (GObject       *obj,
+                          GAsyncResult  *res,
+                          gpointer       user_data)
+{
+  TestMultiSpliceData *data = user_data;
+
+  if (!data->caught_error)
+    {
+      if (g_output_stream_splice_finish ((GOutputStream*)obj, res, &data->error) < 0)
+        data->caught_error = TRUE;
+    }
+
+  data->events_pending--;
+  if (data->events_pending == 0)
+    g_main_loop_quit (data->loop);
+}
+
+static gboolean
+on_idle_multisplice (gpointer     user_data)
+{
+  TestMultiSpliceData *data = user_data;
+
+  /* We write 2^1 + 2^2 ... + 2^10 or 2047 copies of "Hello World!\n"
+   * ultimately
+   */
+  if (data->counter >= 2047 || data->caught_error)
+    {
+      if (!g_output_stream_close (data->first_stdin, NULL, &data->error))
+        data->caught_error = TRUE;
+      data->events_pending--;
+      if (data->events_pending == 0)
+        {
+          g_main_loop_quit (data->loop);
+        }
+      return FALSE;
+    }
+  else
+    {
+      int i;
+      for (i = 0; i < data->counter; i++)
+        {
+          gsize bytes_written;
+          if (!g_output_stream_write_all (data->first_stdin, "hello world!\n",
+                                          strlen ("hello world!\n"), &bytes_written,
+                                          NULL, &data->error))
+            {
+              data->caught_error = TRUE;
+              return FALSE;
+            }
+        }
+      data->counter *= 2;
+      return TRUE;
+    }
+}
+
+static void
+on_subprocess_exited (GObject         *object,
+                      GAsyncResult    *result,
+                      gpointer         user_data)
+{
+  GSubprocess *subprocess = G_SUBPROCESS (object);
+  TestMultiSpliceData *data = user_data;
+  GError *error = NULL;
+
+  if (!g_subprocess_wait_finish (subprocess, result, &error))
+    {
+      if (!data->caught_error)
+        {
+          data->caught_error = TRUE;
+          g_propagate_error (&data->error, error);
+        }
+    }
+  g_spawn_check_exit_status (g_subprocess_get_exit_status (subprocess), &error);
+  g_assert_no_error (error);
+  data->events_pending--;
+  if (data->events_pending == 0)
+    g_main_loop_quit (data->loop);
+}
+
+static void
+test_multi_1 (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GPtrArray *args;
+  GSubprocessLauncher *launcher;
+  GSubprocess *first;
+  GSubprocess *second;
+  GSubprocess *third;
+  GOutputStream *first_stdin;
+  GInputStream *first_stdout;
+  GOutputStream *second_stdin;
+  GInputStream *second_stdout;
+  GOutputStream *third_stdin;
+  GInputStream *third_stdout;
+  GOutputStream *membuf;
+  TestMultiSpliceData data;
+  int splice_flags = G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET;
+
+  args = get_test_subprocess_args ("cat", NULL);
+  launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE);
+  first = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
+  g_assert_no_error (local_error);
+  second = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
+  g_assert_no_error (local_error);
+  third = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
+  g_assert_no_error (local_error);
+
+  g_ptr_array_free (args, TRUE);
+
+  membuf = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
+
+  first_stdin = g_subprocess_get_stdin_pipe (first);
+  first_stdout = g_subprocess_get_stdout_pipe (first);
+  second_stdin = g_subprocess_get_stdin_pipe (second);
+  second_stdout = g_subprocess_get_stdout_pipe (second);
+  third_stdin = g_subprocess_get_stdin_pipe (third);
+  third_stdout = g_subprocess_get_stdout_pipe (third);
+
+  memset (&data, 0, sizeof (data));
+  data.loop = g_main_loop_new (NULL, TRUE);
+  data.counter = 1;
+  data.first_stdin = first_stdin;
+
+  data.events_pending++;
+  g_output_stream_splice_async (second_stdin, first_stdout, splice_flags, G_PRIORITY_DEFAULT,
+                                NULL, on_one_multi_splice_done, &data);
+  data.events_pending++;
+  g_output_stream_splice_async (third_stdin, second_stdout, splice_flags, G_PRIORITY_DEFAULT,
+                                NULL, on_one_multi_splice_done, &data);
+  data.events_pending++;
+  g_output_stream_splice_async (membuf, third_stdout, splice_flags, G_PRIORITY_DEFAULT,
+                                NULL, on_one_multi_splice_done, &data);
+
+  data.events_pending++;
+  g_timeout_add (250, on_idle_multisplice, &data);
+
+  data.events_pending++;
+  g_subprocess_wait_async (first, NULL, on_subprocess_exited, &data);
+  data.events_pending++;
+  g_subprocess_wait_async (second, NULL, on_subprocess_exited, &data);
+  data.events_pending++;
+  g_subprocess_wait_async (third, NULL, on_subprocess_exited, &data);
+
+  g_main_loop_run (data.loop);
+
+  g_assert (!data.caught_error);
+  g_assert_no_error (data.error);
+
+  g_assert_cmpint (g_memory_output_stream_get_data_size ((GMemoryOutputStream*)membuf), ==, 26611);
+
+  g_main_loop_unref (data.loop);
+  g_object_unref (membuf);
+  g_object_unref (launcher);
+  g_object_unref (first);
+  g_object_unref (second);
+  g_object_unref (third);
+}
+
+static gboolean
+send_terminate (gpointer   user_data)
+{
+  GSubprocess *proc = user_data;
+
+  g_subprocess_force_exit (proc);
+
+  return FALSE;
+}
+
+static void
+on_request_quit_exited (GObject        *object,
+                        GAsyncResult   *result,
+                        gpointer        user_data)
+{
+  GSubprocess *subprocess = G_SUBPROCESS (object);
+  GError *error = NULL;
+
+  g_subprocess_wait_finish (subprocess, result, &error);
+  g_assert_no_error (error);
+#ifdef G_OS_UNIX
+  g_assert (g_subprocess_get_if_signaled (subprocess));
+  g_assert (g_subprocess_get_term_sig (subprocess) == 9);
+#endif
+  g_spawn_check_exit_status (g_subprocess_get_status (subprocess), &error);
+  g_assert (error != NULL);
+  g_clear_error (&error);
+
+  g_main_loop_quit ((GMainLoop*)user_data);
+}
+
+static void
+test_terminate (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocess *proc;
+  GPtrArray *args;
+  GMainLoop *loop;
+
+  args = get_test_subprocess_args ("sleep-forever", NULL);
+  proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  loop = g_main_loop_new (NULL, TRUE);
+
+  g_subprocess_wait_async (proc, NULL, on_request_quit_exited, loop);
+
+  g_timeout_add_seconds (3, send_terminate, proc);
+
+  g_main_loop_run (loop);
+
+  g_main_loop_unref (loop);
+  g_object_unref (proc);
+}
+
+#ifdef G_OS_UNIX
+static void
+test_stdout_file (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocessLauncher *launcher;
+  GSubprocess *proc;
+  GPtrArray *args;
+  GFile *tmpfile;
+  GFileIOStream *iostream;
+  GOutputStream *stdin;
+  const char *test_data = "this is some test data\n";
+  char *tmp_contents;
+  char *tmp_file_path;
+
+  tmpfile = g_file_new_tmp ("gsubprocessXXXXXX", &iostream, error);
+  g_assert_no_error (local_error);
+  g_clear_object (&iostream);
+
+  tmp_file_path = g_file_get_path (tmpfile);
+
+  args = get_test_subprocess_args ("cat", NULL);
+  launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE);
+  g_subprocess_launcher_set_stdout_file_path (launcher, tmp_file_path);
+  proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  stdin = g_subprocess_get_stdin_pipe (proc);
+
+  g_output_stream_write_all (stdin, test_data, strlen (test_data), NULL, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_output_stream_close (stdin, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+
+  g_object_unref (launcher);
+  g_object_unref (proc);
+
+  g_file_load_contents (tmpfile, NULL, &tmp_contents, NULL, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_assert_cmpstr (test_data, ==, tmp_contents);
+  g_free (tmp_contents);
+
+  (void) g_file_delete (tmpfile, NULL, NULL);
+  g_free (tmp_file_path);
+}
+
+static void
+test_stdout_fd (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocessLauncher *launcher;
+  GSubprocess *proc;
+  GPtrArray *args;
+  GFile *tmpfile;
+  GFileIOStream *iostream;
+  GFileDescriptorBased *descriptor_stream;
+  GOutputStream *stdin;
+  const char *test_data = "this is some test data\n";
+  char *tmp_contents;
+
+  tmpfile = g_file_new_tmp ("gsubprocessXXXXXX", &iostream, error);
+  g_assert_no_error (local_error);
+
+  args = get_test_subprocess_args ("cat", NULL);
+  launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE);
+  descriptor_stream = G_FILE_DESCRIPTOR_BASED (g_io_stream_get_output_stream (G_IO_STREAM (iostream)));
+  g_subprocess_launcher_take_stdout_fd (launcher, dup (g_file_descriptor_based_get_fd (descriptor_stream)));
+  proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  g_clear_object (&iostream);
+
+  stdin = g_subprocess_get_stdin_pipe (proc);
+
+  g_output_stream_write_all (stdin, test_data, strlen (test_data), NULL, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_output_stream_close (stdin, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+
+  g_object_unref (launcher);
+  g_object_unref (proc);
+
+  g_file_load_contents (tmpfile, NULL, &tmp_contents, NULL, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_assert_cmpstr (test_data, ==, tmp_contents);
+  g_free (tmp_contents);
+
+  (void) g_file_delete (tmpfile, NULL, NULL);
+}
+
+static void
+child_setup (gpointer user_data)
+{
+  dup2 (GPOINTER_TO_INT (user_data), 1);
+}
+
+static void
+test_child_setup (void)
+{
+  GError *local_error = NULL;
+  GError **error = &local_error;
+  GSubprocessLauncher *launcher;
+  GSubprocess *proc;
+  GPtrArray *args;
+  GFile *tmpfile;
+  GFileIOStream *iostream;
+  GOutputStream *stdin;
+  const char *test_data = "this is some test data\n";
+  char *tmp_contents;
+  int fd;
+
+  tmpfile = g_file_new_tmp ("gsubprocessXXXXXX", &iostream, error);
+  g_assert_no_error (local_error);
+
+  fd = g_file_descriptor_based_get_fd (G_FILE_DESCRIPTOR_BASED (g_io_stream_get_output_stream (G_IO_STREAM (iostream))));
+
+  args = get_test_subprocess_args ("cat", NULL);
+  launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE);
+  g_subprocess_launcher_set_child_setup (launcher, child_setup, GINT_TO_POINTER (fd), NULL);
+  proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
+  g_ptr_array_free (args, TRUE);
+  g_assert_no_error (local_error);
+
+  g_clear_object (&iostream);
+
+  stdin = g_subprocess_get_stdin_pipe (proc);
+
+  g_output_stream_write_all (stdin, test_data, strlen (test_data), NULL, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_output_stream_close (stdin, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_subprocess_wait_check (proc, NULL, error);
+
+  g_object_unref (launcher);
+  g_object_unref (proc);
+
+  g_file_load_contents (tmpfile, NULL, &tmp_contents, NULL, NULL, error);
+  g_assert_no_error (local_error);
+
+  g_assert_cmpstr (test_data, ==, tmp_contents);
+  g_free (tmp_contents);
+
+  (void) g_file_delete (tmpfile, NULL, NULL);
+}
+#endif
+
+int
+main (int argc, char **argv)
+{
+  g_test_init (&argc, &argv, NULL);
+
+  g_test_add_func ("/gsubprocess/noop", test_noop);
+  g_test_add_func ("/gsubprocess/noop-all-to-null", test_noop_all_to_null);
+  g_test_add_func ("/gsubprocess/noop-no-wait", test_noop_no_wait);
+  g_test_add_func ("/gsubprocess/noop-stdin-inherit", test_noop_stdin_inherit);
+#ifdef G_OS_UNIX
+  g_test_add_func ("/gsubprocess/search-path", test_search_path);
+#endif
+  g_test_add_func ("/gsubprocess/exit1", test_exit1);
+  g_test_add_func ("/gsubprocess/echo1", test_echo1);
+#ifdef G_OS_UNIX
+  g_test_add_func ("/gsubprocess/echo-merged", test_echo_merged);
+#endif
+  g_test_add_func ("/gsubprocess/cat-utf8", test_cat_utf8);
+  g_test_add_func ("/gsubprocess/cat-eof", test_cat_eof);
+  g_test_add_func ("/gsubprocess/multi1", test_multi_1);
+  g_test_add_func ("/gsubprocess/terminate", test_terminate);
+#ifdef G_OS_UNIX
+  g_test_add_func ("/gsubprocess/stdout-file", test_stdout_file);
+  g_test_add_func ("/gsubprocess/stdout-fd", test_stdout_fd);
+  g_test_add_func ("/gsubprocess/child-setup", test_child_setup);
+#endif
+
+  return g_test_run ();
+}