/* 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 "glib-private.h" #include "gprintfint.h" #include "glibintl.h" #include "gthread.h" #include #include #include #include #include #include #include #include #include #include #ifndef GSPAWN_HELPER #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 #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; } G_DEFINE_QUARK (g-exec-error-quark, g_spawn_error) G_DEFINE_QUARK (g-spawn-exit-error-quark, g_spawn_exit_error) 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; 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); } gboolean g_spawn_check_exit_status (gint exit_status, GError **error) { gboolean ret = FALSE; if (exit_status != 0) { g_set_error (error, G_SPAWN_EXIT_ERROR, exit_status, _("Child process exited with code %ld"), (long) exit_status); goto out; } ret = TRUE; out: return ret; } #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 */