summaryrefslogtreecommitdiff
path: root/glib/glib/gspawn-win32.c
diff options
context:
space:
mode:
Diffstat (limited to 'glib/glib/gspawn-win32.c')
-rw-r--r--glib/glib/gspawn-win32.c1493
1 files changed, 1493 insertions, 0 deletions
diff --git a/glib/glib/gspawn-win32.c b/glib/glib/gspawn-win32.c
new file mode 100644
index 0000000..44ae907
--- /dev/null
+++ b/glib/glib/gspawn-win32.c
@@ -0,0 +1,1493 @@
+/* gspawn-win32.c - Process launching on Win32
+ *
+ * Copyright 2000 Red Hat, Inc.
+ * Copyright 2003 Tor Lillqvist
+ *
+ * GLib is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * GLib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GLib; see the file COPYING.LIB. If not, write
+ * to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Implementation details on Win32.
+ *
+ * - There is no way to set the no-inherit flag for
+ * a "file descriptor" in the MS C runtime. The flag is there,
+ * and the dospawn() function uses it, but unfortunately
+ * this flag can only be set when opening the file.
+ * - As there is no fork(), we cannot reliably change directory
+ * before starting the child process. (There might be several threads
+ * running, and the current directory is common for all threads.)
+ *
+ * Thus, we must in many cases use a helper program to handle closing
+ * of (inherited) file descriptors and changing of directory. The
+ * helper process is also needed if the standard input, standard
+ * output, or standard error of the process to be run are supposed to
+ * be redirected somewhere.
+ *
+ * The structure of the source code in this file is a mess, I know.
+ */
+
+/* Define this to get some logging all the time */
+/* #define G_SPAWN_WIN32_DEBUG */
+
+#include "config.h"
+
+#include "glib.h"
+#include "gprintfint.h"
+#include "glibintl.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <windows.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <io.h>
+#include <process.h>
+#include <direct.h>
+#include <wchar.h>
+
+#ifdef G_SPAWN_WIN32_DEBUG
+ static int debug = 1;
+ #define SETUP_DEBUG() /* empty */
+#else
+ static int debug = -1;
+ #define SETUP_DEBUG() \
+ G_STMT_START \
+ { \
+ if (debug == -1) \
+ { \
+ if (getenv ("G_SPAWN_WIN32_DEBUG") != NULL) \
+ debug = 1; \
+ else \
+ debug = 0; \
+ } \
+ } \
+ G_STMT_END
+#endif
+
+enum
+{
+ CHILD_NO_ERROR,
+ CHILD_CHDIR_FAILED,
+ CHILD_SPAWN_FAILED,
+};
+
+enum {
+ ARG_CHILD_ERR_REPORT = 1,
+ ARG_HELPER_SYNC,
+ ARG_STDIN,
+ ARG_STDOUT,
+ ARG_STDERR,
+ ARG_WORKING_DIRECTORY,
+ ARG_CLOSE_DESCRIPTORS,
+ ARG_USE_PATH,
+ ARG_WAIT,
+ ARG_PROGRAM,
+ ARG_COUNT = ARG_PROGRAM
+};
+
+static int
+dup_noninherited (int fd,
+ int mode)
+{
+ HANDLE filehandle;
+
+ DuplicateHandle (GetCurrentProcess (), (LPHANDLE) _get_osfhandle (fd),
+ GetCurrentProcess (), &filehandle,
+ 0, FALSE, DUPLICATE_SAME_ACCESS);
+ close (fd);
+ return _open_osfhandle ((gintptr) filehandle, mode | _O_NOINHERIT);
+}
+
+#ifndef GSPAWN_HELPER
+
+#ifdef _WIN64
+#define HELPER_PROCESS "gspawn-win64-helper"
+#else
+#define HELPER_PROCESS "gspawn-win32-helper"
+#endif
+
+static gchar *
+protect_argv_string (const gchar *string)
+{
+ const gchar *p = string;
+ gchar *retval, *q;
+ gint len = 0;
+ gboolean need_dblquotes = FALSE;
+ while (*p)
+ {
+ if (*p == ' ' || *p == '\t')
+ need_dblquotes = TRUE;
+ else if (*p == '"')
+ len++;
+ else if (*p == '\\')
+ {
+ const gchar *pp = p;
+ while (*pp && *pp == '\\')
+ pp++;
+ if (*pp == '"')
+ len++;
+ }
+ len++;
+ p++;
+ }
+
+ q = retval = g_malloc (len + need_dblquotes*2 + 1);
+ p = string;
+
+ if (need_dblquotes)
+ *q++ = '"';
+
+ while (*p)
+ {
+ if (*p == '"')
+ *q++ = '\\';
+ else if (*p == '\\')
+ {
+ const gchar *pp = p;
+ while (*pp && *pp == '\\')
+ pp++;
+ if (*pp == '"')
+ *q++ = '\\';
+ }
+ *q++ = *p;
+ p++;
+ }
+
+ if (need_dblquotes)
+ *q++ = '"';
+ *q++ = '\0';
+
+ return retval;
+}
+
+static gint
+protect_argv (gchar **argv,
+ gchar ***new_argv)
+{
+ gint i;
+ gint argc = 0;
+
+ while (argv[argc])
+ ++argc;
+ *new_argv = g_new (gchar *, argc+1);
+
+ /* Quote each argv element if necessary, so that it will get
+ * reconstructed correctly in the C runtime startup code. Note that
+ * the unquoting algorithm in the C runtime is really weird, and
+ * rather different than what Unix shells do. See stdargv.c in the C
+ * runtime sources (in the Platform SDK, in src/crt).
+ *
+ * Note that an new_argv[0] constructed by this function should
+ * *not* be passed as the filename argument to a spawn* or exec*
+ * family function. That argument should be the real file name
+ * without any quoting.
+ */
+ for (i = 0; i < argc; i++)
+ (*new_argv)[i] = protect_argv_string (argv[i]);
+
+ (*new_argv)[argc] = NULL;
+
+ return argc;
+}
+
+GQuark
+g_spawn_error_quark (void)
+{
+ return g_quark_from_static_string ("g-exec-error-quark");
+}
+
+gboolean
+g_spawn_async_utf8 (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data,
+ GPid *child_handle,
+ GError **error)
+{
+ g_return_val_if_fail (argv != NULL, FALSE);
+
+ return g_spawn_async_with_pipes_utf8 (working_directory,
+ argv, envp,
+ flags,
+ child_setup,
+ user_data,
+ child_handle,
+ NULL, NULL, NULL,
+ error);
+}
+
+/* Avoids a danger in threaded situations (calling close()
+ * on a file descriptor twice, and another thread has
+ * re-opened it since the first close)
+ */
+static void
+close_and_invalidate (gint *fd)
+{
+ if (*fd < 0)
+ return;
+
+ close (*fd);
+ *fd = -1;
+}
+
+typedef enum
+{
+ READ_FAILED = 0, /* FALSE */
+ READ_OK,
+ READ_EOF
+} ReadResult;
+
+static ReadResult
+read_data (GString *str,
+ GIOChannel *iochannel,
+ GError **error)
+{
+ GIOStatus giostatus;
+ gsize bytes;
+ gchar buf[4096];
+
+ again:
+
+ giostatus = g_io_channel_read_chars (iochannel, buf, sizeof (buf), &bytes, NULL);
+
+ if (bytes == 0)
+ return READ_EOF;
+ else if (bytes > 0)
+ {
+ g_string_append_len (str, buf, bytes);
+ return READ_OK;
+ }
+ else if (giostatus == G_IO_STATUS_AGAIN)
+ goto again;
+ else if (giostatus == G_IO_STATUS_ERROR)
+ {
+ g_set_error_literal (error, G_SPAWN_ERROR, G_SPAWN_ERROR_READ,
+ _("Failed to read data from child process"));
+
+ return READ_FAILED;
+ }
+ else
+ return READ_OK;
+}
+
+static gboolean
+make_pipe (gint p[2],
+ GError **error)
+{
+ if (_pipe (p, 4096, _O_BINARY) < 0)
+ {
+ int errsv = errno;
+
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Failed to create pipe for communicating with child process (%s)"),
+ g_strerror (errsv));
+ return FALSE;
+ }
+ else
+ return TRUE;
+}
+
+/* The helper process writes a status report back to us, through a
+ * pipe, consisting of two ints.
+ */
+static gboolean
+read_helper_report (int fd,
+ gintptr report[2],
+ GError **error)
+{
+ gint bytes = 0;
+
+ while (bytes < sizeof(gintptr)*2)
+ {
+ gint chunk;
+
+ if (debug)
+ g_print ("%s:read_helper_report: read %" G_GSIZE_FORMAT "...\n",
+ __FILE__,
+ sizeof(gintptr)*2 - bytes);
+
+ chunk = read (fd, ((gchar*)report) + bytes,
+ sizeof(gintptr)*2 - bytes);
+
+ if (debug)
+ g_print ("...got %d bytes\n", chunk);
+
+ if (chunk < 0)
+ {
+ int errsv = errno;
+
+ /* Some weird shit happened, bail out */
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Failed to read from child pipe (%s)"),
+ g_strerror (errsv));
+
+ return FALSE;
+ }
+ else if (chunk == 0)
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Failed to read from child pipe (%s)"),
+ "EOF");
+ break; /* EOF */
+ }
+ else
+ bytes += chunk;
+ }
+
+ if (bytes < sizeof(gintptr)*2)
+ return FALSE;
+
+ return TRUE;
+}
+
+static void
+set_child_error (gintptr report[2],
+ const gchar *working_directory,
+ GError **error)
+{
+ switch (report[0])
+ {
+ case CHILD_CHDIR_FAILED:
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_CHDIR,
+ _("Failed to change to directory '%s' (%s)"),
+ working_directory,
+ g_strerror (report[1]));
+ break;
+ case CHILD_SPAWN_FAILED:
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Failed to execute child process (%s)"),
+ g_strerror (report[1]));
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static gboolean
+utf8_charv_to_wcharv (char **utf8_charv,
+ wchar_t ***wcharv,
+ int *error_index,
+ GError **error)
+{
+ wchar_t **retval = NULL;
+
+ *wcharv = NULL;
+ if (utf8_charv != NULL)
+ {
+ int n = 0, i;
+
+ while (utf8_charv[n])
+ n++;
+ retval = g_new (wchar_t *, n + 1);
+
+ for (i = 0; i < n; i++)
+ {
+ retval[i] = g_utf8_to_utf16 (utf8_charv[i], -1, NULL, NULL, error);
+ if (retval[i] == NULL)
+ {
+ if (error_index)
+ *error_index = i;
+ while (i)
+ g_free (retval[--i]);
+ g_free (retval);
+ return FALSE;
+ }
+ }
+
+ retval[n] = NULL;
+ }
+ *wcharv = retval;
+ return TRUE;
+}
+
+static gboolean
+do_spawn_directly (gint *exit_status,
+ gboolean do_return_handle,
+ GSpawnFlags flags,
+ gchar **argv,
+ char **envp,
+ char **protected_argv,
+ GPid *child_handle,
+ GError **error)
+{
+ const int mode = (exit_status == NULL) ? P_NOWAIT : P_WAIT;
+ char **new_argv;
+ gintptr rc = -1;
+ int saved_errno;
+ GError *conv_error = NULL;
+ gint conv_error_index;
+ wchar_t *wargv0, **wargv, **wenvp;
+
+ new_argv = (flags & G_SPAWN_FILE_AND_ARGV_ZERO) ? protected_argv + 1 : protected_argv;
+
+ wargv0 = g_utf8_to_utf16 (argv[0], -1, NULL, NULL, &conv_error);
+ if (wargv0 == NULL)
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Invalid program name: %s"),
+ conv_error->message);
+ g_error_free (conv_error);
+
+ return FALSE;
+ }
+
+ if (!utf8_charv_to_wcharv (new_argv, &wargv, &conv_error_index, &conv_error))
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Invalid string in argument vector at %d: %s"),
+ conv_error_index, conv_error->message);
+ g_error_free (conv_error);
+ g_free (wargv0);
+
+ return FALSE;
+ }
+
+ if (!utf8_charv_to_wcharv (envp, &wenvp, NULL, &conv_error))
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Invalid string in environment: %s"),
+ conv_error->message);
+ g_error_free (conv_error);
+ g_free (wargv0);
+ g_strfreev ((gchar **) wargv);
+
+ return FALSE;
+ }
+
+ if (flags & G_SPAWN_SEARCH_PATH)
+ if (wenvp != NULL)
+ rc = _wspawnvpe (mode, wargv0, (const wchar_t **) wargv, (const wchar_t **) wenvp);
+ else
+ rc = _wspawnvp (mode, wargv0, (const wchar_t **) wargv);
+ else
+ if (wenvp != NULL)
+ rc = _wspawnve (mode, wargv0, (const wchar_t **) wargv, (const wchar_t **) wenvp);
+ else
+ rc = _wspawnv (mode, wargv0, (const wchar_t **) wargv);
+
+ g_free (wargv0);
+ g_strfreev ((gchar **) wargv);
+ g_strfreev ((gchar **) wenvp);
+
+ saved_errno = errno;
+
+ if (rc == -1 && saved_errno != 0)
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Failed to execute child process (%s)"),
+ g_strerror (saved_errno));
+ return FALSE;
+ }
+
+ if (exit_status == NULL)
+ {
+ if (child_handle && do_return_handle)
+ *child_handle = (GPid) rc;
+ else
+ {
+ CloseHandle ((HANDLE) rc);
+ if (child_handle)
+ *child_handle = 0;
+ }
+ }
+ else
+ *exit_status = rc;
+
+ return TRUE;
+}
+
+static gboolean
+do_spawn_with_pipes (gint *exit_status,
+ gboolean do_return_handle,
+ const gchar *working_directory,
+ gchar **argv,
+ char **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ GPid *child_handle,
+ gint *standard_input,
+ gint *standard_output,
+ gint *standard_error,
+ gint *err_report,
+ GError **error)
+{
+ char **protected_argv;
+ char args[ARG_COUNT][10];
+ char **new_argv;
+ int i;
+ gintptr rc = -1;
+ int saved_errno;
+ int argc;
+ int stdin_pipe[2] = { -1, -1 };
+ int stdout_pipe[2] = { -1, -1 };
+ int stderr_pipe[2] = { -1, -1 };
+ int child_err_report_pipe[2] = { -1, -1 };
+ int helper_sync_pipe[2] = { -1, -1 };
+ gintptr helper_report[2];
+ static gboolean warned_about_child_setup = FALSE;
+ GError *conv_error = NULL;
+ gint conv_error_index;
+ gchar *helper_process;
+ CONSOLE_CURSOR_INFO cursor_info;
+ wchar_t *whelper, **wargv, **wenvp;
+ extern gchar *_glib_get_dll_directory (void);
+ gchar *glib_dll_directory;
+
+ if (child_setup && !warned_about_child_setup)
+ {
+ warned_about_child_setup = TRUE;
+ g_warning ("passing a child setup function to the g_spawn functions is pointless on Windows and it is ignored");
+ }
+
+ argc = protect_argv (argv, &protected_argv);
+
+ if (!standard_input && !standard_output && !standard_error &&
+ (flags & G_SPAWN_CHILD_INHERITS_STDIN) &&
+ !(flags & G_SPAWN_STDOUT_TO_DEV_NULL) &&
+ !(flags & G_SPAWN_STDERR_TO_DEV_NULL) &&
+ (working_directory == NULL || !*working_directory) &&
+ (flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN))
+ {
+ /* We can do without the helper process */
+ gboolean retval =
+ do_spawn_directly (exit_status, do_return_handle, flags,
+ argv, envp, protected_argv,
+ child_handle, error);
+ g_strfreev (protected_argv);
+ return retval;
+ }
+
+ if (standard_input && !make_pipe (stdin_pipe, error))
+ goto cleanup_and_fail;
+
+ if (standard_output && !make_pipe (stdout_pipe, error))
+ goto cleanup_and_fail;
+
+ if (standard_error && !make_pipe (stderr_pipe, error))
+ goto cleanup_and_fail;
+
+ if (!make_pipe (child_err_report_pipe, error))
+ goto cleanup_and_fail;
+
+ if (!make_pipe (helper_sync_pipe, error))
+ goto cleanup_and_fail;
+
+ new_argv = g_new (char *, argc + 1 + ARG_COUNT);
+ if (GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info))
+ helper_process = HELPER_PROCESS "-console.exe";
+ else
+ helper_process = HELPER_PROCESS ".exe";
+
+ glib_dll_directory = _glib_get_dll_directory ();
+ if (glib_dll_directory != NULL)
+ {
+ helper_process = g_build_filename (glib_dll_directory, helper_process, NULL);
+ g_free (glib_dll_directory);
+ }
+ else
+ helper_process = g_strdup (helper_process);
+
+ new_argv[0] = protect_argv_string (helper_process);
+
+ _g_sprintf (args[ARG_CHILD_ERR_REPORT], "%d", child_err_report_pipe[1]);
+ new_argv[ARG_CHILD_ERR_REPORT] = args[ARG_CHILD_ERR_REPORT];
+
+ /* Make the read end of the child error report pipe
+ * noninherited. Otherwise it will needlessly be inherited by the
+ * helper process, and the started actual user process. As such that
+ * shouldn't harm, but it is unnecessary.
+ */
+ child_err_report_pipe[0] = dup_noninherited (child_err_report_pipe[0], _O_RDONLY);
+
+ if (flags & G_SPAWN_FILE_AND_ARGV_ZERO)
+ {
+ /* Overload ARG_CHILD_ERR_REPORT to also encode the
+ * G_SPAWN_FILE_AND_ARGV_ZERO functionality.
+ */
+ strcat (args[ARG_CHILD_ERR_REPORT], "#");
+ }
+
+ _g_sprintf (args[ARG_HELPER_SYNC], "%d", helper_sync_pipe[0]);
+ new_argv[ARG_HELPER_SYNC] = args[ARG_HELPER_SYNC];
+
+ /* Make the write end of the sync pipe noninherited. Otherwise the
+ * helper process will inherit it, and thus if this process happens
+ * to crash before writing the sync byte to the pipe, the helper
+ * process won't read but won't get any EOF either, as it has the
+ * write end open itself.
+ */
+ helper_sync_pipe[1] = dup_noninherited (helper_sync_pipe[1], _O_WRONLY);
+
+ if (standard_input)
+ {
+ _g_sprintf (args[ARG_STDIN], "%d", stdin_pipe[0]);
+ new_argv[ARG_STDIN] = args[ARG_STDIN];
+ }
+ else if (flags & G_SPAWN_CHILD_INHERITS_STDIN)
+ {
+ /* Let stdin be alone */
+ new_argv[ARG_STDIN] = "-";
+ }
+ else
+ {
+ /* Keep process from blocking on a read of stdin */
+ new_argv[ARG_STDIN] = "z";
+ }
+
+ if (standard_output)
+ {
+ _g_sprintf (args[ARG_STDOUT], "%d", stdout_pipe[1]);
+ new_argv[ARG_STDOUT] = args[ARG_STDOUT];
+ }
+ else if (flags & G_SPAWN_STDOUT_TO_DEV_NULL)
+ {
+ new_argv[ARG_STDOUT] = "z";
+ }
+ else
+ {
+ new_argv[ARG_STDOUT] = "-";
+ }
+
+ if (standard_error)
+ {
+ _g_sprintf (args[ARG_STDERR], "%d", stderr_pipe[1]);
+ new_argv[ARG_STDERR] = args[ARG_STDERR];
+ }
+ else if (flags & G_SPAWN_STDERR_TO_DEV_NULL)
+ {
+ new_argv[ARG_STDERR] = "z";
+ }
+ else
+ {
+ new_argv[ARG_STDERR] = "-";
+ }
+
+ if (working_directory && *working_directory)
+ new_argv[ARG_WORKING_DIRECTORY] = protect_argv_string (working_directory);
+ else
+ new_argv[ARG_WORKING_DIRECTORY] = g_strdup ("-");
+
+ if (!(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN))
+ new_argv[ARG_CLOSE_DESCRIPTORS] = "y";
+ else
+ new_argv[ARG_CLOSE_DESCRIPTORS] = "-";
+
+ if (flags & G_SPAWN_SEARCH_PATH)
+ new_argv[ARG_USE_PATH] = "y";
+ else
+ new_argv[ARG_USE_PATH] = "-";
+
+ if (exit_status == NULL)
+ new_argv[ARG_WAIT] = "-";
+ else
+ new_argv[ARG_WAIT] = "w";
+
+ for (i = 0; i <= argc; i++)
+ new_argv[ARG_PROGRAM + i] = protected_argv[i];
+
+ SETUP_DEBUG();
+
+ if (debug)
+ {
+ g_print ("calling %s with argv:\n", helper_process);
+ for (i = 0; i < argc + 1 + ARG_COUNT; i++)
+ g_print ("argv[%d]: %s\n", i, (new_argv[i] ? new_argv[i] : "NULL"));
+ }
+
+ if (!utf8_charv_to_wcharv (new_argv, &wargv, &conv_error_index, &conv_error))
+ {
+ if (conv_error_index == ARG_WORKING_DIRECTORY)
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_CHDIR,
+ _("Invalid working directory: %s"),
+ conv_error->message);
+ else
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Invalid string in argument vector at %d: %s"),
+ conv_error_index - ARG_PROGRAM, conv_error->message);
+ g_error_free (conv_error);
+ g_strfreev (protected_argv);
+ g_free (new_argv[0]);
+ g_free (new_argv[ARG_WORKING_DIRECTORY]);
+ g_free (new_argv);
+ g_free (helper_process);
+
+ goto cleanup_and_fail;
+ }
+
+ if (!utf8_charv_to_wcharv (envp, &wenvp, NULL, &conv_error))
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Invalid string in environment: %s"),
+ conv_error->message);
+ g_error_free (conv_error);
+ g_strfreev (protected_argv);
+ g_free (new_argv[0]);
+ g_free (new_argv[ARG_WORKING_DIRECTORY]);
+ g_free (new_argv);
+ g_free (helper_process);
+ g_strfreev ((gchar **) wargv);
+
+ goto cleanup_and_fail;
+ }
+
+ whelper = g_utf8_to_utf16 (helper_process, -1, NULL, NULL, NULL);
+ g_free (helper_process);
+
+ if (wenvp != NULL)
+ rc = _wspawnvpe (P_NOWAIT, whelper, (const wchar_t **) wargv, (const wchar_t **) wenvp);
+ else
+ rc = _wspawnvp (P_NOWAIT, whelper, (const wchar_t **) wargv);
+
+ saved_errno = errno;
+
+ g_free (whelper);
+ g_strfreev ((gchar **) wargv);
+ g_strfreev ((gchar **) wenvp);
+
+ /* Close the other process's ends of the pipes in this process,
+ * otherwise the reader will never get EOF.
+ */
+ close_and_invalidate (&child_err_report_pipe[1]);
+ close_and_invalidate (&helper_sync_pipe[0]);
+ close_and_invalidate (&stdin_pipe[0]);
+ close_and_invalidate (&stdout_pipe[1]);
+ close_and_invalidate (&stderr_pipe[1]);
+
+ g_strfreev (protected_argv);
+
+ g_free (new_argv[0]);
+ g_free (new_argv[ARG_WORKING_DIRECTORY]);
+ g_free (new_argv);
+
+ /* Check if gspawn-win32-helper couldn't be run */
+ if (rc == -1 && saved_errno != 0)
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Failed to execute helper program (%s)"),
+ g_strerror (saved_errno));
+ goto cleanup_and_fail;
+ }
+
+ if (exit_status != NULL)
+ {
+ /* Synchronous case. Pass helper's report pipe back to caller,
+ * which takes care of reading it after the grandchild has
+ * finished.
+ */
+ g_assert (err_report != NULL);
+ *err_report = child_err_report_pipe[0];
+ write (helper_sync_pipe[1], " ", 1);
+ close_and_invalidate (&helper_sync_pipe[1]);
+ }
+ else
+ {
+ /* Asynchronous case. We read the helper's report right away. */
+ if (!read_helper_report (child_err_report_pipe[0], helper_report, error))
+ goto cleanup_and_fail;
+
+ close_and_invalidate (&child_err_report_pipe[0]);
+
+ switch (helper_report[0])
+ {
+ case CHILD_NO_ERROR:
+ if (child_handle && do_return_handle)
+ {
+ /* rc is our HANDLE for gspawn-win32-helper. It has
+ * told us the HANDLE of its child. Duplicate that into
+ * a HANDLE valid in this process.
+ */
+ if (!DuplicateHandle ((HANDLE) rc, (HANDLE) helper_report[1],
+ GetCurrentProcess (), (LPHANDLE) child_handle,
+ 0, TRUE, DUPLICATE_SAME_ACCESS))
+ {
+ char *emsg = g_win32_error_message (GetLastError ());
+ g_print("%s\n", emsg);
+ *child_handle = 0;
+ }
+ }
+ else if (child_handle)
+ *child_handle = 0;
+ write (helper_sync_pipe[1], " ", 1);
+ close_and_invalidate (&helper_sync_pipe[1]);
+ break;
+
+ default:
+ write (helper_sync_pipe[1], " ", 1);
+ close_and_invalidate (&helper_sync_pipe[1]);
+ set_child_error (helper_report, working_directory, error);
+ goto cleanup_and_fail;
+ }
+ }
+
+ /* Success against all odds! return the information */
+
+ if (standard_input)
+ *standard_input = stdin_pipe[1];
+ if (standard_output)
+ *standard_output = stdout_pipe[0];
+ if (standard_error)
+ *standard_error = stderr_pipe[0];
+ if (rc != -1)
+ CloseHandle ((HANDLE) rc);
+
+ return TRUE;
+
+ cleanup_and_fail:
+
+ if (rc != -1)
+ CloseHandle ((HANDLE) rc);
+ if (child_err_report_pipe[0] != -1)
+ close (child_err_report_pipe[0]);
+ if (child_err_report_pipe[1] != -1)
+ close (child_err_report_pipe[1]);
+ if (helper_sync_pipe[0] != -1)
+ close (helper_sync_pipe[0]);
+ if (helper_sync_pipe[1] != -1)
+ close (helper_sync_pipe[1]);
+ if (stdin_pipe[0] != -1)
+ close (stdin_pipe[0]);
+ if (stdin_pipe[1] != -1)
+ close (stdin_pipe[1]);
+ if (stdout_pipe[0] != -1)
+ close (stdout_pipe[0]);
+ if (stdout_pipe[1] != -1)
+ close (stdout_pipe[1]);
+ if (stderr_pipe[0] != -1)
+ close (stderr_pipe[0]);
+ if (stderr_pipe[1] != -1)
+ close (stderr_pipe[1]);
+
+ return FALSE;
+}
+
+gboolean
+g_spawn_sync_utf8 (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data,
+ gchar **standard_output,
+ gchar **standard_error,
+ gint *exit_status,
+ GError **error)
+{
+ gint outpipe = -1;
+ gint errpipe = -1;
+ gint reportpipe = -1;
+ GIOChannel *outchannel = NULL;
+ GIOChannel *errchannel = NULL;
+ GPollFD outfd, errfd;
+ GPollFD fds[2];
+ gint nfds;
+ gint outindex = -1;
+ gint errindex = -1;
+ gint ret;
+ GString *outstr = NULL;
+ GString *errstr = NULL;
+ gboolean failed;
+ gint status;
+
+ g_return_val_if_fail (argv != NULL, FALSE);
+ g_return_val_if_fail (!(flags & G_SPAWN_DO_NOT_REAP_CHILD), FALSE);
+ g_return_val_if_fail (standard_output == NULL ||
+ !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
+ g_return_val_if_fail (standard_error == NULL ||
+ !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
+
+ /* Just to ensure segfaults if callers try to use
+ * these when an error is reported.
+ */
+ if (standard_output)
+ *standard_output = NULL;
+
+ if (standard_error)
+ *standard_error = NULL;
+
+ if (!do_spawn_with_pipes (&status,
+ FALSE,
+ working_directory,
+ argv,
+ envp,
+ flags,
+ child_setup,
+ NULL,
+ NULL,
+ standard_output ? &outpipe : NULL,
+ standard_error ? &errpipe : NULL,
+ &reportpipe,
+ error))
+ return FALSE;
+
+ /* Read data from child. */
+
+ failed = FALSE;
+
+ if (outpipe >= 0)
+ {
+ outstr = g_string_new (NULL);
+ outchannel = g_io_channel_win32_new_fd (outpipe);
+ g_io_channel_set_encoding (outchannel, NULL, NULL);
+ g_io_channel_set_buffered (outchannel, FALSE);
+ g_io_channel_win32_make_pollfd (outchannel,
+ G_IO_IN | G_IO_ERR | G_IO_HUP,
+ &outfd);
+ if (debug)
+ g_print ("outfd=%p\n", (HANDLE) outfd.fd);
+ }
+
+ if (errpipe >= 0)
+ {
+ errstr = g_string_new (NULL);
+ errchannel = g_io_channel_win32_new_fd (errpipe);
+ g_io_channel_set_encoding (errchannel, NULL, NULL);
+ g_io_channel_set_buffered (errchannel, FALSE);
+ g_io_channel_win32_make_pollfd (errchannel,
+ G_IO_IN | G_IO_ERR | G_IO_HUP,
+ &errfd);
+ if (debug)
+ g_print ("errfd=%p\n", (HANDLE) errfd.fd);
+ }
+
+ /* Read data until we get EOF on all pipes. */
+ while (!failed && (outpipe >= 0 || errpipe >= 0))
+ {
+ nfds = 0;
+ if (outpipe >= 0)
+ {
+ fds[nfds] = outfd;
+ outindex = nfds;
+ nfds++;
+ }
+ if (errpipe >= 0)
+ {
+ fds[nfds] = errfd;
+ errindex = nfds;
+ nfds++;
+ }
+
+ if (debug)
+ g_print ("g_spawn_sync: calling g_io_channel_win32_poll, nfds=%d\n",
+ nfds);
+
+ ret = g_io_channel_win32_poll (fds, nfds, -1);
+
+ if (ret < 0)
+ {
+ failed = TRUE;
+
+ g_set_error_literal (error, G_SPAWN_ERROR, G_SPAWN_ERROR_READ,
+ _("Unexpected error in g_io_channel_win32_poll() reading data from a child process"));
+
+ break;
+ }
+
+ if (outpipe >= 0 && (fds[outindex].revents & G_IO_IN))
+ {
+ switch (read_data (outstr, outchannel, error))
+ {
+ case READ_FAILED:
+ if (debug)
+ g_print ("g_spawn_sync: outchannel: READ_FAILED\n");
+ failed = TRUE;
+ break;
+ case READ_EOF:
+ if (debug)
+ g_print ("g_spawn_sync: outchannel: READ_EOF\n");
+ g_io_channel_unref (outchannel);
+ outchannel = NULL;
+ close_and_invalidate (&outpipe);
+ break;
+ default:
+ if (debug)
+ g_print ("g_spawn_sync: outchannel: OK\n");
+ break;
+ }
+
+ if (failed)
+ break;
+ }
+
+ if (errpipe >= 0 && (fds[errindex].revents & G_IO_IN))
+ {
+ switch (read_data (errstr, errchannel, error))
+ {
+ case READ_FAILED:
+ if (debug)
+ g_print ("g_spawn_sync: errchannel: READ_FAILED\n");
+ failed = TRUE;
+ break;
+ case READ_EOF:
+ if (debug)
+ g_print ("g_spawn_sync: errchannel: READ_EOF\n");
+ g_io_channel_unref (errchannel);
+ errchannel = NULL;
+ close_and_invalidate (&errpipe);
+ break;
+ default:
+ if (debug)
+ g_print ("g_spawn_sync: errchannel: OK\n");
+ break;
+ }
+
+ if (failed)
+ break;
+ }
+ }
+
+ if (reportpipe == -1)
+ {
+ /* No helper process, exit status of actual spawned process
+ * already available.
+ */
+ if (exit_status)
+ *exit_status = status;
+ }
+ else
+ {
+ /* Helper process was involved. Read its report now after the
+ * grandchild has finished.
+ */
+ gintptr helper_report[2];
+
+ if (!read_helper_report (reportpipe, helper_report, error))
+ failed = TRUE;
+ else
+ {
+ switch (helper_report[0])
+ {
+ case CHILD_NO_ERROR:
+ if (exit_status)
+ *exit_status = helper_report[1];
+ break;
+ default:
+ set_child_error (helper_report, working_directory, error);
+ failed = TRUE;
+ break;
+ }
+ }
+ close_and_invalidate (&reportpipe);
+ }
+
+
+ /* These should only be open still if we had an error. */
+
+ if (outchannel != NULL)
+ g_io_channel_unref (outchannel);
+ if (errchannel != NULL)
+ g_io_channel_unref (errchannel);
+ if (outpipe >= 0)
+ close_and_invalidate (&outpipe);
+ if (errpipe >= 0)
+ close_and_invalidate (&errpipe);
+
+ if (failed)
+ {
+ if (outstr)
+ g_string_free (outstr, TRUE);
+ if (errstr)
+ g_string_free (errstr, TRUE);
+
+ return FALSE;
+ }
+ else
+ {
+ if (standard_output)
+ *standard_output = g_string_free (outstr, FALSE);
+
+ if (standard_error)
+ *standard_error = g_string_free (errstr, FALSE);
+
+ return TRUE;
+ }
+}
+
+gboolean
+g_spawn_async_with_pipes_utf8 (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data,
+ GPid *child_handle,
+ gint *standard_input,
+ gint *standard_output,
+ gint *standard_error,
+ GError **error)
+{
+ g_return_val_if_fail (argv != NULL, FALSE);
+ g_return_val_if_fail (standard_output == NULL ||
+ !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
+ g_return_val_if_fail (standard_error == NULL ||
+ !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
+ /* can't inherit stdin if we have an input pipe. */
+ g_return_val_if_fail (standard_input == NULL ||
+ !(flags & G_SPAWN_CHILD_INHERITS_STDIN), FALSE);
+
+ return do_spawn_with_pipes (NULL,
+ (flags & G_SPAWN_DO_NOT_REAP_CHILD),
+ working_directory,
+ argv,
+ envp,
+ flags,
+ child_setup,
+ child_handle,
+ standard_input,
+ standard_output,
+ standard_error,
+ NULL,
+ error);
+}
+
+gboolean
+g_spawn_command_line_sync_utf8 (const gchar *command_line,
+ gchar **standard_output,
+ gchar **standard_error,
+ gint *exit_status,
+ GError **error)
+{
+ gboolean retval;
+ gchar **argv = 0;
+
+ g_return_val_if_fail (command_line != NULL, FALSE);
+
+ if (!g_shell_parse_argv (command_line,
+ NULL, &argv,
+ error))
+ return FALSE;
+
+ retval = g_spawn_sync_utf8 (NULL,
+ argv,
+ NULL,
+ G_SPAWN_SEARCH_PATH,
+ NULL,
+ NULL,
+ standard_output,
+ standard_error,
+ exit_status,
+ error);
+ g_strfreev (argv);
+
+ return retval;
+}
+
+gboolean
+g_spawn_command_line_async_utf8 (const gchar *command_line,
+ GError **error)
+{
+ gboolean retval;
+ gchar **argv = 0;
+
+ g_return_val_if_fail (command_line != NULL, FALSE);
+
+ if (!g_shell_parse_argv (command_line,
+ NULL, &argv,
+ error))
+ return FALSE;
+
+ retval = g_spawn_async_utf8 (NULL,
+ argv,
+ NULL,
+ G_SPAWN_SEARCH_PATH,
+ NULL,
+ NULL,
+ NULL,
+ error);
+ g_strfreev (argv);
+
+ return retval;
+}
+
+void
+g_spawn_close_pid (GPid pid)
+{
+ CloseHandle (pid);
+}
+
+#if !defined (_WIN64)
+
+/* Binary compatibility versions that take system codepage pathnames,
+ * argument vectors and environments. These get used only by code
+ * built against 2.8.1 or earlier. Code built against 2.8.2 or later
+ * will use the _utf8 versions above (see the #defines in gspawn.h).
+ */
+
+#undef g_spawn_async
+#undef g_spawn_async_with_pipes
+#undef g_spawn_sync
+#undef g_spawn_command_line_sync
+#undef g_spawn_command_line_async
+
+static gboolean
+setup_utf8_copies (const gchar *working_directory,
+ gchar **utf8_working_directory,
+ gchar **argv,
+ gchar ***utf8_argv,
+ gchar **envp,
+ gchar ***utf8_envp,
+ GError **error)
+{
+ gint i, argc, envc;
+
+ if (working_directory == NULL)
+ *utf8_working_directory = NULL;
+ else
+ {
+ GError *conv_error = NULL;
+
+ *utf8_working_directory = g_locale_to_utf8 (working_directory, -1, NULL, NULL, &conv_error);
+ if (*utf8_working_directory == NULL)
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_CHDIR,
+ _("Invalid working directory: %s"),
+ conv_error->message);
+ g_error_free (conv_error);
+ return FALSE;
+ }
+ }
+
+ argc = 0;
+ while (argv[argc])
+ ++argc;
+ *utf8_argv = g_new (gchar *, argc + 1);
+ for (i = 0; i < argc; i++)
+ {
+ GError *conv_error = NULL;
+
+ (*utf8_argv)[i] = g_locale_to_utf8 (argv[i], -1, NULL, NULL, &conv_error);
+ if ((*utf8_argv)[i] == NULL)
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Invalid string in argument vector at %d: %s"),
+ i, conv_error->message);
+ g_error_free (conv_error);
+
+ g_strfreev (*utf8_argv);
+ *utf8_argv = NULL;
+
+ g_free (*utf8_working_directory);
+ *utf8_working_directory = NULL;
+
+ return FALSE;
+ }
+ }
+ (*utf8_argv)[argc] = NULL;
+
+ if (envp == NULL)
+ {
+ *utf8_envp = NULL;
+ }
+ else
+ {
+ envc = 0;
+ while (envp[envc])
+ ++envc;
+ *utf8_envp = g_new (gchar *, envc + 1);
+ for (i = 0; i < envc; i++)
+ {
+ GError *conv_error = NULL;
+
+ (*utf8_envp)[i] = g_locale_to_utf8 (envp[i], -1, NULL, NULL, &conv_error);
+ if ((*utf8_envp)[i] == NULL)
+ {
+ g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ _("Invalid string in environment: %s"),
+ conv_error->message);
+ g_error_free (conv_error);
+
+ g_strfreev (*utf8_envp);
+ *utf8_envp = NULL;
+
+ g_strfreev (*utf8_argv);
+ *utf8_argv = NULL;
+
+ g_free (*utf8_working_directory);
+ *utf8_working_directory = NULL;
+
+ return FALSE;
+ }
+ }
+ (*utf8_envp)[envc] = NULL;
+ }
+ return TRUE;
+}
+
+static void
+free_utf8_copies (gchar *utf8_working_directory,
+ gchar **utf8_argv,
+ gchar **utf8_envp)
+{
+ g_free (utf8_working_directory);
+ g_strfreev (utf8_argv);
+ g_strfreev (utf8_envp);
+}
+
+gboolean
+g_spawn_async_with_pipes (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data,
+ GPid *child_handle,
+ gint *standard_input,
+ gint *standard_output,
+ gint *standard_error,
+ GError **error)
+{
+ gchar *utf8_working_directory;
+ gchar **utf8_argv;
+ gchar **utf8_envp;
+ gboolean retval;
+
+ if (!setup_utf8_copies (working_directory, &utf8_working_directory,
+ argv, &utf8_argv,
+ envp, &utf8_envp,
+ error))
+ return FALSE;
+
+ retval = g_spawn_async_with_pipes_utf8 (utf8_working_directory,
+ utf8_argv, utf8_envp,
+ flags, child_setup, user_data,
+ child_handle,
+ standard_input, standard_output, standard_error,
+ error);
+
+ free_utf8_copies (utf8_working_directory, utf8_argv, utf8_envp);
+
+ return retval;
+}
+
+gboolean
+g_spawn_async (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data,
+ GPid *child_handle,
+ GError **error)
+{
+ return g_spawn_async_with_pipes (working_directory,
+ argv, envp,
+ flags,
+ child_setup,
+ user_data,
+ child_handle,
+ NULL, NULL, NULL,
+ error);
+}
+
+gboolean
+g_spawn_sync (const gchar *working_directory,
+ gchar **argv,
+ gchar **envp,
+ GSpawnFlags flags,
+ GSpawnChildSetupFunc child_setup,
+ gpointer user_data,
+ gchar **standard_output,
+ gchar **standard_error,
+ gint *exit_status,
+ GError **error)
+{
+ gchar *utf8_working_directory;
+ gchar **utf8_argv;
+ gchar **utf8_envp;
+ gboolean retval;
+
+ if (!setup_utf8_copies (working_directory, &utf8_working_directory,
+ argv, &utf8_argv,
+ envp, &utf8_envp,
+ error))
+ return FALSE;
+
+ retval = g_spawn_sync_utf8 (utf8_working_directory,
+ utf8_argv, utf8_envp,
+ flags, child_setup, user_data,
+ standard_output, standard_error, exit_status,
+ error);
+
+ free_utf8_copies (utf8_working_directory, utf8_argv, utf8_envp);
+
+ return retval;
+}
+
+gboolean
+g_spawn_command_line_sync (const gchar *command_line,
+ gchar **standard_output,
+ gchar **standard_error,
+ gint *exit_status,
+ GError **error)
+{
+ gboolean retval;
+ gchar **argv = 0;
+
+ g_return_val_if_fail (command_line != NULL, FALSE);
+
+ if (!g_shell_parse_argv (command_line,
+ NULL, &argv,
+ error))
+ return FALSE;
+
+ retval = g_spawn_sync (NULL,
+ argv,
+ NULL,
+ G_SPAWN_SEARCH_PATH,
+ NULL,
+ NULL,
+ standard_output,
+ standard_error,
+ exit_status,
+ error);
+ g_strfreev (argv);
+
+ return retval;
+}
+
+gboolean
+g_spawn_command_line_async (const gchar *command_line,
+ GError **error)
+{
+ gboolean retval;
+ gchar **argv = 0;
+
+ g_return_val_if_fail (command_line != NULL, FALSE);
+
+ if (!g_shell_parse_argv (command_line,
+ NULL, &argv,
+ error))
+ return FALSE;
+
+ retval = g_spawn_async (NULL,
+ argv,
+ NULL,
+ G_SPAWN_SEARCH_PATH,
+ NULL,
+ NULL,
+ NULL,
+ error);
+ g_strfreev (argv);
+
+ return retval;
+}
+
+#endif /* !_WIN64 */
+
+#endif /* !GSPAWN_HELPER */