[glib/wip/gsubprocess: 3/3] GSubprocess: New class for spawning child processes
- From: Colin Walters <walters src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [glib/wip/gsubprocess: 3/3] GSubprocess: New class for spawning child processes
- Date: Fri, 18 May 2012 15:04:16 +0000 (UTC)
commit 42220218fb4089723387bb7a3b0735eb6d05ee6d
Author: Colin Walters <walters verbum org>
Date: Thu May 17 14:37:17 2012 -0400
GSubprocess: New class for spawning child processes
There are a number of nice things this class brings:
0) g_subprocess_append_args() is REALLY nice to use from C, as
opposed to building up an argument array all at once.
1) Operates in terms of G{Input,Output}Stream, not file descriptors
2) Sets a GError for you if the child exits with nonzero code; Unix
consumers don't have to copy the bits to do the WIFEXITED/WEXITCODE
dance.
3) Creates the child watch source on the thread-default main context,
matching modern GIO API.
4) The g_subprocess_set_standard_output_file_path() is a very handy
API that can work on both Unix and Windows (but is quite efficient
on Unix).
5) Has high-level helper functions; for example "synchronously run this
process and give me the entire output as a string that's been validated
as UTF-8"
One major conceptual issue with the code right now is that I'm using
GUnix{Input,Output}Stream, but this won't work on Windows =( What
we really need I guess is a GFd{Input,Output}Stream that implements
GPollable{Input,Output}Stream.
https://bugzilla.gnome.org/show_bug.cgi?id=672102
gio/Makefile.am | 2 +
gio/gio.h | 1 +
gio/gio.symbols | 43 +
gio/gioenums.h | 4 +-
gio/giotypes.h | 10 +
gio/gsubprocess.c | 2101 ++++++++++++++++++++++++++++++++++++++
gio/gsubprocess.h | 253 +++++
gio/tests/Makefile.am | 8 +
gio/tests/gsubprocess-testprog.c | 105 ++
gio/tests/gsubprocess.c | 343 +++++++
10 files changed, 2869 insertions(+), 1 deletions(-)
---
diff --git a/gio/Makefile.am b/gio/Makefile.am
index dae04b4..9fffebd 100644
--- a/gio/Makefile.am
+++ b/gio/Makefile.am
@@ -424,6 +424,7 @@ libgio_2_0_la_SOURCES = \
gsocketlistener.c \
gsocketoutputstream.c \
gsocketoutputstream.h \
+ gsubprocess.c \
gproxy.c \
gproxyaddress.c \
gproxyaddressenumerator.c \
@@ -598,6 +599,7 @@ gio_headers = \
gsocketlistener.h \
gsocketservice.h \
gsrvtarget.h \
+ gsubprocess.h \
gtcpconnection.h \
gtcpwrapperconnection.h \
gthreadedsocketservice.h\
diff --git a/gio/gio.h b/gio/gio.h
index 3fb914d..93ed5e4 100644
--- a/gio/gio.h
+++ b/gio/gio.h
@@ -122,6 +122,7 @@
#include <gio/gsocketlistener.h>
#include <gio/gsocketservice.h>
#include <gio/gsrvtarget.h>
+#include <gio/gsubprocess.h>
#include <gio/gtcpconnection.h>
#include <gio/gtcpwrapperconnection.h>
#include <gio/gtestdbus.h>
diff --git a/gio/gio.symbols b/gio/gio.symbols
index 34c954f..e41ba9c 100644
--- a/gio/gio.symbols
+++ b/gio/gio.symbols
@@ -1076,6 +1076,49 @@ g_threaded_socket_service_new
g_tcp_connection_get_type
g_tcp_connection_set_graceful_disconnect
g_tcp_connection_get_graceful_disconnect
+g_subprocess_add_watch
+g_subprocess_add_watch_full
+g_subprocess_append_arg
+g_subprocess_append_args
+g_subprocess_append_args_va
+g_subprocess_get_exit_code
+g_subprocess_get_pid
+g_subprocess_get_type
+g_subprocess_new
+g_subprocess_new_with_args
+g_subprocess_override_environ
+g_subprocess_query_success
+g_subprocess_run_sync
+g_subprocess_run_sync_get_output_bytes
+g_subprocess_run_sync_get_stdout_utf8
+g_subprocess_set_argv
+g_subprocess_set_argv0
+g_subprocess_set_child_setup
+g_subprocess_set_detached
+g_subprocess_setenv
+g_subprocess_set_io_priority
+g_subprocess_set_leave_descriptors_open
+g_subprocess_set_search_path
+g_subprocess_set_standard_error_file_path
+g_subprocess_set_standard_error_to_devnull
+g_subprocess_set_standard_error_to_stdout
+g_subprocess_set_standard_error_unix_fd
+g_subprocess_set_standard_input_bytes
+g_subprocess_set_standard_input_file_path
+g_subprocess_set_standard_input_str
+g_subprocess_set_standard_input_stream
+g_subprocess_set_standard_input_to_devnull
+g_subprocess_set_standard_input_unix_fd
+g_subprocess_set_standard_output_file_path
+g_subprocess_set_standard_output_to_devnull
+g_subprocess_set_standard_output_unix_fd
+g_subprocess_set_working_directory
+g_subprocess_start
+g_subprocess_start_and_splice_async
+g_subprocess_start_and_splice_finish
+g_subprocess_start_with_pipes
+g_subprocess_unsetenv
+g_subprocess_wait_sync
#ifndef G_OS_WIN32
g_unix_connection_get_type
g_unix_connection_receive_fd
diff --git a/gio/gioenums.h b/gio/gioenums.h
index 4ae0609..9f79b45 100644
--- a/gio/gioenums.h
+++ b/gio/gioenums.h
@@ -444,6 +444,7 @@ typedef enum {
* @G_IO_ERROR_PROXY_NEED_AUTH: Proxy server needs authentication. Since 2.26
* @G_IO_ERROR_PROXY_NOT_ALLOWED: Proxy connection is not allowed by ruleset.
* Since 2.26
+ * @G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL: The subprocess terminated abnormally. Since: 2.34
*
* Error codes returned by GIO functions.
*
@@ -492,7 +493,8 @@ typedef enum {
G_IO_ERROR_PROXY_FAILED,
G_IO_ERROR_PROXY_AUTH_FAILED,
G_IO_ERROR_PROXY_NEED_AUTH,
- G_IO_ERROR_PROXY_NOT_ALLOWED
+ G_IO_ERROR_PROXY_NOT_ALLOWED,
+ G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL
} GIOErrorEnum;
diff --git a/gio/giotypes.h b/gio/giotypes.h
index 876d856..e4f38ec 100644
--- a/gio/giotypes.h
+++ b/gio/giotypes.h
@@ -135,6 +135,16 @@ typedef struct _GIOStream GIOStream;
typedef struct _GPollableInputStream GPollableInputStream; /* Dummy typedef */
typedef struct _GPollableOutputStream GPollableOutputStream; /* Dummy typedef */
typedef struct _GResolver GResolver;
+
+/**
+ * GSubprocess:
+ *
+ * A child process.
+ *
+ * Since: 2.34
+ */
+typedef struct _GSubprocess GSubprocess;
+
/**
* GResource:
*
diff --git a/gio/gsubprocess.c b/gio/gsubprocess.c
new file mode 100644
index 0000000..8017c0f
--- /dev/null
+++ b/gio/gsubprocess.c
@@ -0,0 +1,2101 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright  2012 Red Hat, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * SECTION:gsubprocess
+ * @title: GSubprocess
+ * @short_description: Create child processes
+ *
+ * This class is primarily convenience API on top of the lower-level
+ * g_spawn_async_with_pipes() and related functions provided by GLib.
+ *
+ * Since: 2.34
+ */
+
+#include "config.h"
+#include "gsubprocess.h"
+#include "gasyncresult.h"
+#include "giostream.h"
+#include "gmemoryinputstream.h"
+#include "glibintl.h"
+
+#include <string.h>
+#ifdef G_OS_UNIX
+#include <gio/gunixoutputstream.h>
+#include <gio/gunixinputstream.h>
+#include <gstdio.h>
+#include <glib-unix.h>
+#include <fcntl.h>
+#endif
+
+typedef struct _GSubprocessClass GSubprocessClass;
+
+struct _GSubprocessClass {
+ GObjectClass parent_class;
+};
+
+typedef enum {
+ G_SUBPROCESS_STATE_BUILDING,
+ G_SUBPROCESS_STATE_RUNNING,
+ G_SUBPROCESS_STATE_TERMINATED
+} GSubprocessState;
+
+struct _GSubprocess
+{
+ GObject parent;
+ GSubprocessState state;
+
+ gchar *child_argv0;
+ GPtrArray *child_argv;
+ gchar **child_envp;
+
+ gboolean detached : 1;
+ gboolean search_path : 1;
+ gboolean leave_descriptors_open : 1;
+ gboolean stdin_to_devnull : 1;
+ gboolean stdout_to_devnull : 1;
+ gboolean stderr_to_devnull : 1;
+ gboolean stderr_to_stdout : 1;
+
+ gint io_priority;
+
+ gchar *working_directory;
+
+ GSpawnChildSetupFunc child_setup;
+ gpointer child_setup_user_data;
+
+ gint stdin_fd;
+ gchar *stdin_path;
+ GInputStream *stdin_stream;
+
+ gchar *stdout_path;
+ gint stdout_fd;
+ gchar *stderr_path;
+ gint stderr_fd;
+
+ GError *internal_error;
+
+ /* Used when we're writing input to the child via a pipe. */
+ GOutputStream *child_input_pipe_stream;
+
+ GPid pid;
+
+ int exit_status;
+};
+
+G_DEFINE_TYPE (GSubprocess, g_subprocess, G_TYPE_OBJECT);
+
+enum
+{
+ PROP_0
+};
+
+static void
+g_subprocess_init (GSubprocess *self)
+{
+ self->state = G_SUBPROCESS_STATE_BUILDING;
+ self->child_argv = g_ptr_array_new_with_free_func (g_free);
+ self->stdin_to_devnull = TRUE;
+ self->stdin_fd = -1;
+ self->stdout_fd = -1;
+ self->stderr_fd = -1;
+ self->io_priority = G_PRIORITY_DEFAULT;
+}
+
+static void
+g_subprocess_dispose (GObject *object)
+{
+ GSubprocess *self = G_SUBPROCESS (object);
+
+ g_clear_object (&self->stdin_stream);
+ g_clear_object (&self->child_input_pipe_stream);
+ g_clear_error (&self->internal_error);
+
+ if (G_OBJECT_CLASS (g_subprocess_parent_class)->dispose != NULL)
+ G_OBJECT_CLASS (g_subprocess_parent_class)->dispose (object);
+}
+
+static void
+g_subprocess_finalize (GObject *object)
+{
+ GSubprocess *self = G_SUBPROCESS (object);
+
+ if (self->state == G_SUBPROCESS_STATE_RUNNING
+ && !self->detached)
+ {
+ g_warning ("GSubprocess being finalized without child having been reaped; see g_subprocess_set_detatched()");
+ }
+
+ if (self->child_argv)
+ g_ptr_array_unref (self->child_argv);
+
+ g_strfreev (self->child_envp);
+
+ g_free (self->working_directory);
+
+ if (G_OBJECT_CLASS (g_subprocess_parent_class)->finalize != NULL)
+ G_OBJECT_CLASS (g_subprocess_parent_class)->finalize (object);
+}
+
+static void
+g_subprocess_class_init (GSubprocessClass *class)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+ gobject_class->dispose = g_subprocess_dispose;
+ gobject_class->finalize = g_subprocess_finalize;
+}
+
+/**** Creation ****/
+
+/**
+ * g_subprocess_new:
+ *
+ * After calling this function, you must use one of the functions to
+ * initialize the argument vector, such as g_subprocess_set_argv().
+ *
+ * Returns: A new #GSubprocess
+ * Since: 2.34
+ */
+GSubprocess *
+g_subprocess_new (void)
+{
+ return g_object_new (G_TYPE_SUBPROCESS, NULL);
+}
+
+/**
+ * g_subprocess_new_with_args:
+ * @first: (array zero-terminated=1) (element-type guint8): First argument
+ *
+ * See the documentation of g_subprocess_append_args_va() for details
+ * about child process arguments.
+ *
+ * After calling this function, you may append further arguments with
+ * e.g. g_subprocess_append_args().
+ *
+ * Returns: A new #GSubprocess with the provided arguments
+ * Since: 2.34
+ */
+GSubprocess *
+g_subprocess_new_with_args (const gchar *first,
+ ...)
+{
+ va_list args;
+ GSubprocess *ret;
+
+ ret = g_subprocess_new ();
+
+ va_start (args, first);
+ g_subprocess_append_arg (ret, first);
+ g_subprocess_append_args_va (ret, args);
+ va_end (args);
+
+ return ret;
+}
+
+/**** Argument control ****/
+
+/**
+ * g_subprocess_set_argv:
+ * @self: a #GSubprocess:
+ * @argv: (array zero-terminated=1): Argument array, %NULL-terminated
+ *
+ * Set the arguments to be used by the child process. This will
+ * overwrite any previous calls to g_subprocess_append_args().
+ *
+ * Due to limitations of gobject-introspection, the provided argument
+ * is annotated as an array of strings, not an array of bytestrings.
+ *
+ * For language bindings, you can use calls to
+ * g_subprocess_append_arg() indivdually to provide non-UTF8
+ * arguments.
+ *
+ * For more information, see g_subprocess_append_args_va().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_argv (GSubprocess *self,
+ gchar **argv)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (argv != NULL);
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_ptr_array_set_size (self->child_argv, 0);
+
+ for (; *argv; argv++)
+ g_ptr_array_add (self->child_argv, g_strdup (*argv));
+}
+
+/**
+ * g_subprocess_set_argv0:
+ * @self: a #GSubprocess:
+ * @argv: (array zero-terminated=1) (element-type guint8): First argument
+ *
+ * On Unix, child processes receive a bytestring provided by the
+ * parent process as the first argument (i.e. argv[0]). By default,
+ * GLib will set this to whatever executable is run, but you may override
+ * it with this function.
+ *
+ * For example, some implementations of Unix have just one 'grep'
+ * executable which behaves differently when executed as 'grep' or
+ * 'fgrep'.
+ *
+ * See the discussion of %G_SPAWN_FILE_AND_ARGV_ZERO in the
+ * g_spawn_async_with_pipes() documentation.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_argv0 (GSubprocess *self,
+ const gchar *argv0)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->child_argv0);
+ self->child_argv0 = g_strdup (argv0);
+}
+
+/**
+ * g_subprocess_append_arg:
+ * @self: a #GSubprocess:
+ * @arg: (array zero-terminated=1) (element-type guint8): Argument
+ *
+ * Append an argument to the child process. On Unix, this argument is
+ * a bytestring. For more information, see
+ * g_subprocess_append_args_va().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_append_arg (GSubprocess *self,
+ const gchar *arg)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_ptr_array_add (self->child_argv, g_strdup (arg));
+}
+
+
+/**
+ * g_subprocess_append_args:
+ * @self: a #GSubprocess:
+ * @first: (array zero-terminated=1) (element-type guint8): First argument to be appended
+ *
+ * Appends arguments to the child process. For more information, see
+ * g_subprocess_append_args_va().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_append_args (GSubprocess *self,
+ const gchar *first,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (first != NULL);
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_subprocess_append_arg (self, first);
+
+ va_start (args, first);
+ g_subprocess_append_args_va (self, args);
+ va_end (args);
+}
+
+/**
+ * g_subprocess_append_args_va:
+ * @self: a #GSubprocess
+ * @args: List of %NULL-terminated arguments
+ *
+ * Append the provided @args to the child argument vector.
+ *
+ * On Unix, the arguments are bytestrings. Note though that while
+ * it's possible to pass arbitrary bytestrings to subprocesses on
+ * Unix, not all utility programs are written to handle this
+ * correctly. You should typically only pass strings which are valid
+ * in the current locale encoding; see g_locale_to_utf8().
+ *
+ * On Windows, the arguments are in the GLib filename encoding
+ * (i.e. UTF-8).
+ *
+ * For more information, about how arguments are processed, see the
+ * documentation of g_spawn_async_with_pipes().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_append_args_va (GSubprocess *self,
+ va_list args)
+{
+ const char *arg;
+
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ while ((arg = va_arg (args, const char *)) != NULL)
+ {
+ g_ptr_array_add (self->child_argv, g_strdup (arg));
+ }
+}
+
+/**** GSpawnFlags wrappers ****/
+
+/**
+ * g_subprocess_set_detatched:
+ * @self: a #GSubprocess
+ * @detached: %TRUE if the child shouldn't be watched
+ *
+ * Unlike the g_spawn_async_with_pipes(), the default for #GSubprocess
+ * is to assume that child exit status should be available; this
+ * corresponds to the %G_SPAWN_DO_NOT_REAP_CHILD flag.
+ *
+ * If you don't plan to monitor the child status via a function like
+ * g_subprocess_add_watch() or g_subprocess_wait_sync(), you should
+ * set this flag.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_detached (GSubprocess *self,
+ gboolean detached)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ self->detached = detached;
+}
+
+/**
+ * g_subprocess_set_search_path:
+ * @self: a #GSubprocess
+ * @do_search_path: %TRUE if the system path should be searched
+ *
+ * See the documentation for %G_SPAWN_SEARCH_PATH for details; setting
+ * @do_search_path to %FALSE is equivalent to not providing that flag.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_search_path (GSubprocess *self,
+ gboolean do_search_path)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ self->search_path = do_search_path;
+}
+
+/**
+ * g_subprocess_set_leave_descriptors_open:
+ * @self: a #GSubprocess
+ * @do_leave_descriptors_open: %TRUE if file descriptors should be left open
+ *
+ * See the documentation for %G_SPAWN_LEAVE_DESCRIPTORS_OPEN for
+ * details.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_leave_descriptors_open (GSubprocess *self,
+ gboolean do_leave_descriptors_open)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ self->leave_descriptors_open = do_leave_descriptors_open;
+}
+
+/**** Envronment control ****/
+
+/**
+ * g_subprocess_setenv:
+ * @self: a #GSubprocess
+ * @variable: the environment variable to set, must not contain '='
+ * @value: the value for to set the variable to
+ * @overwrite: whether to change the variable if it already exists
+ *
+ * This modifies the environment child process will be run in; it has
+ * no effect on the current process. See the documentation of
+ * g_environ_setenv() for more information about environment
+ * variables.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_setenv (GSubprocess *self,
+ gchar *variable,
+ gchar *value,
+ gboolean overwrite)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+ g_return_if_fail (variable != NULL);
+
+ if (self->child_envp == NULL)
+ self->child_envp = g_get_environ ();
+
+ self->child_envp = g_environ_setenv (self->child_envp, variable, value,
+ overwrite);
+}
+
+/**
+ * g_subprocess_unsetenv:
+ * @self: a #GSubprocess
+ * @variable: the environment variable to set, must not contain '='
+ *
+ * This modifies the environment child process will be run in; it has
+ * no effect on the current process. See the documentation of
+ * g_environ_unsetenv() for more information about environment
+ * variables.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ */
+void
+g_subprocess_unsetenv (GSubprocess *self,
+ const gchar *variable)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+ g_return_if_fail (variable != NULL);
+
+ self->child_envp = g_environ_unsetenv (self->child_envp, variable);
+}
+
+/**
+ * g_subprocess_override_environ:
+ * @self: a #GSubprocess
+ * @envp: (array zero-terminated=1): An environment list
+ *
+ * This completely replaces the environment child process will be run
+ * in; it has no effect on the current process. See the documentation
+ * of g_environ_setenv() for more information about environment
+ * variables.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_override_environ (GSubprocess *self,
+ gchar **envp)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+ g_return_if_fail (envp != NULL);
+
+ g_strfreev (self->child_envp);
+ self->child_envp = g_strdupv (envp);
+}
+
+/**
+ * g_subprocess_set_working_directory:
+ * @self: a #GSubprocess
+ * @working_directory: (allow-none): Path to working directory, in the GLib file name encoding
+ *
+ * By default, the child process will inherit the working
+ * directory of the current process. This function allows
+ * overriding that default.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ */
+void
+g_subprocess_set_working_directory (GSubprocess *self,
+ const gchar *working_directory)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->working_directory);
+ self->working_directory = g_strdup (working_directory);
+}
+
+/**
+ * g_subprocess_set_child_setup:
+ * @self: a #GSubprocess
+ * @child_setup: (allow-none): Function to run in the context of just-forked child
+ *
+ * This functionality is only available on Unix. See the
+ * documentation of g_spawn_async_with_pipes() for more information
+ * about @child_setup.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_child_setup (GSubprocess *self,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+#ifdef G_OS_UNIX
+ self->child_setup = child_setup;
+ self->child_setup_user_data = user_data;
+#else
+ g_warning ("g_subprocess_set_child_setup is only available on Unix");
+#endif
+}
+
+/**** Input and Output ****/
+
+/**
+ * g_subprocess_set_io_priority:
+ * @self: a #GSubprocess
+ * @priority: I/O priority
+ *
+ * For the cases where #GSubprocess internally uses asynchronous I/O,
+ * this function allows controlling the priority. The default is
+ * %G_PRIORITY_DEFAULT.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_io_priority (GSubprocess *self,
+ gint io_priority)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ self->io_priority = io_priority;
+}
+
+/**
+ * g_subprocess_set_standard_input_file_path:
+ * @self: a #GSubprocess
+ * @file_path: String containing path to file to use as standard input
+ *
+ * This function allows providing a file as input to the given
+ * subprocess. The file will not be opened until g_subprocess_start()
+ * has been called.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_input_unix_fd(),
+ * g_subprocess_set_standard_input_stream(), and
+ * g_subprocess_set_standard_input_to_devnull().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_input_file_path (GSubprocess *self,
+ const gchar *file_path)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+ g_return_if_fail (file_path != NULL);
+
+ g_clear_object (&self->stdin_stream);
+ g_free (self->stdin_path);
+ self->stdin_path = NULL;
+ self->stdin_to_devnull = FALSE;
+ self->stdin_fd = -1;
+
+ self->stdin_path = g_strdup (file_path);
+}
+
+/**
+ * g_subprocess_set_standard_input_unix_fd:
+ * @self: a #GSubprocess
+ * @fd: File descriptor to use as standard input
+ *
+ * This function allows providing a file descriptor as input to the given
+ * subprocess.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_input_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_input_unix_fd (GSubprocess *self,
+ gint fd)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_clear_object (&self->stdin_stream);
+ g_free (self->stdin_path);
+ self->stdin_path = NULL;
+ self->stdin_to_devnull = FALSE;
+ self->stdin_fd = -1;
+
+ self->stdin_fd = fd;
+}
+
+/**
+ * g_subprocess_set_standard_input_to_devnull:
+ * @self: a #GSubprocess
+ * @to_devnull: If %TRUE, redirect input from null stream, if %FALSE, inherit
+ *
+ * The default is for child processes to have their input stream
+ * pointed at a null stream (e.g. on Unix, /dev/null), because having
+ * multiple processes read from an input stream creates race
+ * conditions and is generally nonsensical. See the documentation of
+ * g_spawn_async_with_pipes() and %G_SPAWN_CHILD_INHERITS_STDIN.
+ *
+ * If @to_devnull is %FALSE, then this function will cause the
+ * standard input of the child process to be inherited.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_input_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_input_to_devnull (GSubprocess *self,
+ gboolean to_devnull)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_clear_object (&self->stdin_stream);
+ g_free (self->stdin_path);
+ self->stdin_path = NULL;
+ self->stdin_to_devnull = FALSE;
+ self->stdin_fd = -1;
+
+ self->stdin_to_devnull = to_devnull;
+}
+
+/**
+ * g_subprocess_set_standard_input_stream:
+ * @self: a #GSubprocess
+ * @stream: an input stream
+ *
+ * Use the provided stream as input to the child process. The stream
+ * will not be closed upon completion by default; however, you may
+ * safely drop other references to @stream, and then it will be
+ * automatically closed when @self itself is unreferenced.
+ *
+ * <note>
+ * If your input stream is from a file, such as that returned
+ * by g_file_read(), it is significantly more efficient
+ * to cause the child process to read the file directly
+ * via g_subprocess_set_standard_input_file_path().
+ * </note>
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_input_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_input_stream (GSubprocess *self,
+ GInputStream *stream)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+ g_return_if_fail (stream != NULL);
+
+ g_clear_object (&self->stdin_stream);
+ g_free (self->stdin_path);
+ self->stdin_path = NULL;
+ self->stdin_to_devnull = FALSE;
+ self->stdin_fd = -1;
+
+ self->stdin_stream = g_object_ref (stream);
+}
+
+/**
+ * g_subprocess_set_standard_input_bytes:
+ * @self: a #GSubprocess
+ * @buf: Buffer to use as input
+ *
+ * Use the provided data as input to the child process. This
+ * function simply wraps g_subprocess_set_standard_input_stream()
+ * using g_memory_input_stream_new_from_bytes().
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_input_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_input_bytes (GSubprocess *self,
+ GBytes *buf)
+{
+ GInputStream *stream;
+
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+ g_return_if_fail (buf != NULL);
+
+ stream = g_memory_input_stream_new_from_bytes (buf);
+ g_subprocess_set_standard_input_stream (self, stream);
+ g_object_unref (stream);
+}
+
+/**
+ * g_subprocess_set_standard_input_str:
+ * @self: a #GSubprocess
+ * @str: (array zero-terminated=1) (element-type guint8): Buffer to use as input
+ *
+ * Use the provided data as input to the child process. This function
+ * simply wraps g_subprocess_set_standard_input_bytes().
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_input_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_input_str (GSubprocess *self,
+ const gchar *str)
+{
+ GBytes *bytes;
+
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+ g_return_if_fail (str != NULL);
+
+ bytes = g_bytes_new (str, strlen (str));
+ g_subprocess_set_standard_input_bytes (self, bytes);
+ g_bytes_unref (bytes);
+}
+
+/**
+ * g_subprocess_set_standard_output_to_devnull:
+ * @self: a #GSubprocess
+ * @to_devnull: If %TRUE, redirect process output to null stream
+ *
+ * The default is for the child process to inherit the standard output
+ * of the current process. Specify %TRUE for @to_devnull to redirect it
+ * to the operating system's null stream.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_output_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_output_to_devnull (GSubprocess *self,
+ gboolean to_devnull)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->stdout_path);
+ self->stdout_path = NULL;
+ self->stdout_to_devnull = FALSE;
+ self->stdout_fd = -1;
+
+ self->stdout_to_devnull = to_devnull;
+}
+
+/**
+ * g_subprocess_set_standard_output_file_path:
+ * @self: a #GSubprocess
+ * @file_path: String containing path to file to use as standard input
+ *
+ * This function allows providing a file as standard output for the
+ * given subprocess. The file will not be opened until
+ * g_subprocess_start() has been called.
+ *
+ * <note>
+ * The output file will be opened with similar semantics to
+ * g_file_append_to(); on Unix, open(path, O_CREAT, 0644).
+ * </note>
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_output_to_devnull().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_output_file_path (GSubprocess *self,
+ const gchar *file_path)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->stdout_path);
+ self->stdout_path = NULL;
+ self->stdout_to_devnull = FALSE;
+ self->stdout_fd = -1;
+
+ self->stdout_path = g_strdup (file_path);
+}
+
+/**
+ * g_subprocess_set_standard_output_unix_fd:
+ * @self: a #GSubprocess
+ * @fd: File descriptor
+ *
+ * This function allows providing a file descriptor as standard output
+ * for the given subprocess.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_output_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_output_unix_fd (GSubprocess *self,
+ gint fd)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->stdout_path);
+ self->stdout_path = NULL;
+ self->stdout_to_devnull = FALSE;
+ self->stderr_to_stdout = FALSE;
+ self->stdout_fd = -1;
+
+ self->stdout_fd = fd;
+}
+
+/**
+ * g_subprocess_set_standard_error_to_devnull:
+ * @self: a #GSubprocess
+ * @to_devnull: If %TRUE, redirect process error output to null stream
+ *
+ * The default is for the child process to inherit the standard error
+ * of the current process. Specify %TRUE for @to_devnull to redirect
+ * it to the operating system's null stream.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_error_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_error_to_devnull (GSubprocess *self,
+ gboolean to_devnull)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->stderr_path);
+ self->stderr_path = NULL;
+ self->stderr_to_devnull = FALSE;
+ self->stderr_to_stdout = FALSE;
+ self->stderr_fd = -1;
+
+ self->stderr_to_devnull = to_devnull;
+}
+
+/**
+ * g_subprocess_set_standard_error_to_stdout:
+ * @self: a #GSubprocess
+ * @to_devnull: If %TRUE, redirect process error output to standard output
+ *
+ * The default is for the child process to inherit the standard error
+ * of the current process. Specify %TRUE for it to be merged with
+ * standard output.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_error_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_error_to_stdout (GSubprocess *self,
+ gboolean to_stdout)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->stderr_path);
+ self->stderr_path = NULL;
+ self->stderr_to_devnull = FALSE;
+ self->stderr_to_stdout = FALSE;
+ self->stderr_fd = -1;
+
+ self->stderr_to_stdout = to_stdout;
+
+}
+
+/**
+ * g_subprocess_set_standard_error_file_path:
+ * @self: a #GSubprocess
+ * @file_path: String containing path to file to use as standard input
+ *
+ * This function allows providing a file as standard error for the
+ * given subprocess. The file will not be opened until
+ * g_subprocess_start() has been called.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_error_to_devnull().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_error_file_path (GSubprocess *self,
+ const gchar *file_path)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->stderr_path);
+ self->stderr_path = NULL;
+ self->stderr_to_devnull = FALSE;
+ self->stderr_to_stdout = FALSE;
+ self->stderr_fd = -1;
+
+ self->stderr_path = g_strdup (file_path);
+}
+
+/**
+ * g_subprocess_set_standard_error_unix_fd:
+ * @self: a #GSubprocess
+ * @fd: File descriptor
+ *
+ * This function allows providing a file descriptor as standard error
+ * for the given subprocess.
+ *
+ * Calling this function overrides any previous calls, as well as
+ * other related functions such as
+ * g_subprocess_set_standard_error_file_path().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * been called.
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_set_standard_error_unix_fd (GSubprocess *self,
+ gint fd)
+{
+ g_return_if_fail (G_IS_SUBPROCESS (self));
+ g_return_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING);
+
+ g_free (self->stderr_path);
+ self->stderr_path = NULL;
+ self->stderr_to_devnull = FALSE;
+ self->stderr_to_stdout = FALSE;
+ self->stderr_fd = -1;
+
+ self->stderr_fd = fd;
+}
+
+/**
+ * g_subprocess_start:
+ * @self: a #GSubprocess
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * When called, this runs the child process asynchronously using
+ * the current configuration. You must have at least initialized
+ * an argument vector using g_subprocess_append_args() or a related
+ * function.
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * already been called.
+ *
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_start (GSubprocess *self,
+ GCancellable *cancellable,
+ GError **error)
+{
+ return g_subprocess_start_with_pipes (self, NULL, NULL, NULL,
+ cancellable, error);
+}
+
+/**
+ * g_subprocess_run_sync:
+ * @self: a #GSubprocess
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * When called, this runs the child process synchronously using
+ * the current configuration. You must have at least initialized
+ * an argument vector using g_subprocess_append_args() or a related
+ * function.
+ *
+ * This function simply wraps g_subprocess_start() and
+ * g_subprocess_wait_sync(). See the documentation for both of those,
+ * as well as g_subprocess_query_success().
+ *
+ * It invalid to call this function after g_subprocess_start() has
+ * already been called.
+ *
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_run_sync (GSubprocess *self,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret = FALSE;
+
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+ g_return_val_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING, FALSE);
+
+ if (!g_subprocess_start (self, cancellable, error))
+ goto out;
+ if (!g_subprocess_wait_sync (self, cancellable, error))
+ goto out;
+
+ ret = TRUE;
+ out:
+ return ret;
+}
+
+#ifdef G_OS_UNIX
+
+static inline void
+safe_dup2 (int a,
+ int b)
+{
+ int ecode;
+ do
+ {
+ ecode = dup2 (a, b);
+ } while (ecode == -1 && errno == EINTR);
+}
+
+static void
+g_subprocess_internal_child_setup (gpointer user_data)
+{
+ GSubprocess *self = user_data;
+
+ if (self->stdin_fd >= 0)
+ safe_dup2 (self->stdin_fd, 0);
+ if (self->stdout_fd >= 0)
+ safe_dup2 (self->stdout_fd, 1);
+ if (self->stderr_fd >= 0)
+ safe_dup2 (self->stderr_fd, 2);
+ if (self->stderr_to_stdout)
+ safe_dup2 (1, 2);
+
+ if (self->child_setup)
+ self->child_setup (self->child_setup_user_data);
+}
+
+#endif
+
+static void
+internal_error_occurred (GSubprocess *self,
+ GError **error)
+{
+ if (self->internal_error == NULL)
+ {
+ g_prefix_error (error, _("While writing input to child process: "));
+ g_propagate_error (&self->internal_error, *error);
+ }
+ else
+ g_clear_error (error);
+}
+
+static void
+g_subprocess_on_input_splice_finished (GObject *src,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GSubprocess *self = user_data;
+ GError *local_error = NULL;
+ GError **error = &local_error;
+ gssize bytes_written;
+
+ bytes_written = g_output_stream_splice_finish (G_OUTPUT_STREAM (src),
+ res, error);
+ if (bytes_written < 0)
+ {
+ internal_error_occurred (self, error);
+ }
+
+ g_object_unref (self);
+}
+
+
+/**
+ * g_subprocess_start_with_pipes:
+ * @self: a #GSubprocess
+ * @out_stdin_stream: (out) (allow-none): Return location for standard input pipe
+ * @out_stdout_stream: (out) (allow-none): Return location for standard output pipe
+ * @out_stderr_stream: (out) (allow-none): Return location for standard error pipe
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * When called, this runs the child process asynchronously using the
+ * current configuration, with pipes connected to the standard output
+ * or error. You must have at least initialized an argument vector
+ * using g_subprocess_append_args() or a related function.
+ *
+ * See the documentation for g_spawn_async_with_pipes() for more
+ * information about how the child process has been run.
+ *
+ * <warning>
+ * If both input and output streams are given, using synchronous
+ * I/O on both sides risks deadlock.
+ * </warning>
+ *
+ * It invalid to call this function after
+ * g_subprocess_start_with_pipes() has already been called.
+ *
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_start_with_pipes (GSubprocess *self,
+ GOutputStream **out_stdin_stream,
+ GInputStream **out_stdout_stream,
+ GInputStream **out_stderr_stream,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret = FALSE;
+ GPtrArray *tmp_argv = NULL;
+ gchar **real_argv;
+ GSpawnFlags spawn_flags = 0;
+ gint stdin_pipe_fd = -1;
+ gint *stdin_arg = NULL;
+ gint stdout_pipe_fd = -1;
+ gint *stdout_arg = NULL;
+ gint stderr_pipe_fd = -1;
+ gint *stderr_arg = NULL;
+ GSpawnChildSetupFunc child_setup;
+ gpointer child_setup_user_data;
+
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+ g_return_val_if_fail (self->state == G_SUBPROCESS_STATE_BUILDING, FALSE);
+
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ return FALSE;
+
+ if (out_stdin_stream)
+ g_return_val_if_fail (self->stdin_fd == -1
+ && self->stdin_path == NULL
+ && self->stdin_stream == NULL,
+ FALSE);
+ if (out_stdout_stream)
+ g_return_val_if_fail (self->stdout_fd == -1
+ && self->stdout_path == NULL
+ && self->stdout_to_devnull == FALSE,
+ FALSE);
+ if (out_stderr_stream)
+ g_return_val_if_fail (self->stderr_fd == -1
+ && self->stderr_path == NULL
+ && self->stderr_to_devnull == FALSE
+ && self->stderr_to_stdout == FALSE,
+ FALSE);
+
+ self->state = G_SUBPROCESS_STATE_RUNNING;
+
+#ifdef G_OS_UNIX
+ if (self->stdin_path)
+ {
+ self->stdin_fd = g_open (self->stdin_path, O_RDONLY);
+ if (self->stdin_fd < 0)
+ {
+ g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
+ _("Failed to open file '%s'"), self->stdin_path);
+ goto out;
+ }
+ g_free (self->stdin_path);
+ self->stdin_path = NULL;
+ }
+ if (self->stdout_path)
+ {
+ self->stdout_fd = g_open (self->stdout_path, O_CREAT | O_APPEND | O_WRONLY,
+ 0666);
+ if (self->stdout_fd < 0)
+ {
+ g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
+ _("Failed to open file '%s'"), self->stdout_path);
+ goto out;
+ }
+ g_free (self->stdout_path);
+ self->stdout_path = NULL;
+ }
+ if (self->stderr_path)
+ {
+ self->stderr_fd = g_open (self->stderr_path, O_CREAT | O_APPEND | O_WRONLY,
+ 0666);
+ if (self->stderr_fd < 0)
+ {
+ g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
+ _("Failed to open file '%s'"), self->stdout_path);
+ goto out;
+ }
+ g_free (self->stderr_path);
+ self->stderr_path = NULL;
+ }
+#else
+ if (self->stdin_path)
+ {
+ GFile *stdin_file;
+
+ stdin_file = g_file_new_for_path (self->stdin_path);
+ self->stdin_stream = g_file_read (stdin_file, cancellable, error);
+ g_object_unref (stdin_file);
+ if (!self->stdin_stream)
+ goto out;
+ g_free (self->stdin_path);
+ self->stdin_path = NULL;
+ }
+ if (self->stdout_path)
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+ "FIXME not supported yet");
+ goto out;
+ }
+ if (self->stderr_path)
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+ "FIXME not supported yet");
+ goto out;
+ }
+#endif
+
+ g_assert (self->stdin_path == NULL
+ && self->stdout_path == NULL
+ && self->stderr_path == NULL);
+
+ if (self->child_argv0)
+ {
+ guint i;
+
+ tmp_argv = g_ptr_array_new ();
+ g_ptr_array_add (tmp_argv, self->child_argv0);
+ for (i = 0; i < self->child_argv->len; i++)
+ g_ptr_array_add (tmp_argv, self->child_argv->pdata[i]);
+
+ real_argv = (char**)tmp_argv->pdata;
+
+ spawn_flags |= G_SPAWN_FILE_AND_ARGV_ZERO;
+ }
+ else
+ {
+ g_ptr_array_add (self->child_argv, NULL);
+ real_argv = (char**)self->child_argv->pdata;
+ }
+
+ if (self->leave_descriptors_open)
+ spawn_flags |= G_SPAWN_LEAVE_DESCRIPTORS_OPEN;
+ if (self->search_path)
+ spawn_flags |= G_SPAWN_SEARCH_PATH;
+ if (self->stdout_to_devnull)
+ spawn_flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
+ if (self->stderr_to_devnull)
+ spawn_flags |= G_SPAWN_STDERR_TO_DEV_NULL;
+ if (!self->detached)
+ spawn_flags |= G_SPAWN_DO_NOT_REAP_CHILD;
+
+#ifdef G_OS_UNIX
+ child_setup = g_subprocess_internal_child_setup;
+ child_setup_user_data = self;
+#else
+ child_setup = NULL;
+ child_setup_user_data = NULL;
+#endif
+
+ if (out_stdin_stream != NULL
+ || self->stdin_stream != NULL)
+ stdin_arg = &stdin_pipe_fd;
+ else
+ {
+ g_assert (self->stdin_fd != -1 || self->stdin_to_devnull);
+ stdin_arg = NULL;
+ }
+
+ if (out_stdout_stream != NULL)
+ stdout_arg = &stdout_pipe_fd;
+ else
+ {
+ g_assert (self->stdout_fd == -1 || self->stdout_to_devnull);
+ stdout_arg = NULL;
+ }
+
+ if (out_stderr_stream != NULL)
+ stderr_arg = &stderr_pipe_fd;
+ else
+ {
+ g_assert (self->stderr_fd == -1
+ || self->stderr_to_devnull
+ || self->stderr_to_stdout);
+ stderr_arg = NULL;
+ }
+
+ if (!g_spawn_async_with_pipes (self->working_directory,
+ real_argv,
+ self->child_envp,
+ spawn_flags,
+ child_setup, child_setup_user_data,
+ &self->pid,
+ stdin_arg, stdout_arg, stderr_arg,
+ error))
+ goto out;
+
+ ret = TRUE;
+
+ if (stdin_pipe_fd != -1)
+ {
+ GOutputStream *child_stdout = g_unix_output_stream_new (stdin_pipe_fd, TRUE);
+ if (self->stdin_stream)
+ {
+ self->child_input_pipe_stream = child_stdout;
+ g_output_stream_splice_async (self->child_input_pipe_stream,
+ self->stdin_stream,
+ G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
+ G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
+ self->io_priority,
+ cancellable,
+ g_subprocess_on_input_splice_finished,
+ g_object_ref (self));
+ }
+ else
+ {
+ g_assert (out_stdin_stream);
+ *out_stdin_stream = child_stdout;
+ }
+ }
+ if (stdout_pipe_fd != -1)
+ {
+ g_assert (out_stdout_stream);
+ *out_stdout_stream = g_unix_input_stream_new (stdout_pipe_fd, TRUE);
+ }
+ if (stderr_pipe_fd != -1)
+ {
+ g_assert (out_stderr_stream);
+ *out_stderr_stream = g_unix_input_stream_new (stderr_pipe_fd, TRUE);
+ }
+ out:
+ if (tmp_argv)
+ g_ptr_array_unref (tmp_argv);
+ return ret;
+}
+
+/**
+ * g_subprocess_get_pid:
+ * @self: a #GSubprocess
+ *
+ * Returns the identifier for this child process.
+ *
+ * <warning>
+ * Due to the way GLib implements subprocess monitoring works on
+ * Unix, attempting to use e.g. kill() to send a signal to the
+ * child process has a race condition where the child process
+ * may not exist, even if e.g. g_subprocess_wait_async()
+ * has not yet returned.
+ * <warning>
+ *
+ * This function can only be called when the process has been started
+ * via g_subprocess_start() or a related function.
+ *
+ * Since: 2.34
+ */
+GPid
+g_subprocess_get_pid (GSubprocess *self)
+{
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), 0);
+ g_return_val_if_fail (self->state == G_SUBPROCESS_STATE_RUNNING
+ || self->state == G_SUBPROCESS_STATE_TERMINATED, 0);
+
+ return self->pid;
+}
+
+/**
+ * g_subprocess_add_watch:
+ * @self: a #GSubprocess
+ * @function: Callback invoked when child has exited
+ * @user_data: Data for @function
+ *
+ * This function is similar to using g_child_watch_add(), except it
+ * operates on the thread default main context. See
+ * g_main_context_get_thread_default().
+ *
+ * For more information, see the documentation of
+ * g_subprocess_add_watch_full().
+ *
+ * Returns: (transfer full): A newly-created #GSource for this process
+ * Since: 2.34
+ */
+GSource *
+g_subprocess_add_watch (GSubprocess *self,
+ GSubprocessWatchFunc function,
+ gpointer user_data)
+{
+ return g_subprocess_add_watch_full (self, G_PRIORITY_DEFAULT, function, user_data, NULL);
+}
+
+typedef struct {
+ GSubprocess *self;
+ GSubprocessWatchFunc *callback;
+ gpointer user_data;
+ GDestroyNotify notify;
+} GSubprocessWatchTrampolineData;
+
+static void
+g_subprocess_child_watch_func (GPid pid,
+ gint exit_status,
+ gpointer user_data)
+{
+ GSubprocessWatchTrampolineData *data = user_data;
+
+ data->self->exit_status = exit_status;
+ data->self->state = G_SUBPROCESS_STATE_TERMINATED;
+
+ if (data->callback)
+ data->callback (data->self, data->user_data);
+}
+
+static void
+g_subprocess_trampoline_data_destroy (gpointer user_data)
+{
+ GSubprocessWatchTrampolineData *data = user_data;
+
+ if (data->notify)
+ data->notify (data->user_data);
+
+ g_object_unref (data->self);
+ g_free (data);
+}
+
+/**
+ * g_subprocess_add_watch_full:
+ * @self: a #GSubprocess
+ * @priority: I/O priority
+ * @function: Callback invoked when child has exited
+ * @user_data: Data for @function
+ * @notify: Destroy notify
+ *
+ * This function is similar to using g_child_watch_add_full(), except
+ * it operates on the thread default main context. See
+ * g_main_context_get_thread_default().
+ *
+ * Inside the callback, you should call either
+ * g_subprocess_query_success() or g_subprocess_get_exit_code() to
+ * determine the status of the child.
+ *
+ * Returns: (transfer full): A newly-created #GSource for this process
+ * Since: 2.34
+ */
+GSource *
+g_subprocess_add_watch_full (GSubprocess *self,
+ gint priority,
+ GSubprocessWatchFunc function,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GSource *source;
+ GSubprocessWatchTrampolineData *trampoline_data;
+
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), 0);
+ g_return_val_if_fail (self->state == G_SUBPROCESS_STATE_RUNNING, 0);
+
+ source = g_child_watch_source_new (self->pid);
+ g_source_set_priority (source, priority);
+ trampoline_data = g_new (GSubprocessWatchTrampolineData, 1);
+ trampoline_data->self = g_object_ref (self);
+ trampoline_data->callback = function;
+ trampoline_data->user_data = user_data;
+ trampoline_data->notify = notify;
+ g_source_set_callback (source, (GSourceFunc)g_subprocess_child_watch_func, trampoline_data,
+ g_subprocess_trampoline_data_destroy);
+ g_source_attach (source, g_main_context_get_thread_default ());
+
+ return source;
+}
+
+/**
+ * g_subprocess_query_success:
+ * @self: a #GSubprocess
+ * @error: a #GError
+ *
+ * Unlike the g_spawn_async_with_pipes() family of functions, this
+ * function by default sets an error if the child exits abnormally
+ * (e.g. with a nonzero exit code, or via a fatal signal).
+ *
+ * In the case where the child exits abnormally, the resulting @error
+ * will have domain %G_IO_ERROR, code %G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL.
+ *
+ * You can query the actual exit status via
+ * g_subprocess_get_exit_code().
+ *
+ * It is invalid to call this function unless the child has actually
+ * terminated. You can wait for the child to exit via
+ * g_subprocess_add_watch(), or synchronously via
+ * g_subprocess_wait_sync().
+ *
+ * Returns: %TRUE if child exited successfully, %FALSE otherwise
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_query_success (GSubprocess *self,
+ GError **error)
+{
+ gboolean ret = FALSE;
+
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+ g_return_val_if_fail (!self->detached, FALSE);
+ g_return_val_if_fail (self->state == G_SUBPROCESS_STATE_TERMINATED, FALSE);
+
+ if (self->internal_error)
+ {
+ if (error)
+ *error = g_error_copy (self->internal_error);
+ return FALSE;
+ }
+
+#ifdef G_OS_UNIX
+ if (WIFEXITED (self->exit_status))
+ {
+ if (WEXITSTATUS (self->exit_status) != 0)
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL,
+ _("Child process %ld exited with code %ld"),
+ (long) self->pid, (long) self->exit_status);
+ goto out;
+ }
+ }
+ else if (WIFSIGNALED (self->exit_status))
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL,
+ _("Child process %ld killed by signal %ld"),
+ (long) self->pid, (long) WTERMSIG (self->exit_status));
+ goto out;
+ }
+ else if (WIFSTOPPED (self->exit_status))
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL,
+ _("Child process %ld stopped by signal %ld"),
+ (long) self->pid, (long) WSTOPSIG (self->exit_status));
+ goto out;
+ }
+ else
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL,
+ _("Child process %ld exited abnormally"),
+ (long) self->pid);
+ goto out;
+ }
+#else
+ if (self->exit_status != 0)
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL,
+ _("Child process %ld exited abnormally"),
+ (long) self->pid);
+ goto out;
+ }
+#endif
+
+ ret = TRUE;
+ out:
+ return ret;
+}
+
+/**
+ * g_subprocess_get_exit_code:
+ * @self: a #GSubprocess
+ *
+ * Returns the exit code from the process, in the same form as
+ * provided by g_spawn_async_with_pipes(). In the typical case where
+ * you simply want to print an error message if the child exited
+ * abnormally, use g_subprocess_query_success().
+ *
+ * It is invalid to call this function unless the child has actually
+ * terminated. You can wait for the child to exit via
+ * g_subprocess_add_watch(), or synchronously via
+ * g_subprocess_wait_sync().
+ *
+ * Returns: Exit code of child
+ * Since: 2.34
+ */
+gint
+g_subprocess_get_exit_code (GSubprocess *self)
+{
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+ g_return_val_if_fail (!self->detached, FALSE);
+ g_return_val_if_fail (self->state == G_SUBPROCESS_STATE_TERMINATED, FALSE);
+
+ return self->exit_status;
+}
+
+static void
+g_subprocess_on_sync_watch (GSubprocess *self,
+ gpointer user_data)
+{
+ GMainLoop *loop = user_data;
+
+ g_main_loop_quit (loop);
+}
+
+/**
+ * g_subprocess_wait_sync:
+ * @self: a #GSubprocess
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Synchronously wait for the subprocess to terminate. This function
+ * will also invoke g_subprocess_query_success(), meaning that by
+ * default @error will be set if the subprocess exits abornmally.
+ *
+ * Returns: %TRUE if child exited successfully, %FALSE otherwise
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_wait_sync (GSubprocess *self,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret = FALSE;
+ gboolean pushed_thread_default = FALSE;
+ GMainContext *context = NULL;
+ GMainLoop *loop = NULL;
+ GSource *source = NULL;
+
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+ g_return_val_if_fail (!self->detached, FALSE);
+ g_return_val_if_fail (self->state == G_SUBPROCESS_STATE_RUNNING, FALSE);
+
+ context = g_main_context_new ();
+ g_main_context_push_thread_default (context);
+ pushed_thread_default = TRUE;
+ loop = g_main_loop_new (context, TRUE);
+
+ source = g_subprocess_add_watch (self, g_subprocess_on_sync_watch, loop);
+
+ g_main_loop_run (loop);
+
+ if (!g_subprocess_query_success (self, error))
+ goto out;
+
+ ret = TRUE;
+ out:
+ if (pushed_thread_default)
+ g_main_context_pop_thread_default (context);
+ if (source)
+ g_source_unref (source);
+ if (context)
+ g_main_context_unref (context);
+ if (loop)
+ g_main_loop_unref (loop);
+
+ return ret;
+}
+
+/**** High level wrapers ****/
+
+typedef struct {
+ GSubprocess *self;
+ GSimpleAsyncResult *res;
+ gboolean caught_error;
+ GError *error;
+ guint events_needed;
+} GSubprocessSpliceData;
+
+static void
+g_subprocess_on_splice_finished (GObject *obj,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GSubprocessSpliceData *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_needed--;
+ if (data->events_needed == 0)
+ {
+ if (data->caught_error)
+ g_simple_async_result_take_error (data->res, data->error);
+ else
+ g_simple_async_result_set_op_res_gboolean (data->res, TRUE);
+
+ g_simple_async_result_complete (data->res);
+
+ g_object_unref (data->res);
+
+ g_object_unref (data->self);
+ g_free (data);
+ }
+}
+
+/**
+ * g_subprocess_start_and_splice_async:
+ * @self: a #GSubprocess
+ * @flags: Flags for splicing
+ * @stdout_splice: Transfer data from stdout into this stream
+ * @stderr_splice: Transfer data from stderr into this stream
+ * @cancellable: a #GCancellable
+ * @callback: Callback invoked when all data has been transferred
+ * @user_data: User data for @callback
+ *
+ * Start the process, asynchronously transferring data from child
+ * standard output and/or standard error into the provided streams.
+ * The @callback will be invoked when the child closes the streams,
+ * not when it terminates.
+ *
+ * If you want to query the child exit status, you need to use a
+ * function like g_subprocess_add_watch() to be notified when it exits
+ * as well. Or, if you just want the output, use
+ * g_subprocess_set_detached().
+ *
+ * Since: 2.34
+ */
+void
+g_subprocess_start_and_splice_async (GSubprocess *self,
+ GOutputStreamSpliceFlags flags,
+ GOutputStream *stdout_splice,
+ GOutputStream *stderr_splice,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSubprocessSpliceData *op_data;
+ GSimpleAsyncResult *res;
+ GError *local_error = NULL;
+ GInputStream *subproc_stdout = NULL;
+ GInputStream *subproc_stderr = NULL;
+
+ if (!g_subprocess_start_with_pipes (self, NULL, stdout_splice ? &subproc_stdout : NULL,
+ stderr_splice ? &subproc_stderr : NULL,
+ cancellable, &local_error))
+ {
+ res = g_simple_async_result_new_take_error ((GObject*)self, callback, user_data,
+ local_error);
+ g_simple_async_result_complete_in_idle (res);
+ return;
+ }
+
+ op_data = g_new0 (GSubprocessSpliceData, 1);
+ op_data->self = g_object_ref (self);
+ op_data->res = g_simple_async_result_new ((GObject*)self,
+ callback, user_data,
+ g_subprocess_start_and_splice_async);
+
+ if (stdout_splice)
+ {
+ g_output_stream_splice_async (stdout_splice, subproc_stdout, flags,
+ self->io_priority, cancellable,
+ g_subprocess_on_splice_finished, op_data);
+ g_object_unref (subproc_stdout);
+ op_data->events_needed++;
+ }
+
+ if (stderr_splice)
+ {
+ g_output_stream_splice_async (stderr_splice, subproc_stderr, flags,
+ self->io_priority, cancellable,
+ g_subprocess_on_splice_finished, op_data);
+ g_object_unref (subproc_stderr);
+ op_data->events_needed++;
+ }
+}
+
+/**
+ * g_subprocess_start_and_splice_finish:
+ * @self: a #GSubprocess
+ * @result: a #GAsyncResult
+ * @error: a #GError
+ *
+ * Complete an asynchronous splice operation. There is at present no
+ * way to query the number of bytes written.
+ *
+ * Returns: %TRUE if the operation was successful, %FALSE otherwise
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_start_and_splice_finish (GSubprocess *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (G_IS_SUBPROCESS (self), FALSE);
+ g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
+
+ if (G_IS_SIMPLE_ASYNC_RESULT (result))
+ {
+ simple = (GSimpleAsyncResult*) result;
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+ }
+ return TRUE;
+}
+
+typedef struct {
+ GSubprocess *self;
+ GError **error;
+ GMainLoop *loop;
+} GSubprocessRunSyncGetOutputData;
+
+static void
+g_subprocess_on_get_output_splice_done (GObject *obj,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GSubprocessRunSyncGetOutputData *data = user_data;
+
+ g_subprocess_start_and_splice_finish (data->self, res, data->error);
+
+ g_main_loop_quit (data->loop);
+}
+
+static gboolean
+run_sync_get_output_membufs (GSubprocess *self,
+ GOutputStreamSpliceFlags flags,
+ GMemoryOutputStream **out_stdout_buf,
+ GMemoryOutputStream **out_stderr_buf,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret = FALSE;
+ GSubprocessRunSyncGetOutputData data;
+ gboolean pushed_thread_default;
+ GMainContext *context = NULL;
+ GOutputStream *stdout_membuf = NULL;
+ GOutputStream *stderr_membuf = NULL;
+
+ if (out_stdout_buf)
+ stdout_membuf = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
+ if (out_stderr_buf)
+ stderr_membuf = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
+
+ memset (&data, 0, sizeof (data));
+ data.error = error;
+ data.self = self;
+
+ context = g_main_context_new ();
+ g_main_context_push_thread_default (context);
+ pushed_thread_default = TRUE;
+ data.loop = g_main_loop_new (context, TRUE);
+
+ g_subprocess_start_and_splice_async (self, flags, stdout_membuf,
+ stderr_membuf, cancellable,
+ g_subprocess_on_get_output_splice_done,
+ &data);
+
+ g_main_loop_run (data.loop);
+
+ /* Note minor optimization opportunity: we create two main loops
+ * presently */
+ if (!g_subprocess_wait_sync (self, cancellable, error))
+ goto out;
+
+ ret = TRUE;
+ if (out_stdout_buf)
+ {
+ *out_stdout_buf = (GMemoryOutputStream*)stdout_membuf;
+ stdout_membuf = NULL;
+ }
+ if (out_stderr_buf)
+ {
+ *out_stderr_buf = (GMemoryOutputStream*)stderr_membuf;
+ stderr_membuf = NULL;
+ }
+ out:
+ g_clear_object (&stdout_membuf);
+ g_clear_object (&stderr_membuf);
+ if (pushed_thread_default)
+ g_main_context_pop_thread_default (context);
+ if (context)
+ g_main_context_unref (context);
+ if (data.loop)
+ g_main_loop_unref (data.loop);
+
+ return ret;
+}
+
+/**
+ * g_subprocess_run_sync_get_output_bytes:
+ * @self: a #GSubprocess
+ * @out_stdout_bytes: (out) (transfer full) (allow-none): Standard output from child process
+ * @out_stderr_bytes: (out) (transfer full) (allow-none): Standard error from child process
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Synchronously run the child process, gathering output from standard
+ * output and/or standard error into the returned buffers. To get them
+ * both into one stream, use g_subprocess_set_standard_error_to_stdout().
+ *
+ * If @error is set for any reason (including the child exiting
+ * unsuccessfully), then @out_stdout_bytes and @out_stderr_bytes will
+ * be left uninitialized! If you want to run the child process,
+ * gathering output regardless of exit status, you should use the
+ * lower-level function g_subprocess_start_and_splice_async().
+ *
+ * Returns: %TRUE if child process exited, successfully %FALSE otherwise
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_run_sync_get_output_bytes (GSubprocess *self,
+ GBytes **out_stdout_bytes,
+ GBytes **out_stderr_bytes,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret = FALSE;
+ GMemoryOutputStream *stdout_membuf = NULL;
+ GMemoryOutputStream *stderr_membuf = NULL;
+ const gint flags = G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET | G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE;
+
+ if (!run_sync_get_output_membufs (self, flags,
+ out_stdout_bytes ? &stdout_membuf : NULL,
+ out_stderr_bytes ? &stderr_membuf : NULL,
+ cancellable, error))
+ goto out;
+
+ if (stdout_membuf && !g_output_stream_close ((GOutputStream*) stdout_membuf,
+ cancellable, error))
+ goto out;
+ if (stderr_membuf && !g_output_stream_close ((GOutputStream*) stderr_membuf,
+ cancellable, error))
+ goto out;
+
+ ret = TRUE;
+ if (out_stdout_bytes)
+ *out_stdout_bytes = g_memory_output_stream_steal_as_bytes (stdout_membuf);
+ if (out_stderr_bytes)
+ *out_stderr_bytes = g_memory_output_stream_steal_as_bytes (stderr_membuf);
+ out:
+ g_clear_object (&stdout_membuf);
+ g_clear_object (&stderr_membuf);
+ return ret;
+}
+
+/**
+ * g_subprocess_run_sync_get_stdout_utf8:
+ * @self: A #GSubprocess
+ * @output_utf8: (out) (transfer full) (allow-none): Output string
+ * @cancellable: a #GCancellable
+ * @error: a #GError
+ *
+ * Synchronously run the child process, gathering complete output into
+ * the returned @output_utf8 string. By default, stderr will go to
+ * the current process' stderr, but you may redirect it normally via
+ * g_subprocess_set_standard_error_to_devnull().
+ *
+ * Returns: %TRUE on success, %FALSE otherwise
+ * Since: 2.34
+ */
+gboolean
+g_subprocess_run_sync_get_stdout_utf8 (GSubprocess *self,
+ gchar **output_utf8,
+ GCancellable *cancellable,
+ GError **error)
+{
+ gboolean ret = FALSE;
+ gsize bytes_written;
+ GMemoryOutputStream *buf = NULL;
+
+ if (!run_sync_get_output_membufs (self, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE,
+ &buf, NULL, cancellable, error))
+ goto out;
+
+ /* Ensure it's NUL terminated */
+ if (!g_output_stream_write_all (G_OUTPUT_STREAM (buf), "", 1, &bytes_written,
+ cancellable, error))
+ goto out;
+
+ if (!g_output_stream_close (G_OUTPUT_STREAM (buf), cancellable, error))
+ goto out;
+
+ if (!g_utf8_validate (g_memory_output_stream_get_data (buf),
+ -1, NULL))
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
+ _("Subprocess output was invalid UTF-8"));
+ goto out;
+ }
+
+ ret = TRUE;
+ if (output_utf8)
+ *output_utf8 = g_memory_output_stream_steal_data (buf);
+ out:
+ g_clear_object (&buf);
+ return ret;
+}
diff --git a/gio/gsubprocess.h b/gio/gsubprocess.h
new file mode 100644
index 0000000..b256798
--- /dev/null
+++ b/gio/gsubprocess.h
@@ -0,0 +1,253 @@
+/* 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))
+
+GType g_subprocess_get_type (void) G_GNUC_CONST;
+
+/**** Creation ****/
+
+GLIB_AVAILABLE_IN_2_34
+GSubprocess * g_subprocess_new (void);
+
+GLIB_AVAILABLE_IN_2_34
+GSubprocess * g_subprocess_new_with_args (const gchar *first,
+ ...) G_GNUC_NULL_TERMINATED;
+
+/**** Argument control ****/
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_argv (GSubprocess *self,
+ gchar **argv);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_argv0 (GSubprocess *self,
+ const gchar *argv0);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_append_arg (GSubprocess *self,
+ const gchar *arg);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_append_args (GSubprocess *self,
+ const gchar *first,
+ ...) G_GNUC_NULL_TERMINATED;
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_append_args_va (GSubprocess *self,
+ va_list args);
+
+/**** Envronment control ****/
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_detached (GSubprocess *self,
+ gboolean detached);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_search_path (GSubprocess *self,
+ gboolean do_search_path);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_leave_descriptors_open (GSubprocess *self,
+ gboolean do_leave_descriptors_open);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_setenv (GSubprocess *self,
+ gchar *variable,
+ gchar *value,
+ gboolean overwrite);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_unsetenv (GSubprocess *self,
+ const gchar *variable);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_override_environ (GSubprocess *self,
+ gchar **envp);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_working_directory (GSubprocess *self,
+ const gchar *working_directory);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_child_setup (GSubprocess *self,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data);
+
+/**** Input and Output ****/
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_io_priority (GSubprocess *self,
+ gint io_priority);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_input_file_path (GSubprocess *self,
+ const gchar *file_path);
+
+#ifdef G_OS_UNIX
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_input_unix_fd (GSubprocess *self,
+ gint fd);
+#endif
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_input_to_devnull (GSubprocess *self,
+ gboolean to_devnull);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_input_stream (GSubprocess *self,
+ GInputStream *stream);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_input_bytes (GSubprocess *self,
+ GBytes *buf);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_input_str (GSubprocess *self,
+ const gchar *str);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_output_to_devnull (GSubprocess *self,
+ gboolean to_devnull);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_output_file_path (GSubprocess *self,
+ const gchar *file_path);
+
+#ifdef G_OS_UNIX
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_output_unix_fd (GSubprocess *self,
+ gint fd);
+#endif
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_error_to_devnull (GSubprocess *self,
+ gboolean to_devnull);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_error_to_stdout (GSubprocess *self,
+ gboolean to_stdout);
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_set_standard_error_file_path (GSubprocess *self,
+ const gchar *file_path);
+
+#ifdef G_OS_UNIX
+void g_subprocess_set_standard_error_unix_fd (GSubprocess *self,
+ gint fd);
+#endif
+
+/**** Running ****/
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_start (GSubprocess *self,
+ GCancellable *cancellable,
+ GError **error);
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_start_with_pipes (GSubprocess *self,
+ GOutputStream **stdin_stream,
+ GInputStream **stdout_stream,
+ GInputStream **stderr_stream,
+ GCancellable *cancellable,
+ GError **error);
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_run_sync (GSubprocess *self,
+ GCancellable *cancellable,
+ GError **error);
+
+GLIB_AVAILABLE_IN_2_34
+GPid g_subprocess_get_pid (GSubprocess *self);
+
+typedef void (GSubprocessWatchFunc) (GSubprocess *subprocess,
+ gpointer user_data);
+
+GLIB_AVAILABLE_IN_2_34
+GSource * g_subprocess_add_watch (GSubprocess *self,
+ GSubprocessWatchFunc function,
+ gpointer user_data);
+
+GLIB_AVAILABLE_IN_2_34
+GSource * g_subprocess_add_watch_full (GSubprocess *self,
+ gint priority,
+ GSubprocessWatchFunc function,
+ gpointer user_data,
+ GDestroyNotify notify);
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_query_success (GSubprocess *self,
+ GError **error);
+
+GLIB_AVAILABLE_IN_2_34
+gint g_subprocess_get_exit_code (GSubprocess *self);
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_wait_sync (GSubprocess *self,
+ GCancellable *cancellable,
+ GError **error);
+
+/**** High level wrapers ****/
+
+GLIB_AVAILABLE_IN_2_34
+void g_subprocess_start_and_splice_async (GSubprocess *self,
+ GOutputStreamSpliceFlags flags,
+ GOutputStream *stdout_splice,
+ GOutputStream *stderr_splice,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_start_and_splice_finish (GSubprocess *self,
+ GAsyncResult *result,
+ GError **error);
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_run_sync_get_output_bytes (GSubprocess *self,
+ GBytes **stdout_bytes,
+ GBytes **stderr_bytes,
+ GCancellable *cancellable,
+ GError **error);
+
+GLIB_AVAILABLE_IN_2_34
+gboolean g_subprocess_run_sync_get_stdout_utf8 (GSubprocess *self,
+ gchar **output_utf8,
+ GCancellable *cancellable,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __G_SUBPROCESS_H__ */
diff --git a/gio/tests/Makefile.am b/gio/tests/Makefile.am
index c5cf59d..7a19800 100644
--- a/gio/tests/Makefile.am
+++ b/gio/tests/Makefile.am
@@ -45,6 +45,7 @@ TEST_PROGS += \
srvtarget \
contexts \
gsettings \
+ gsubprocess \
gschema-compile \
async-close-output-stream \
gdbus-addresses \
@@ -263,6 +264,13 @@ contexts_LDADD = $(progs_ldadd) \
gsettings_SOURCES = gsettings.c
gsettings_LDADD = $(progs_ldadd)
+gsubprocess_SOURCES = gsubprocess.c
+gsubprocess_LDADD = $(progs_ldadd)
+
+noinst_PROGRAMS += gsubprocess-testprog
+gsubprocess_testprog_SOURCES = gsubprocess-testprog.c
+gsubprocess_testprog_LDADD = $(progs_ldadd)
+
gschema_compile_SOURCES = gschema-compile.c
gschema_compile_LDADD = $(progs_ldadd)
diff --git a/gio/tests/gsubprocess-testprog.c b/gio/tests/gsubprocess-testprog.c
new file mode 100644
index 0000000..59494f1
--- /dev/null
+++ b/gio/tests/gsubprocess-testprog.c
@@ -0,0 +1,105 @@
+#include <gio/gio.h>
+#include <string.h>
+#ifdef G_OS_UNIX
+#include <gio/gunixinputstream.h>
+#include <gio/gunixoutputstream.h>
+#endif
+
+static GOptionEntry options[] = {
+ {NULL}
+};
+
+static int
+echo_mode (int argc,
+ char **argv)
+{
+ int i;
+
+ for (i = 2; i < argc; i++)
+ g_print ("%s\n", argv[i]);
+
+ return 0;
+}
+
+static int
+echo_stdout_and_stderr_mode (int argc,
+ char **argv)
+{
+ int i;
+
+ for (i = 2; i < argc; i++)
+ {
+ g_print ("%s\n", argv[i]);
+ g_printerr ("%s\n", argv[i]);
+ }
+
+ return 0;
+}
+
+static int
+cat_mode (int argc,
+ char **argv)
+{
+#ifdef G_OS_UNIX
+ GInputStream *stdin;
+ GOutputStream *stdout;
+ GError *local_error = NULL;
+ GError **error = &local_error;
+
+ stdin = g_unix_input_stream_new (0, FALSE);
+ stdout = g_unix_output_stream_new (1, FALSE);
+
+ if (g_output_stream_splice (stdout, stdin, 0, NULL, error) < 0)
+ {
+ g_printerr ("%s\n", local_error->message);
+ return 1;
+ }
+
+ return 0;
+#else
+ return 1;
+#endif
+}
+
+int
+main (int argc, char **argv)
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ const char *mode;
+
+ g_type_init ();
+
+ 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, "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
+ {
+ 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 0000000..830cc43
--- /dev/null
+++ b/gio/tests/gsubprocess.c
@@ -0,0 +1,343 @@
+#include <gio/gio.h>
+#include <string.h>
+
+#ifdef G_OS_UNIX
+#include <sys/wait.h>
+#endif
+
+static GSubprocess *
+get_test_subprocess (const char *mode)
+{
+ char *cwd;
+ char *cwd_path;
+ GSubprocess *ret;
+
+ cwd = g_get_current_dir ();
+ cwd_path = g_build_filename (cwd, "gsubprocess-testprog", NULL);
+ ret = g_subprocess_new_with_args (cwd_path, mode, NULL);
+ g_free (cwd);
+ g_free (cwd_path);
+
+ return ret;
+}
+
+static void
+test_noop (void)
+{
+ GError *local_error = NULL;
+ GError **error = &local_error;
+ GSubprocess *proc;
+
+ proc = get_test_subprocess ("noop");
+
+ (void)g_subprocess_run_sync (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;
+ GSubprocess *proc;
+
+ proc = get_test_subprocess ("noop");
+
+ g_subprocess_set_standard_input_to_devnull (proc, TRUE);
+ g_subprocess_set_standard_output_to_devnull (proc, TRUE);
+ g_subprocess_set_standard_error_to_devnull (proc, TRUE);
+
+ (void)g_subprocess_run_sync (proc, NULL, error);
+ g_assert_no_error (local_error);
+
+ g_object_unref (proc);
+}
+
+static void
+test_exit1 (void)
+{
+ GSubprocess *proc;
+ GError *local_error = NULL;
+ GError **error = &local_error;
+
+ proc = get_test_subprocess ("exit1");
+
+ (void)g_subprocess_run_sync (proc, NULL, error);
+ g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_SUBPROCESS_EXIT_ABNORMAL);
+ g_clear_error (error);
+
+#ifdef G_OS_UNIX
+ {
+ int ecode = g_subprocess_get_exit_code (proc);
+ g_assert (WIFEXITED (ecode) && WEXITSTATUS (ecode) == 1);
+ }
+#endif
+
+ g_object_unref (proc);
+}
+
+static void
+test_echo1 (void)
+{
+ GSubprocess *proc;
+ GError *local_error = NULL;
+ GError **error = &local_error;
+ gchar *result;
+
+ proc = get_test_subprocess ("echo");
+
+ g_subprocess_append_args (proc, "hello", "world!", NULL);
+
+ g_subprocess_run_sync_get_stdout_utf8 (proc, &result, NULL, error);
+ g_assert_no_error (local_error);
+
+ g_assert_cmpstr (result, ==, "hello\nworld!\n");
+
+ g_object_unref (proc);
+}
+
+static void
+test_echo_merged (void)
+{
+ GSubprocess *proc;
+ GError *local_error = NULL;
+ GError **error = &local_error;
+ gchar *result;
+
+ proc = get_test_subprocess ("echo-stdout-and-stderr");
+
+ g_subprocess_append_args (proc, "merge", "this", NULL);
+ g_subprocess_set_standard_error_to_stdout (proc, TRUE);
+
+ g_subprocess_run_sync_get_stdout_utf8 (proc, &result, NULL, error);
+ g_assert_no_error (local_error);
+
+ g_assert_cmpstr (result, ==, "merge\nmerge\nthis\nthis\n");
+
+ g_free (result);
+ g_object_unref (proc);
+}
+
+static void
+test_cat_utf8 (void)
+{
+ GSubprocess *proc;
+ GError *local_error = NULL;
+ GError **error = &local_error;
+ gchar *result = NULL;
+
+ proc = get_test_subprocess ("cat");
+
+ g_subprocess_set_standard_input_str (proc, "hello, world!");
+ g_subprocess_run_sync_get_stdout_utf8 (proc, &result, NULL, error);
+ g_assert_no_error (local_error);
+
+ g_assert_cmpstr (result, ==, "hello, world!");
+
+ g_free (result);
+ g_object_unref (proc);
+}
+
+static void
+test_cat_non_utf8 (void)
+{
+ GSubprocess *proc;
+ GError *local_error = NULL;
+ GError **error = &local_error;
+ gchar *result;
+
+ proc = get_test_subprocess ("cat");
+
+ g_subprocess_set_standard_input_str (proc, "\xFE\xFE\xFF\xFF");
+ g_subprocess_run_sync_get_stdout_utf8 (proc, &result, NULL, error);
+ g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA);
+ g_clear_error (&local_error);
+
+ g_object_unref (proc);
+}
+
+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 (GSubprocess *proc,
+ gpointer user_data)
+{
+ TestMultiSpliceData *data = user_data;
+
+ if (!data->caught_error)
+ {
+ if (!g_subprocess_query_success (proc, &data->error))
+ data->caught_error = TRUE;
+ }
+ 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;
+ 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;
+ GSource *proc_watch_source;
+ TestMultiSpliceData data;
+ int splice_flags = G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET;
+
+ first = get_test_subprocess ("cat");
+ second = get_test_subprocess ("cat");
+ third = get_test_subprocess ("cat");
+
+ membuf = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
+
+ g_subprocess_start_with_pipes (first, &first_stdin, &first_stdout, NULL,
+ NULL, error);
+ g_assert_no_error (local_error);
+ g_subprocess_start_with_pipes (second, &second_stdin, &second_stdout, NULL,
+ NULL, error);
+ g_assert_no_error (local_error);
+ g_subprocess_start_with_pipes (third, &third_stdin, &third_stdout, NULL,
+ NULL, error);
+ g_assert_no_error (local_error);
+
+ 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++;
+ proc_watch_source = g_subprocess_add_watch (first, on_subprocess_exited, &data);
+ g_source_unref (proc_watch_source);
+ data.events_pending++;
+ proc_watch_source = g_subprocess_add_watch (second, on_subprocess_exited, &data);
+ g_source_unref (proc_watch_source);
+ data.events_pending++;
+ proc_watch_source = g_subprocess_add_watch (third, on_subprocess_exited, &data);
+ g_source_unref (proc_watch_source);
+
+ 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 (first_stdin);
+ g_object_unref (first_stdout);
+ g_object_unref (second_stdin);
+ g_object_unref (second_stdout);
+ g_object_unref (third_stdin);
+ g_object_unref (third_stdout);
+ g_object_unref (membuf);
+ g_object_unref (first);
+ g_object_unref (second);
+ g_object_unref (third);
+}
+
+int
+main (int argc, char **argv)
+{
+ g_type_init ();
+
+ 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/exit1", test_exit1);
+ g_test_add_func ("/gsubprocess/echo1", test_echo1);
+ g_test_add_func ("/gsubprocess/echo-merged", test_echo_merged);
+ g_test_add_func ("/gsubprocess/cat-utf8", test_cat_utf8);
+ g_test_add_func ("/gsubprocess/cat-non-utf8", test_cat_non_utf8);
+ g_test_add_func ("/gsubprocess/multi1", test_multi_1);
+
+ return g_test_run ();
+}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
