1    	/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2    	
3    	/* GIO - GLib Input, Output and Streaming Library
4    	 *
5    	 * Copyright �� 2012 Red Hat, Inc.
6    	 * Copyright �� 2012 Canonical Limited
7    	 *
8    	 * This program is free software: you can redistribute it and/or modify
9    	 * it under the terms of the GNU Lesser General Public License as published
10   	 * by the Free Software Foundation; either version 2 of the licence or (at
11   	 * your option) any later version.
12   	 *
13   	 * See the included COPYING file for more information.
14   	 *
15   	 * Authors: Colin Walters <walters@verbum.org>
16   	 *          Ryan Lortie <desrt@desrt.ca>
17   	 */
18   	
19   	#include "config.h"
20   	
21   	#define _GSYSTEM_NO_LOCAL_ALLOC
22   	#include "libgsystem.h"
23   	
24   	#if GLIB_CHECK_VERSION(2,34,0)
25   	
26   	/**
27   	 * SECTION:gssubprocess
28   	 * @title: GSSubprocess
29   	 * @short_description: Create child processes and monitor their status
30   	 *
31   	 * This class wraps the lower-level g_spawn_async_with_pipes() API,
32   	 * providing a more modern GIO-style API, such as returning
33   	 * #GInputStream objects for child output pipes.
34   	 *
35   	 * One major advantage that GIO brings over the core GLib library is
36   	 * comprehensive API for asynchronous I/O, such
37   	 * g_output_stream_splice_async().  This makes GSubprocess
38   	 * significantly more powerful and flexible than equivalent APIs in
39   	 * some other languages such as the <literal>subprocess.py</literal>
40   	 * included with Python.  For example, using #GSubprocess one could
41   	 * create two child processes, reading standard output from the first,
42   	 * processing it, and writing to the input stream of the second, all
43   	 * without blocking the main loop.
44   	 *
45   	 * Since: 2.36
46   	 */
47   	
48   	#include "config.h"
49   	
50   	#include "gsystem-subprocess.h"
51   	#include "gsystem-subprocess-context-private.h"
52   	
53   	#include <string.h>
54   	#ifdef G_OS_UNIX
55   	#include <gio/gunixoutputstream.h>
56   	#include <gio/gfiledescriptorbased.h>
57   	#include <gio/gunixinputstream.h>
58   	#include <glib-unix.h>
59   	#endif
60   	#include <fcntl.h>
61   	#ifdef G_OS_WIN32
62   	#define _WIN32_WINNT 0x0500
63   	#include <windows.h>
64   	#include "giowin32-priv.h"
65   	#endif
66   	
67   	#ifndef O_BINARY
68   	#define O_BINARY 0
69   	#endif
70   	
71   	static void initable_iface_init (GInitableIface         *initable_iface);
72   	
73   	typedef GObjectClass GSSubprocessClass;
74   	
75   	#ifdef G_OS_UNIX
76   	static void
77   	gs_subprocess_unix_queue_waitpid (GSSubprocess  *self);
78   	#endif
79   	
80   	struct _GSSubprocess
81   	{
82   	  GObject parent;
83   	
84   	  GSSubprocessContext *context;
85   	  GPid pid;
86   	
87   	  guint pid_valid : 1;
88   	  guint reaped_child : 1;
89   	  guint unused : 30;
90   	
91   	  /* These are the streams created if a pipe is requested via flags. */
92   	  GOutputStream *stdin_pipe;
93   	  GInputStream  *stdout_pipe;
94   	  GInputStream  *stderr_pipe;
95   	};
96   	
97   	G_DEFINE_TYPE_WITH_CODE (GSSubprocess, gs_subprocess, G_TYPE_OBJECT,
98   	                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init));
99   	
100  	enum
101  	{
102  	  PROP_0,
103  	  PROP_CONTEXT,
104  	  N_PROPS
105  	};
106  	
107  	static GParamSpec *gs_subprocess_pspecs[N_PROPS];
108  	
109  	static void
110  	gs_subprocess_init (GSSubprocess  *self)
111  	{
112  	}
113  	
114  	static void
115  	gs_subprocess_finalize (GObject *object)
116  	{
117  	  GSSubprocess *self = GS_SUBPROCESS (object);
118  	
119  	  if (self->pid_valid)
120  	    {
121  	#ifdef G_OS_UNIX
122  	      /* Here we need to actually call waitpid() to clean up the
123  	       * zombie.  In case the child hasn't actually exited, defer this
124  	       * cleanup to the worker thread.
125  	       */
126  	      if (!self->reaped_child)
127  	        gs_subprocess_unix_queue_waitpid (self);
128  	#endif
129  	      g_spawn_close_pid (self->pid);
130  	    }
131  	
132  	  g_clear_object (&self->stdin_pipe);
133  	  g_clear_object (&self->stdout_pipe);
134  	  g_clear_object (&self->stderr_pipe);
135  	
136  	  if (G_OBJECT_CLASS (gs_subprocess_parent_class)->finalize != NULL)
137  	    G_OBJECT_CLASS (gs_subprocess_parent_class)->finalize (object);
138  	}
139  	
140  	static void
141  	gs_subprocess_set_property (GObject      *object,
142  	                           guint         prop_id,
143  	                           const GValue *value,
144  	                           GParamSpec   *pspec)
145  	{
146  	  GSSubprocess *self = GS_SUBPROCESS (object);
147  	
148  	  switch (prop_id)
149  	    {
150  	    case PROP_CONTEXT:
151  	      self->context = g_value_dup_object (value);
152  	      break;
153  	
154  	    default:
155  	      g_assert_not_reached ();
156  	    }
157  	}
158  	
159  	static void
160  	gs_subprocess_get_property (GObject    *object,
161  	                           guint       prop_id,
162  	                           GValue     *value,
163  	                           GParamSpec *pspec)
164  	{
165  	  GSSubprocess *self = GS_SUBPROCESS (object);
166  	
167  	  switch (prop_id)
168  	    {
169  	    case PROP_CONTEXT:
170  	      g_value_set_object (value, self->context);
171  	      break;
172  	
173  	    default:
174  	      g_assert_not_reached ();
175  	    }
176  	}
177  	
178  	static void
179  	gs_subprocess_class_init (GSSubprocessClass *class)
180  	{
181  	  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
182  	
183  	  gobject_class->finalize = gs_subprocess_finalize;
184  	  gobject_class->get_property = gs_subprocess_get_property;
185  	  gobject_class->set_property = gs_subprocess_set_property;
186  	
187  	  /**
188  	   * GSSubprocess:context:
189  	   *
190  	   *
191  	   * Since: 2.36
192  	   */
193  	  gs_subprocess_pspecs[PROP_CONTEXT] = g_param_spec_object ("context", "Context", "Subprocess options", GS_TYPE_SUBPROCESS_CONTEXT,
194  								   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
195  								   G_PARAM_STATIC_STRINGS);
196  	
197  	  g_object_class_install_properties (gobject_class, N_PROPS, gs_subprocess_pspecs);
198  	}
199  	
200  	#ifdef G_OS_UNIX
201  	
202  	static gboolean
203  	gs_subprocess_unix_waitpid_dummy (gpointer data)
204  	{
205  	  return FALSE;
206  	}
207  	
208  	static void
209  	gs_subprocess_unix_queue_waitpid (GSSubprocess  *self)
210  	{
211  	  GMainContext *worker_context;
212  	  GSource *waitpid_source;
213  	
214  	#ifdef GLIB_COMPILATION
215  	  worker_context = GLIB_PRIVATE_CALL (g_get_worker_context) ();
216  	#else
217  	  worker_context = g_main_context_get_thread_default ();
218  	#endif
219  	  waitpid_source = g_child_watch_source_new (self->pid); 
220  	  g_source_set_callback (waitpid_source, gs_subprocess_unix_waitpid_dummy, NULL, NULL);
221  	  g_source_attach (waitpid_source, worker_context);
222  	  g_source_unref (waitpid_source);
223  	}
224  	
225  	#endif
226  	
227  	static GInputStream *
228  	platform_input_stream_from_spawn_fd (gint fd)
229  	{
230  	  if (fd < 0)
231  	    return NULL;
232  	
233  	#ifdef G_OS_UNIX
234  	  return g_unix_input_stream_new (fd, TRUE);
235  	#else
236  	  return g_win32_input_stream_new_from_fd (fd, TRUE);
237  	#endif
238  	}
239  	
240  	static GOutputStream *
241  	platform_output_stream_from_spawn_fd (gint fd)
242  	{
243  	  if (fd < 0)
244  	    return NULL;
245  	
246  	#ifdef G_OS_UNIX
247  	  return g_unix_output_stream_new (fd, TRUE);
248  	#else
249  	  return g_win32_output_stream_new_from_fd (fd, TRUE);
250  	#endif
251  	}
252  	
253  	#ifdef G_OS_UNIX
254  	static gint
255  	unix_open_file (const char  *filename,
256  	                gint         mode,
257  	                GError     **error)
258  	{
259  	  gint my_fd;
260  	
261  	  do
262  	    my_fd = open (filename, mode | O_BINARY | O_CLOEXEC, 0666);
263  	  while (my_fd == -1 && errno == EINTR);
264  	
265  	  /* If we return -1 we should also set the error */
266  	  if (my_fd < 0)
267  	    {
268  	      gint saved_errno = errno;
269  	      char *display_name;
270  	
271  	      display_name = g_filename_display_name (filename);
272  	      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (saved_errno),
273  	                   "Error opening file '%s': %s", display_name,
274  	                   g_strerror (saved_errno));
275  	      g_free (display_name);
276  	      /* fall through... */
277  	    }
278  	
279  	  return my_fd;
280  	}
281  	#endif
282  	
283  	typedef struct
284  	{
285  	  gint                   fds[3];
286  	  GArray                *inherit_fds;
287  	  GSpawnChildSetupFunc   child_setup_func;
288  	  gpointer               child_setup_data;
289  	} ChildData;
290  	
291  	static void
292  	child_setup (gpointer user_data)
293  	{
294  	  ChildData *child_data = user_data;
295  	  gint i;
296  	  gint result;
297  	
298  	  /* We're on the child side now.  "Rename" the file descriptors in
299  	   * child_data.fds[] to stdin/stdout/stderr.
300  	   *
301  	   * We don't close the originals.  It's possible that the originals
302  	   * should not be closed and if they should be closed then they should
303  	   * have been created O_CLOEXEC.
304  	   */
305  	  for (i = 0; i < 3; i++)
306  	    {
307  	      if (child_data->fds[i] != -1 && child_data->fds[i] != i)
308  	        {
309  	          do
310  	            result = dup2 (child_data->fds[i], i);
311  	          while (G_UNLIKELY (result == -1 && errno == EINTR));
312  	        }
313  	    }
314  	
315  	  /* Unset the CLOEXEC flag for the child *should* inherit */
316  	  for (i = 0; i < child_data->inherit_fds->len; i++)
317  	    {
318  	      int fd = g_array_index (child_data->inherit_fds, int, i);
319  	      int flags;
320  	
321  	      do
322  	        flags = fcntl (fd, F_GETFL);
323  	      while (G_UNLIKELY (flags == -1 && errno == EINTR));
324  	
325  	      flags &= ~FD_CLOEXEC;
326  	      
327  	      do
328  	        result = fcntl (fd, F_SETFD, flags);
329  	      while (G_UNLIKELY (result == -1 && errno == EINTR));
330  	    }
331  	
332  	  if (child_data->child_setup_func)
333  	    child_data->child_setup_func (child_data->child_setup_data);
334  	}
335  	
336  	static gboolean
337  	initable_init (GInitable     *initable,
338  	               GCancellable  *cancellable,
339  	               GError       **error)
340  	{
341  	  GSSubprocess *self = GS_SUBPROCESS (initable);
342  	  ChildData child_data = { { -1, -1, -1 } };
343  	  gint *pipe_ptrs[3] = { NULL, NULL, NULL };
344  	  gint pipe_fds[3] = { -1, -1, -1 };
345  	  gint close_fds[3] = { -1, -1, -1 };
346  	  GSpawnFlags spawn_flags = 0;
347  	  gboolean success = FALSE;
348  	  gint i;
349  	
350  	  if (g_cancellable_set_error_if_cancelled (cancellable, error))
351  	    return FALSE;
352  	
353  	  /* We must setup the three fds that will end up in the child as stdin,
354  	   * stdout and stderr.
355  	   *
356  	   * First, stdin.
357  	   */
358  	#ifdef G_OS_UNIX
359  	  if (self->context->stdin_fd != -1)
360  	    child_data.fds[0] = self->context->stdin_fd;
361  	  else if (self->context->stdin_path != NULL)
362  	    {
363  	      child_data.fds[0] = close_fds[0] = unix_open_file (self->context->stdin_path, 
364  								 O_RDONLY, error);
365  	      if (child_data.fds[0] == -1)
366  		goto out;
367  	    }
368  	  else
369  	#endif
370  	  if (self->context->stdin_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_NULL)
371  	    ; /* nothing */
372  	  else if (self->context->stdin_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_INHERIT)
373  	    spawn_flags |= G_SPAWN_CHILD_INHERITS_STDIN;
374  	  else if (self->context->stdin_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_PIPE)
375  	    pipe_ptrs[0] = &pipe_fds[0];
376  	  else
377  	    g_assert_not_reached ();
378  	
379  	  /* Next, stdout. */
380  	#ifdef G_OS_UNIX
381  	  if (self->context->stdout_fd != -1)
382  	    child_data.fds[1] = self->context->stdout_fd;
383  	  else if (self->context->stdout_path != NULL)
384  	    {
385  	      child_data.fds[1] = close_fds[1] = unix_open_file (self->context->stdout_path, 
386  								 O_CREAT | O_WRONLY, error);
387  	      if (child_data.fds[1] == -1)
388  		goto out;
389  	    }
390  	  else
391  	#endif
392  	  if (self->context->stdout_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_NULL)
393  	    spawn_flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
394  	  else if (self->context->stdout_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_INHERIT)
395  	    ; /* Nothing */
396  	  else if (self->context->stdout_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_PIPE)
397  	    pipe_ptrs[1] = &pipe_fds[1];
398  	  else
399  	    g_assert_not_reached ();
400  	
401  	  /* Finally, stderr. */
402  	#ifdef G_OS_UNIX
403  	  if (self->context->stderr_fd != -1)
404  	    child_data.fds[2] = self->context->stderr_fd;
405  	  else if (self->context->stderr_path != NULL)
406  	    {
407  	      child_data.fds[2] = close_fds[2] = unix_open_file (self->context->stderr_path, 
408  								 O_CREAT | O_WRONLY, error);
409  	      if (child_data.fds[2] == -1)
410  		goto out;
411  	    }
412  	  else
413  	#endif
414  	  if (self->context->stderr_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_NULL)
415  	    spawn_flags |= G_SPAWN_STDERR_TO_DEV_NULL;
416  	  else if (self->context->stderr_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_INHERIT)
417  	    ; /* Nothing */
418  	  else if (self->context->stderr_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_PIPE)
419  	    pipe_ptrs[2] = &pipe_fds[2];
420  	  else if (self->context->stderr_disposition == GS_SUBPROCESS_STREAM_DISPOSITION_STDERR_MERGE)
421  	    /* This will work because stderr gets setup after stdout. */
422  	    child_data.fds[2] = 1;
423  	  else
424  	    g_assert_not_reached ();
425  	
426  	  child_data.inherit_fds = self->context->inherit_fds;
427  	
428  	  if (self->context->keep_descriptors)
429  	    spawn_flags |= G_SPAWN_LEAVE_DESCRIPTORS_OPEN;
430  	
431  	  if (self->context->search_path)
432  	    spawn_flags |= G_SPAWN_SEARCH_PATH;
433  	  else if (self->context->search_path_from_envp)
434  	    spawn_flags |= G_SPAWN_SEARCH_PATH_FROM_ENVP;
435  	  else if (!g_path_is_absolute (((gchar**)self->context->argv)[0]))
436  	    spawn_flags |= G_SPAWN_SEARCH_PATH;
437  	
438  	  if (self->context->has_argv0)
439  	    spawn_flags |= G_SPAWN_FILE_AND_ARGV_ZERO;
440  	
441  	  spawn_flags |= G_SPAWN_DO_NOT_REAP_CHILD;
442  	#ifdef GLIB_COMPILATION
443  	  spawn_flags |= G_SPAWN_CLOEXEC_PIPES;
444  	#endif
445  	
446  	  child_data.child_setup_func = self->context->child_setup_func;
447  	  child_data.child_setup_data = self->context->child_setup_data;
448  	  success = g_spawn_async_with_pipes (self->context->cwd,
449  					      (char**)self->context->argv,
450  					      self->context->envp,
451  	                                      spawn_flags,
452  	                                      child_setup, &child_data,
453  	                                      &self->pid,
454  	                                      pipe_ptrs[0], pipe_ptrs[1], pipe_ptrs[2],
455  	                                      error);
456  	  if (success)
457  	    self->pid_valid = TRUE;
458  	
459  	out:
460  	  for (i = 0; i < 3; i++)
461  	    if (close_fds[i] != -1)
462  	      close (close_fds[i]);
463  	
464  	  for (i = 0; i < self->context->postfork_close_fds->len; i++)
465  	    (void) close (g_array_index (self->context->postfork_close_fds, int, i));
466  	
467  	  self->stdin_pipe = platform_output_stream_from_spawn_fd (pipe_fds[0]);
468  	  self->stdout_pipe = platform_input_stream_from_spawn_fd (pipe_fds[1]);
469  	  self->stderr_pipe = platform_input_stream_from_spawn_fd (pipe_fds[2]);
470  	
471  	  return success;
472  	}
473  	
474  	static void
475  	initable_iface_init (GInitableIface *initable_iface)
476  	{
477  	  initable_iface->init = initable_init;
478  	}
479  	
480  	/**
481  	 * gs_subprocess_new:
482  	 *
483  	 * Create a new process, using the parameters specified by
484  	 * GSSubprocessContext.
485  	 *
486  	 * Returns: (transfer full): A newly created %GSSubprocess, or %NULL on error (and @error will be set)
487  	 *
488  	 * Since: 2.36
489  	 */
490  	GSSubprocess *
491  	gs_subprocess_new (GSSubprocessContext   *context,
492  	                   GCancellable          *cancellable,
493  	                   GError               **error)
494  	{
495  	  return g_initable_new (GS_TYPE_SUBPROCESS,
496  	                         cancellable, error,
497  	                         "context", context,
498  	                         NULL);
499  	}
500  	
501  	/**
502  	 * gs_subprocess_get_pid:
503  	 * @self: a #GSSubprocess
504  	 *
505  	 * The identifier for this child process; it is valid as long as the
506  	 * process @self is referenced.  In particular, do
507  	 * <emphasis>not</emphasis> call g_spawn_close_pid() on this value;
508  	 * that is handled internally.
509  	 *
510  	 * On some Unix versions, it is possible for there to be a race
511  	 * condition where waitpid() may have been called to collect the child
512  	 * before any watches (such as that installed by
513  	 * gs_subprocess_add_watch()) have fired.  If you are planning to use
514  	 * native functions such as kill() on the pid, your program should
515  	 * gracefully handle an %ESRCH result to mitigate this.
516  	 *
517  	 * If you want to request process termination, using the high level
518  	 * gs_subprocess_request_exit() and gs_subprocess_force_exit() API is
519  	 * recommended.
520  	 *
521  	 * Returns: Operating-system specific identifier for child process
522  	 *
523  	 * Since: 2.36
524  	 */
525  	GPid
526  	gs_subprocess_get_pid (GSSubprocess     *self)
527  	{
528  	  g_return_val_if_fail (GS_IS_SUBPROCESS (self), 0);
529  	
530  	  return self->pid;
531  	}
532  	
533  	/**
534  	 * gs_subprocess_get_stdin_pipe:
535  	 *
536  	 * Returns: (transfer none): Pipe
537  	 */
538  	GOutputStream *
539  	gs_subprocess_get_stdin_pipe (GSSubprocess       *self)
540  	{
541  	  g_return_val_if_fail (GS_IS_SUBPROCESS (self), NULL);
542  	  g_return_val_if_fail (self->stdin_pipe, NULL);
543  	
544  	  return self->stdin_pipe;
545  	}
546  	
547  	/**
548  	 * gs_subprocess_get_stdout_pipe:
549  	 *
550  	 * Returns: (transfer none): Pipe
551  	 */
552  	GInputStream *
553  	gs_subprocess_get_stdout_pipe (GSSubprocess      *self)
554  	{
555  	  g_return_val_if_fail (GS_IS_SUBPROCESS (self), NULL);
556  	  g_return_val_if_fail (self->stdout_pipe, NULL);
557  	
558  	  return self->stdout_pipe;
559  	}
560  	
561  	/**
562  	 * gs_subprocess_get_stderr_pipe:
563  	 *
564  	 * Returns: (transfer none): Pipe
565  	 */
566  	GInputStream *
567  	gs_subprocess_get_stderr_pipe (GSSubprocess      *self)
568  	{
569  	  g_return_val_if_fail (GS_IS_SUBPROCESS (self), NULL);
570  	  g_return_val_if_fail (self->stderr_pipe, NULL);
571  	
572  	  return self->stderr_pipe;
573  	}
574  	
575  	typedef struct {
576  	  GSSubprocess *self;
577  	  GCancellable *cancellable;
578  	  GSimpleAsyncResult *result;
579  	} GSSubprocessWatchData;
580  	
581  	static gboolean
582  	gs_subprocess_on_child_exited (GPid       pid,
583  				      gint       status_code,
584  				      gpointer   user_data)
585  	{
586  	  GSSubprocessWatchData *data = user_data;
587  	  GError *error = NULL;
588  	  
589  	  if (g_cancellable_set_error_if_cancelled (data->cancellable, &error))
590  	    {
591  	      g_simple_async_result_take_error (data->result, error);
592  	    }
593  	  else
594  	    {
595  	      data->self->reaped_child = TRUE;
596  	
597  	      g_simple_async_result_set_op_res_gssize (data->result, status_code);
598  	    }
599  	
600  	  g_simple_async_result_complete (data->result);
601  	
602  	  g_object_unref (data->result);
603  	  g_object_unref (data->self);
604  	  g_free (data);
605  	
606  	  return FALSE;
607  	}
608  	
609  	/**
610  	 * gs_subprocess_wait:
611  	 * @self: a #GSSubprocess
612  	 * @cancellable: a #GCancellable
613  	 * @callback: Invoked when process exits, or @cancellable is cancelled
614  	 * @user_data: Data for @callback
615  	 *
616  	 * Start an asynchronous wait for the subprocess @self to exit.
617  	 *
618  	 * Since: 2.36
619  	 */
620  	void
621  	gs_subprocess_wait (GSSubprocess                *self,
622  			   GCancellable               *cancellable,
623  			   GAsyncReadyCallback         callback,
624  			   gpointer                    user_data)
625  	{
626  	  GSource *source;
627  	  GSSubprocessWatchData *data;
628  	
629  	  data = g_new0 (GSSubprocessWatchData, 1);
630  	
631  	  data->self = g_object_ref (self);
632  	  data->result = g_simple_async_result_new ((GObject*)self, callback, user_data,
633  						    gs_subprocess_wait);
634  	
635  	  source = g_child_watch_source_new (self->pid);
636  	
637  	  g_source_set_callback (source, (GSourceFunc)gs_subprocess_on_child_exited,
638  				 data, NULL);
639  	  if (cancellable)
640  	    {
641  	      GSource *cancellable_source;
642  	
643  	      data->cancellable = g_object_ref (cancellable);
644  	
645  	      cancellable_source = g_cancellable_source_new (cancellable);
646  	      g_source_add_child_source (source, cancellable_source);
647  	      g_source_unref (cancellable_source);
648  	    }
649  	
650  	  g_source_attach (source, g_main_context_get_thread_default ());
651  	  g_source_unref (source);
652  	}
653  	
654  	/**
655  	 * gs_subprocess_wait_finish:
656  	 * @self: a #GSSubprocess
657  	 * @result: a #GAsyncResult
658  	 * @out_exit_status: (out): Exit status of the process encoded in platform-specific way
659  	 * @error: a #GError
660  	 *
661  	 * The exit status of the process will be stored in @out_exit_status.
662  	 * See the documentation of g_spawn_check_exit_status() for more
663  	 * details.
664  	 *
665  	 * Note that @error is not set if the process exits abnormally; you
666  	 * must use g_spawn_check_exit_status() for that.
667  	 *
668  	 * Since: 2.36
669  	 */
670  	gboolean
671  	gs_subprocess_wait_finish (GSSubprocess                *self,
672  				  GAsyncResult               *result,
673  				  int                        *out_exit_status,
674  				  GError                    **error)
675  	{
676  	  GSimpleAsyncResult *simple;
677  	
678  	  simple = G_SIMPLE_ASYNC_RESULT (result);
679  	
680  	  if (g_simple_async_result_propagate_error (simple, error))
681  	    return FALSE;
682  	
683  	  *out_exit_status = g_simple_async_result_get_op_res_gssize (simple);
684  	  
685  	  return TRUE;
686  	}
687  	
688  	typedef struct {
689  	  GMainLoop *loop;
690  	  gint *exit_status_ptr;
691  	  gboolean caught_error;
692  	  GError **error;
693  	} GSSubprocessSyncWaitData;
694  	
695  	static void
696  	gs_subprocess_on_sync_wait_complete (GObject       *object,
697  					    GAsyncResult  *result,
698  					    gpointer       user_data)
699  	{
700  	  GSSubprocessSyncWaitData *data = user_data;
701  	
702  	  if (!gs_subprocess_wait_finish ((GSSubprocess*)object, result, 
703  					 data->exit_status_ptr, data->error))
704  	    data->caught_error = TRUE;
705  	
706  	  g_main_loop_quit (data->loop);
707  	}
708  	
709  	/**
710  	 * gs_subprocess_wait_sync:
711  	 * @self: a #GSSubprocess
712  	 * @out_exit_status: (out): Platform-specific exit code
713  	 * @cancellable: a #GCancellable
714  	 * @error: a #GError
715  	 *
716  	 * Synchronously wait for the subprocess to terminate, returning the
717  	 * status code in @out_exit_status.  See the documentation of
718  	 * g_spawn_check_exit_status() for how to interpret it.  Note that if
719  	 * @error is set, then @out_exit_status will be left uninitialized.
720  	 * 
721  	 * Returns: %TRUE on success, %FALSE if @cancellable was cancelled
722  	 *
723  	 * Since: 2.36
724  	 */
725  	gboolean
726  	gs_subprocess_wait_sync (GSSubprocess        *self,
727  				int                *out_exit_status,
728  				GCancellable       *cancellable,
729  				GError            **error)
730  	{
731  	  gboolean ret = FALSE;
732  	  gboolean pushed_thread_default = FALSE;
733  	  GMainContext *context = NULL;
734  	  GSSubprocessSyncWaitData data;
735  	
736  	  memset (&data, 0, sizeof (data));
737  	
738  	  g_return_val_if_fail (GS_IS_SUBPROCESS (self), FALSE);
739  	
740  	  if (g_cancellable_set_error_if_cancelled (cancellable, error))
741  	    return FALSE;
742  	
743  	  context = g_main_context_new ();
744  	  g_main_context_push_thread_default (context);
745  	  pushed_thread_default = TRUE;
746  	
747  	  data.exit_status_ptr = out_exit_status;
748  	  data.loop = g_main_loop_new (context, TRUE);
749  	  data.error = error;
750  	
751  	  gs_subprocess_wait (self, cancellable,
752  			     gs_subprocess_on_sync_wait_complete, &data);
753  	
754  	  g_main_loop_run (data.loop);
755  	
756  	  if (data.caught_error)
757  	    goto out;
758  	
759  	  ret = TRUE;
760  	 out:
761  	  if (pushed_thread_default)
762  	    g_main_context_pop_thread_default (context);
763  	  if (context)
764  	    g_main_context_unref (context);
765  	  if (data.loop)
766  	    g_main_loop_unref (data.loop);
767  	
768  	  return ret;
769  	}
770  	
771  	/**
772  	 * gs_subprocess_wait_sync_check:
773  	 * @self: a #GSSubprocess
774  	 * @cancellable: a #GCancellable
775  	 * @error: a #GError
776  	 *
777  	 * Combines gs_subprocess_wait_sync() with g_spawn_check_exit_status().
778  	 * 
779  	 * Returns: %TRUE on success, %FALSE if process exited abnormally, or @cancellable was cancelled
780  	 *
781  	 * Since: 2.36
782  	 */
783  	gboolean
784  	gs_subprocess_wait_sync_check (GSSubprocess        *self,
785  				      GCancellable       *cancellable,
786  				      GError            **error)
787  	{
788  	  gboolean ret = FALSE;
789  	  int exit_status;
790  	
791  	  if (!gs_subprocess_wait_sync (self, &exit_status, cancellable, error))
792  	    goto out;
793  	
794  	  if (!g_spawn_check_exit_status (exit_status, error))
795  	    goto out;
796  	
797  	  ret = TRUE;
798  	 out:
799  	  return ret;
800  	}
801  	
802  	/**
803  	 * gs_subprocess_request_exit:
804  	 * @self: a #GSSubprocess
805  	 *
806  	 * This API uses an operating-system specific mechanism to request
807  	 * that the subprocess gracefully exit.  This API is not available on
808  	 * all operating systems; for those not supported, it will do nothing
809  	 * and return %FALSE.  Portable code should handle this situation
810  	 * gracefully.  For example, if you are communicating via input or
811  	 * output pipe with the child, many programs will automatically exit
812  	 * when one of their standard input or output are closed.
813  	 *
814  	 * On Unix, this API sends %SIGTERM.
815  	 *
816  	 * A %TRUE return value does <emphasis>not</emphasis> mean the
817  	 * subprocess has exited, merely that an exit request was initiated.
818  	 * You can use gs_subprocess_add_watch() to monitor the status of the
819  	 * process after calling this function.
820  	 *
821  	 * This function returns %TRUE if the process has already exited.
822  	 *
823  	 * Returns: %TRUE if the operation is supported, %FALSE otherwise.
824  	 *
825  	 * Since: 2.36
826  	 */
827  	gboolean
828  	gs_subprocess_request_exit (GSSubprocess *self)
829  	{
830  	  g_return_val_if_fail (GS_IS_SUBPROCESS (self), FALSE);
831  	
832  	#ifdef G_OS_UNIX
833  	  (void) kill (self->pid, SIGTERM);
834  	  return TRUE;
835  	#else
836  	  return FALSE;
837  	#endif
838  	}
839  	
840  	/**
841  	 * gs_subprocess_force_exit:
842  	 * @self: a #GSSubprocess
843  	 *
844  	 * Use an operating-system specific method to attempt an immediate,
845  	 * forceful termination of the process.  There is no mechanism to
846  	 * determine whether or not the request itself was successful;
847  	 * however, you can use gs_subprocess_wait() to monitor the status of
848  	 * the process after calling this function.
849  	 *
850  	 * On Unix, this function sends %SIGKILL.
851  	 */
852  	void
853  	gs_subprocess_force_exit (GSSubprocess *self)
854  	{
855  	  g_return_if_fail (GS_IS_SUBPROCESS (self));
856  	
857  	#if !defined(GLIB_COMPIATION)
858  	  {
859  	    int ret;
860  	    do
861  	      ret = kill (self->pid, SIGKILL);
862  	    while (ret == -1 && errno == EINTR);
863  	  }
864  	#elif defined(G_OS_UNIX)
865  	  GLIB_PRIVATE_CALL (g_main_send_signal) (self->pid, SIGKILL);
866  	#else
867  	  TerminateProcess (self->pid, 1);
868  	#endif
869  	}
870  	
871  	GSSubprocess *
872  	gs_subprocess_new_simple_argl (GSSubprocessStreamDisposition stdout_disposition,
873  				      GSSubprocessStreamDisposition  stderr_disposition,
874  	                               GCancellable                 *cancellable,
875  				      GError                       **error,
876  				      const gchar                   *first_arg,
877  				      ...)
878  	{
879  	  va_list args;
880  	  GSSubprocess *result;
881  	  GSSubprocessContext *context;
882  	
883  	  va_start (args, first_arg);
884  	  context = gs_subprocess_context_newa (first_arg, args);
885  	  va_end (args);
886  	  result = gs_subprocess_new (context, cancellable, error);
887  	  g_object_unref (context);
888  	  
889  	  return result;
890  	}
891  	
892  	/**
893  	 * gs_subprocess_new_simple_argv:
894  	 * @argv: (array zero-terminated=1) (element-type utf8): Argument array
895  	 * @stdout_disposition: Where to redirect stdout
896  	 * @stderr_disposition: Where to redirect stdout
897  	 * @error: a #GError
898  	 *
899  	 * Create a new subprocess using the provided argument array and
900  	 * stream dispositions.
901  	 */
902  	GSSubprocess *
903  	gs_subprocess_new_simple_argv (gchar                       **argv,
904  				      GSSubprocessStreamDisposition  stdout_disposition,
905  				      GSSubprocessStreamDisposition  stderr_disposition,
906  	                               GCancellable                 *cancellable,
907  				      GError                      **error)
908  	{
909  	  GSSubprocessContext *context;
910  	  GSSubprocess *result;
911  	
912  	  context = gs_subprocess_context_new (argv);
913  	  gs_subprocess_context_set_stdout_disposition (context, stdout_disposition);
914  	  gs_subprocess_context_set_stderr_disposition (context, stderr_disposition);
915  	
916  	  result = gs_subprocess_new (context, cancellable, error);
917  	  g_object_unref (context);
918  	
919  	  return result;
920  	}
921  	
922  	/**
923  	 * gs_subprocess_simple_run_sync:
924  	 * @cwd: Current working directory
925  	 * @stdin_disposition: What to do with standard input
926  	 * @cancellable: a #GCancellable
927  	 * @error: a #GError
928  	 * @first_arg: First argument
929  	 * @...: Remaining arguments, %NULL terminated
930  	 *
931  	 * Run a process synchronously, throw an error if it fails.
932  	 */
933  	gboolean
934  	gs_subprocess_simple_run_sync (const char                    *cwd,
935  	                               GSSubprocessStreamDisposition  stdin_disposition,
936  	                               GCancellable                  *cancellable,
937  	                               GError                       **error,
938  	                               const char                    *first_arg,
939  	                               ...)
940  	{
941  	  gboolean ret = FALSE;
942  	  va_list args;
943  	  GSSubprocess *proc = NULL;
944  	  GSSubprocessContext *context = NULL;
945  	
946  	  va_start (args, first_arg);
947  	  context = gs_subprocess_context_newa (first_arg, args);
948  	  va_end (args);
(1) Event deref_ptr_in_call: Dereferencing pointer "context". [details]
Also see events: [check_after_deref]
949  	  gs_subprocess_context_set_stdin_disposition (context, stdin_disposition);
950  	  gs_subprocess_context_set_cwd (context, cwd);
951  	  proc = gs_subprocess_new (context, cancellable, error);
952  	  if (!proc)
953  	    goto out;
954  	
955  	  if (!gs_subprocess_wait_sync_check (proc, cancellable, error))
956  	    goto out;
957  	
958  	  ret = TRUE;
959  	 out:
(2) Event check_after_deref: Null-checking "context" suggests that it may be null, but it has already been dereferenced on all paths leading to the check.
Also see events: [deref_ptr_in_call]
960  	  if (context)
961  	    g_object_unref (context);
962  	  if (proc)
963  	    g_object_unref (proc);
964  	  return ret;
965  	}
966  	
967  	#endif
968