/* GIO - GLib Input, Output and Streaming Library

 *

 * Copyright © 2012, 2013 Red Hat, Inc.

 * Copyright © 2012, 2013 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.1 of the License, 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

 * @include: gio/gio.h

 * @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 `subprocess.py`

 * 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

 * `communicate()` method of `subprocess.py`. 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_async() or

 * g_subprocess_wait().  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.40

 **/

#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

#include <windows.h>

#include <io.h>

#include "giowin32-priv.h"

#endif

#ifndef O_BINARY

#define O_BINARY 0

#endif

#ifndef O_CLOEXEC

#define O_CLOEXEC 0

#else

#define HAVE_O_CLOEXEC 1

#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

};

#ifdef G_OS_UNIX

typedef struct

{

  gint                 fds[3];

  GSpawnChildSetupFunc child_setup_func;

  gpointer             child_setup_data;

  GArray              *basic_fd_assignments;

  GArray              *needdup_fd_assignments;

} ChildData;

static void

unset_cloexec (int fd)

{

  int flags;

  int result;

  flags = fcntl (fd, F_GETFD, 0);

  if (flags != -1)

    {

      int errsv;

      flags &= (~FD_CLOEXEC);

      do

        {

          result = fcntl (fd, F_SETFD, flags);

          errsv = errno;

        }

      while (result == -1 && errsv == EINTR);

    }

}

static int

dupfd_cloexec (int parent_fd)

{

  int fd, errsv;

#ifdef F_DUPFD_CLOEXEC

  do

    {

      fd = fcntl (parent_fd, F_DUPFD_CLOEXEC, 3);

      errsv = errno;

    }

  while (fd == -1 && errsv == EINTR);

#else

  /* OS X Snow Lion and earlier don't have F_DUPFD_CLOEXEC:

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

   */

  int result, flags;

  do

    {

      fd = fcntl (parent_fd, F_DUPFD, 3);

      errsv = errno;

    }

  while (fd == -1 && errsv == EINTR);

  flags = fcntl (fd, F_GETFD, 0);

  if (flags != -1)

    {

      flags |= FD_CLOEXEC;

      do

        {

          result = fcntl (fd, F_SETFD, flags);

          errsv = errno;

        }

      while (result == -1 && errsv == EINTR);

    }

#endif

  return fd;

}

/*

 * Based on code derived from

 * gnome-terminal:src/terminal-screen.c:terminal_screen_child_setup(),

 * used under the LGPLv2+ with permission from author.

 */

static void

child_setup (gpointer user_data)

{

  ChildData *child_data = user_data;

  gint i;

  gint result;

  int errsv;

  /* 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)

      {

        do

          {

            result = dup2 (child_data->fds[i], i);

            errsv = errno;

          }

        while (result == -1 && errsv == EINTR);

      }

  /* Basic fd assignments we can just unset FD_CLOEXEC */

  if (child_data->basic_fd_assignments)

    {

      for (i = 0; i < child_data->basic_fd_assignments->len; i++)

        {

          gint fd = g_array_index (child_data->basic_fd_assignments, int, i);

          unset_cloexec (fd);

        }

    }

  /* If we're doing remapping fd assignments, we need to handle

   * the case where the user has specified e.g.:

   * 5 -> 4, 4 -> 6

   *

   * We do this by duping the source fds temporarily.

   */ 

  if (child_data->needdup_fd_assignments)

    {

      for (i = 0; i < child_data->needdup_fd_assignments->len; i += 2)

        {

          gint parent_fd = g_array_index (child_data->needdup_fd_assignments, int, i);

          gint new_parent_fd;

          new_parent_fd = dupfd_cloexec (parent_fd);

          g_array_index (child_data->needdup_fd_assignments, int, i) = new_parent_fd;

        }

      for (i = 0; i < child_data->needdup_fd_assignments->len; i += 2)

        {

          gint parent_fd = g_array_index (child_data->needdup_fd_assignments, int, i);

          gint child_fd = g_array_index (child_data->needdup_fd_assignments, int, i+1);

          if (parent_fd == child_fd)

            {

              unset_cloexec (parent_fd);

            }

          else

            {

              do

                {

                  result = dup2 (parent_fd, child_fd);

                  errsv = errno;

                }

              while (result == -1 && errsv == EINTR);

              (void) close (parent_fd);

            }

        }

    }

  if (child_data->child_setup_func)

    child_data->child_setup_func (child_data->child_setup_data);

}

#endif

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... */

    }

#ifndef HAVE_O_CLOEXEC

  else

    fcntl (my_fd, F_SETFD, FD_CLOEXEC);

#endif

  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);

      g_object_unref (tasks->data);

      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);

#ifdef G_OS_UNIX

  ChildData child_data = { { -1, -1, -1 }, 0 };

#endif

  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];

#ifdef G_OS_UNIX

  else if (self->flags & G_SUBPROCESS_FLAGS_STDERR_MERGE)

    /* This will work because stderr gets setup after stdout. */

    child_data.fds[2] = 1;

  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

#ifdef G_OS_UNIX

  if (self->launcher)

    {

      child_data.basic_fd_assignments = self->launcher->basic_fd_assignments;

      child_data.needdup_fd_assignments = self->launcher->needdup_fd_assignments;

    }

#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;

#ifdef G_OS_UNIX

  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;

#endif

  success = g_spawn_async_with_pipes (self->launcher ? self->launcher->cwd : NULL,

                                      self->argv,

                                      self->launcher ? self->launcher->envp : NULL,

                                      spawn_flags,

#ifdef G_OS_UNIX

                                      child_setup, &child_data,

#else

                                      NULL, NULL,

#endif

                                      &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 = g_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);

    }

#ifdef G_OS_UNIX

out:

#endif

  /* 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_strfreev (self->argv);

  g_mutex_clear (&self->pending_waits_lock);

  G_OBJECT_CLASS (g_subprocess_parent_class)->finalize (object);

}

static void

g_subprocess_init (GSubprocess  *self)

{

  g_mutex_init (&self->pending_waits_lock);

}

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)

 * @flags: flags that define the behaviour of the subprocess

 * @error: (nullable): return location for an error, or %NULL

 * @argv0: first commandline argument to pass to the subprocess

 * @...:   more commandline arguments, followed by %NULL

 *

 * Create a new process with the given flags and varargs argument

 * list.  By default, matching the g_spawn_async() defaults, the

 * child's stdin will be set to the system null device, and

 * stdout/stderr will be inherited from the parent.  You can use

 * @flags to control this behavior.

 *

 * The argument list must be terminated with %NULL.

 *

 * Returns: A newly created #GSubprocess, or %NULL on error (and @error

 *   will be set)

 *

 * Since: 2.40

 */

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);

  va_end (ap);

  result = g_subprocess_newv ((const gchar * const *) args->pdata, flags, error);

  g_ptr_array_free (args, TRUE);

  return result;

}

/**

 * g_subprocess_newv: (rename-to g_subprocess_new)

 * @argv: (array zero-terminated=1) (element-type filename): commandline arguments for the subprocess

 * @flags: flags that define the behaviour of the subprocess

 * @error: (nullable): return location for an error, or %NULL

 *

 * 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.40

 */

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);

}

/**

 * g_subprocess_get_identifier:

 * @subprocess: a #GSubprocess

 *

 * On UNIX, returns the process ID as a decimal string.

 * On Windows, returns the result of GetProcessId() also as a string.

 */

const gchar *

g_subprocess_get_identifier (GSubprocess *subprocess)

{

  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), NULL);

  if (subprocess->pid)

    return subprocess->identifier;

  else

    return NULL;

}

/**

 * g_subprocess_get_stdin_pipe:

 * @subprocess: a #GSubprocess

 *

 * Gets the #GOutputStream that you can write to in order to give data

 * to the stdin of @subprocess.

 *

 * The process must have been created with

 * %G_SUBPROCESS_FLAGS_STDIN_PIPE.

 *

 * Returns: (transfer none): the stdout pipe

 *

 * Since: 2.40

 **/

GOutputStream *

g_subprocess_get_stdin_pipe (GSubprocess *subprocess)

{

  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), NULL);

  g_return_val_if_fail (subprocess->stdin_pipe, NULL);

  return subprocess->stdin_pipe;

}

/**

 * g_subprocess_get_stdout_pipe:

 * @subprocess: a #GSubprocess

 *

 * Gets the #GInputStream from which to read the stdout output of

 * @subprocess.

 *

 * The process must have been created with

 * %G_SUBPROCESS_FLAGS_STDOUT_PIPE.

 *

 * Returns: (transfer none): the stdout pipe

 *

 * Since: 2.40

 **/

GInputStream *

g_subprocess_get_stdout_pipe (GSubprocess *subprocess)

{

  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), NULL);

  g_return_val_if_fail (subprocess->stdout_pipe, NULL);

  return subprocess->stdout_pipe;

}

/**

 * g_subprocess_get_stderr_pipe:

 * @subprocess: a #GSubprocess

 *

 * Gets the #GInputStream from which to read the stderr output of

 * @subprocess.

 *

 * The process must have been created with

 * %G_SUBPROCESS_FLAGS_STDERR_PIPE.

 *

 * Returns: (transfer none): the stderr pipe

 *

 * Since: 2.40

 **/

GInputStream *

g_subprocess_get_stderr_pipe (GSubprocess *subprocess)

{

  g_return_val_if_fail (G_IS_SUBPROCESS (subprocess), NULL);

  g_return_val_if_fail (subprocess->stderr_pipe, NULL);

  return subprocess->stderr_pipe;

}

/* Remove the first list element containing @data, and return %TRUE. If no

 * such element is found, return %FALSE. */

static gboolean

slist_remove_if_present (GSList        **list,

                         gconstpointer   data)

{

  GSList *l, *prev;

  for (l = *list, prev = NULL; l != NULL; prev = l, l = prev->next)

    {

      if (l->data == data)

        {

          if (prev != NULL)

            prev->next = l->next;

          else

            *list = l->next;

          g_slist_free_1 (l);

          return TRUE;

        }

    }

  return FALSE;

}

static void

g_subprocess_wait_cancelled (GCancellable *cancellable,

                             gpointer      user_data)

{

  GTask *task = user_data;

  GSubprocess *self;

  gboolean task_was_pending;

  self = g_task_get_source_object (task);

  g_mutex_lock (&self->pending_waits_lock);

  task_was_pending = slist_remove_if_present (&self->pending_waits, task);

  g_mutex_unlock (&self->pending_waits_lock);

  if (task_was_pending)

    {

      g_task_return_boolean (task, FALSE);

      g_object_unref (task);  /* ref from pending_waits */

    }

}

/**