1 /* gspawn-win32.c - Process launching on Win32
3 * Copyright 2000 Red Hat, Inc.
4 * Copyright 2003 Tor Lillqvist
6 * GLib is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
11 * GLib is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with GLib; see the file COPYING.LIB. If not, write
18 * to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
23 * Implementation details on Win32.
25 * - There is no way to set the no-inherit flag for
26 * a "file descriptor" in the MS C runtime. The flag is there,
27 * and the dospawn() function uses it, but unfortunately
28 * this flag can only be set when opening the file.
29 * - As there is no fork(), we cannot reliably change directory
30 * before starting the child process. (There might be several threads
31 * running, and the current directory is common for all threads.)
33 * Thus, we must in many cases use a helper program to handle closing
34 * of (inherited) file descriptors and changing of directory. The
35 * helper process is also needed if the standard input, standard
36 * output, or standard error of the process to be run are supposed to
37 * be redirected somewhere.
39 * The structure of the source code in this file is a mess, I know.
42 /* Define this to get some logging all the time */
43 /* #define G_SPAWN_WIN32_DEBUG */
48 #include "gprintfint.h"
63 #ifdef G_SPAWN_WIN32_DEBUG
65 #define SETUP_DEBUG() /* empty */
67 static int debug
= -1;
68 #define SETUP_DEBUG() \
73 if (getenv ("G_SPAWN_WIN32_DEBUG") != NULL) \
90 ARG_CHILD_ERR_REPORT
= 1,
95 ARG_WORKING_DIRECTORY
,
96 ARG_CLOSE_DESCRIPTORS
,
100 ARG_COUNT
= ARG_PROGRAM
104 dup_noninherited (int fd
,
109 DuplicateHandle (GetCurrentProcess (), (LPHANDLE
) _get_osfhandle (fd
),
110 GetCurrentProcess (), &filehandle
,
111 0, FALSE
, DUPLICATE_SAME_ACCESS
);
113 return _open_osfhandle ((gintptr
) filehandle
, mode
| _O_NOINHERIT
);
116 #ifndef GSPAWN_HELPER
119 #define HELPER_PROCESS "gspawn-win64-helper"
121 #define HELPER_PROCESS "gspawn-win32-helper"
125 protect_argv_string (const gchar
*string
)
127 const gchar
*p
= string
;
130 gboolean need_dblquotes
= FALSE
;
133 if (*p
== ' ' || *p
== '\t')
134 need_dblquotes
= TRUE
;
140 while (*pp
&& *pp
== '\\')
149 q
= retval
= g_malloc (len
+ need_dblquotes
*2 + 1);
162 while (*pp
&& *pp
== '\\')
179 protect_argv (gchar
**argv
,
187 *new_argv
= g_new (gchar
*, argc
+1);
189 /* Quote each argv element if necessary, so that it will get
190 * reconstructed correctly in the C runtime startup code. Note that
191 * the unquoting algorithm in the C runtime is really weird, and
192 * rather different than what Unix shells do. See stdargv.c in the C
193 * runtime sources (in the Platform SDK, in src/crt).
195 * Note that an new_argv[0] constructed by this function should
196 * *not* be passed as the filename argument to a spawn* or exec*
197 * family function. That argument should be the real file name
198 * without any quoting.
200 for (i
= 0; i
< argc
; i
++)
201 (*new_argv
)[i
] = protect_argv_string (argv
[i
]);
203 (*new_argv
)[argc
] = NULL
;
209 g_spawn_error_quark (void)
211 return g_quark_from_static_string ("g-exec-error-quark");
215 g_spawn_async_utf8 (const gchar
*working_directory
,
219 GSpawnChildSetupFunc child_setup
,
224 g_return_val_if_fail (argv
!= NULL
, FALSE
);
226 return g_spawn_async_with_pipes_utf8 (working_directory
,
236 /* Avoids a danger in threaded situations (calling close()
237 * on a file descriptor twice, and another thread has
238 * re-opened it since the first close)
241 close_and_invalidate (gint
*fd
)
252 READ_FAILED
= 0, /* FALSE */
258 read_data (GString
*str
,
259 GIOChannel
*iochannel
,
268 giostatus
= g_io_channel_read_chars (iochannel
, buf
, sizeof (buf
), &bytes
, NULL
);
274 g_string_append_len (str
, buf
, bytes
);
277 else if (giostatus
== G_IO_STATUS_AGAIN
)
279 else if (giostatus
== G_IO_STATUS_ERROR
)
281 g_set_error_literal (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_READ
,
282 _("Failed to read data from child process"));
291 make_pipe (gint p
[2],
294 if (_pipe (p
, 4096, _O_BINARY
) < 0)
298 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
299 _("Failed to create pipe for communicating with child process (%s)"),
307 /* The helper process writes a status report back to us, through a
308 * pipe, consisting of two ints.
311 read_helper_report (int fd
,
317 while (bytes
< sizeof(gintptr
)*2)
322 g_print ("%s:read_helper_report: read %" G_GSIZE_FORMAT
"...\n",
324 sizeof(gintptr
)*2 - bytes
);
326 chunk
= read (fd
, ((gchar
*)report
) + bytes
,
327 sizeof(gintptr
)*2 - bytes
);
330 g_print ("...got %d bytes\n", chunk
);
336 /* Some weird shit happened, bail out */
337 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
338 _("Failed to read from child pipe (%s)"),
345 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
346 _("Failed to read from child pipe (%s)"),
354 if (bytes
< sizeof(gintptr
)*2)
361 set_child_error (gintptr report
[2],
362 const gchar
*working_directory
,
367 case CHILD_CHDIR_FAILED
:
368 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_CHDIR
,
369 _("Failed to change to directory '%s' (%s)"),
371 g_strerror (report
[1]));
373 case CHILD_SPAWN_FAILED
:
374 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
375 _("Failed to execute child process (%s)"),
376 g_strerror (report
[1]));
379 g_assert_not_reached ();
384 utf8_charv_to_wcharv (char **utf8_charv
,
389 wchar_t **retval
= NULL
;
392 if (utf8_charv
!= NULL
)
396 while (utf8_charv
[n
])
398 retval
= g_new (wchar_t *, n
+ 1);
400 for (i
= 0; i
< n
; i
++)
402 retval
[i
] = g_utf8_to_utf16 (utf8_charv
[i
], -1, NULL
, NULL
, error
);
403 if (retval
[i
] == NULL
)
408 g_free (retval
[--i
]);
421 do_spawn_directly (gint
*exit_status
,
422 gboolean do_return_handle
,
426 char **protected_argv
,
430 const int mode
= (exit_status
== NULL
) ? P_NOWAIT
: P_WAIT
;
434 GError
*conv_error
= NULL
;
435 gint conv_error_index
;
436 wchar_t *wargv0
, **wargv
, **wenvp
;
438 new_argv
= (flags
& G_SPAWN_FILE_AND_ARGV_ZERO
) ? protected_argv
+ 1 : protected_argv
;
440 wargv0
= g_utf8_to_utf16 (argv
[0], -1, NULL
, NULL
, &conv_error
);
443 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
444 _("Invalid program name: %s"),
445 conv_error
->message
);
446 g_error_free (conv_error
);
451 if (!utf8_charv_to_wcharv (new_argv
, &wargv
, &conv_error_index
, &conv_error
))
453 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
454 _("Invalid string in argument vector at %d: %s"),
455 conv_error_index
, conv_error
->message
);
456 g_error_free (conv_error
);
462 if (!utf8_charv_to_wcharv (envp
, &wenvp
, NULL
, &conv_error
))
464 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
465 _("Invalid string in environment: %s"),
466 conv_error
->message
);
467 g_error_free (conv_error
);
469 g_strfreev ((gchar
**) wargv
);
474 if (flags
& G_SPAWN_SEARCH_PATH
)
476 rc
= _wspawnvpe (mode
, wargv0
, (const wchar_t **) wargv
, (const wchar_t **) wenvp
);
478 rc
= _wspawnvp (mode
, wargv0
, (const wchar_t **) wargv
);
481 rc
= _wspawnve (mode
, wargv0
, (const wchar_t **) wargv
, (const wchar_t **) wenvp
);
483 rc
= _wspawnv (mode
, wargv0
, (const wchar_t **) wargv
);
486 g_strfreev ((gchar
**) wargv
);
487 g_strfreev ((gchar
**) wenvp
);
491 if (rc
== -1 && saved_errno
!= 0)
493 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
494 _("Failed to execute child process (%s)"),
495 g_strerror (saved_errno
));
499 if (exit_status
== NULL
)
501 if (child_handle
&& do_return_handle
)
502 *child_handle
= (GPid
) rc
;
505 CloseHandle ((HANDLE
) rc
);
517 do_spawn_with_pipes (gint
*exit_status
,
518 gboolean do_return_handle
,
519 const gchar
*working_directory
,
523 GSpawnChildSetupFunc child_setup
,
525 gint
*standard_input
,
526 gint
*standard_output
,
527 gint
*standard_error
,
531 char **protected_argv
;
532 char args
[ARG_COUNT
][10];
538 int stdin_pipe
[2] = { -1, -1 };
539 int stdout_pipe
[2] = { -1, -1 };
540 int stderr_pipe
[2] = { -1, -1 };
541 int child_err_report_pipe
[2] = { -1, -1 };
542 int helper_sync_pipe
[2] = { -1, -1 };
543 gintptr helper_report
[2];
544 static gboolean warned_about_child_setup
= FALSE
;
545 GError
*conv_error
= NULL
;
546 gint conv_error_index
;
547 gchar
*helper_process
;
548 CONSOLE_CURSOR_INFO cursor_info
;
549 wchar_t *whelper
, **wargv
, **wenvp
;
550 extern gchar
*_glib_get_dll_directory (void);
551 gchar
*glib_dll_directory
;
553 if (child_setup
&& !warned_about_child_setup
)
555 warned_about_child_setup
= TRUE
;
556 g_warning ("passing a child setup function to the g_spawn functions is pointless on Windows and it is ignored");
559 argc
= protect_argv (argv
, &protected_argv
);
561 if (!standard_input
&& !standard_output
&& !standard_error
&&
562 (flags
& G_SPAWN_CHILD_INHERITS_STDIN
) &&
563 !(flags
& G_SPAWN_STDOUT_TO_DEV_NULL
) &&
564 !(flags
& G_SPAWN_STDERR_TO_DEV_NULL
) &&
565 (working_directory
== NULL
|| !*working_directory
) &&
566 (flags
& G_SPAWN_LEAVE_DESCRIPTORS_OPEN
))
568 /* We can do without the helper process */
570 do_spawn_directly (exit_status
, do_return_handle
, flags
,
571 argv
, envp
, protected_argv
,
572 child_handle
, error
);
573 g_strfreev (protected_argv
);
577 if (standard_input
&& !make_pipe (stdin_pipe
, error
))
578 goto cleanup_and_fail
;
580 if (standard_output
&& !make_pipe (stdout_pipe
, error
))
581 goto cleanup_and_fail
;
583 if (standard_error
&& !make_pipe (stderr_pipe
, error
))
584 goto cleanup_and_fail
;
586 if (!make_pipe (child_err_report_pipe
, error
))
587 goto cleanup_and_fail
;
589 if (!make_pipe (helper_sync_pipe
, error
))
590 goto cleanup_and_fail
;
592 new_argv
= g_new (char *, argc
+ 1 + ARG_COUNT
);
593 if (GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE
), &cursor_info
))
594 helper_process
= HELPER_PROCESS
"-console.exe";
596 helper_process
= HELPER_PROCESS
".exe";
598 glib_dll_directory
= _glib_get_dll_directory ();
599 if (glib_dll_directory
!= NULL
)
601 helper_process
= g_build_filename (glib_dll_directory
, helper_process
, NULL
);
602 g_free (glib_dll_directory
);
605 helper_process
= g_strdup (helper_process
);
607 new_argv
[0] = protect_argv_string (helper_process
);
609 _g_sprintf (args
[ARG_CHILD_ERR_REPORT
], "%d", child_err_report_pipe
[1]);
610 new_argv
[ARG_CHILD_ERR_REPORT
] = args
[ARG_CHILD_ERR_REPORT
];
612 /* Make the read end of the child error report pipe
613 * noninherited. Otherwise it will needlessly be inherited by the
614 * helper process, and the started actual user process. As such that
615 * shouldn't harm, but it is unnecessary.
617 child_err_report_pipe
[0] = dup_noninherited (child_err_report_pipe
[0], _O_RDONLY
);
619 if (flags
& G_SPAWN_FILE_AND_ARGV_ZERO
)
621 /* Overload ARG_CHILD_ERR_REPORT to also encode the
622 * G_SPAWN_FILE_AND_ARGV_ZERO functionality.
624 strcat (args
[ARG_CHILD_ERR_REPORT
], "#");
627 _g_sprintf (args
[ARG_HELPER_SYNC
], "%d", helper_sync_pipe
[0]);
628 new_argv
[ARG_HELPER_SYNC
] = args
[ARG_HELPER_SYNC
];
630 /* Make the write end of the sync pipe noninherited. Otherwise the
631 * helper process will inherit it, and thus if this process happens
632 * to crash before writing the sync byte to the pipe, the helper
633 * process won't read but won't get any EOF either, as it has the
634 * write end open itself.
636 helper_sync_pipe
[1] = dup_noninherited (helper_sync_pipe
[1], _O_WRONLY
);
640 _g_sprintf (args
[ARG_STDIN
], "%d", stdin_pipe
[0]);
641 new_argv
[ARG_STDIN
] = args
[ARG_STDIN
];
643 else if (flags
& G_SPAWN_CHILD_INHERITS_STDIN
)
645 /* Let stdin be alone */
646 new_argv
[ARG_STDIN
] = "-";
650 /* Keep process from blocking on a read of stdin */
651 new_argv
[ARG_STDIN
] = "z";
656 _g_sprintf (args
[ARG_STDOUT
], "%d", stdout_pipe
[1]);
657 new_argv
[ARG_STDOUT
] = args
[ARG_STDOUT
];
659 else if (flags
& G_SPAWN_STDOUT_TO_DEV_NULL
)
661 new_argv
[ARG_STDOUT
] = "z";
665 new_argv
[ARG_STDOUT
] = "-";
670 _g_sprintf (args
[ARG_STDERR
], "%d", stderr_pipe
[1]);
671 new_argv
[ARG_STDERR
] = args
[ARG_STDERR
];
673 else if (flags
& G_SPAWN_STDERR_TO_DEV_NULL
)
675 new_argv
[ARG_STDERR
] = "z";
679 new_argv
[ARG_STDERR
] = "-";
682 if (working_directory
&& *working_directory
)
683 new_argv
[ARG_WORKING_DIRECTORY
] = protect_argv_string (working_directory
);
685 new_argv
[ARG_WORKING_DIRECTORY
] = g_strdup ("-");
687 if (!(flags
& G_SPAWN_LEAVE_DESCRIPTORS_OPEN
))
688 new_argv
[ARG_CLOSE_DESCRIPTORS
] = "y";
690 new_argv
[ARG_CLOSE_DESCRIPTORS
] = "-";
692 if (flags
& G_SPAWN_SEARCH_PATH
)
693 new_argv
[ARG_USE_PATH
] = "y";
695 new_argv
[ARG_USE_PATH
] = "-";
697 if (exit_status
== NULL
)
698 new_argv
[ARG_WAIT
] = "-";
700 new_argv
[ARG_WAIT
] = "w";
702 for (i
= 0; i
<= argc
; i
++)
703 new_argv
[ARG_PROGRAM
+ i
] = protected_argv
[i
];
709 g_print ("calling %s with argv:\n", helper_process
);
710 for (i
= 0; i
< argc
+ 1 + ARG_COUNT
; i
++)
711 g_print ("argv[%d]: %s\n", i
, (new_argv
[i
] ? new_argv
[i
] : "NULL"));
714 if (!utf8_charv_to_wcharv (new_argv
, &wargv
, &conv_error_index
, &conv_error
))
716 if (conv_error_index
== ARG_WORKING_DIRECTORY
)
717 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_CHDIR
,
718 _("Invalid working directory: %s"),
719 conv_error
->message
);
721 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
722 _("Invalid string in argument vector at %d: %s"),
723 conv_error_index
- ARG_PROGRAM
, conv_error
->message
);
724 g_error_free (conv_error
);
725 g_strfreev (protected_argv
);
726 g_free (new_argv
[0]);
727 g_free (new_argv
[ARG_WORKING_DIRECTORY
]);
729 g_free (helper_process
);
731 goto cleanup_and_fail
;
734 if (!utf8_charv_to_wcharv (envp
, &wenvp
, NULL
, &conv_error
))
736 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
737 _("Invalid string in environment: %s"),
738 conv_error
->message
);
739 g_error_free (conv_error
);
740 g_strfreev (protected_argv
);
741 g_free (new_argv
[0]);
742 g_free (new_argv
[ARG_WORKING_DIRECTORY
]);
744 g_free (helper_process
);
745 g_strfreev ((gchar
**) wargv
);
747 goto cleanup_and_fail
;
750 whelper
= g_utf8_to_utf16 (helper_process
, -1, NULL
, NULL
, NULL
);
751 g_free (helper_process
);
754 rc
= _wspawnvpe (P_NOWAIT
, whelper
, (const wchar_t **) wargv
, (const wchar_t **) wenvp
);
756 rc
= _wspawnvp (P_NOWAIT
, whelper
, (const wchar_t **) wargv
);
761 g_strfreev ((gchar
**) wargv
);
762 g_strfreev ((gchar
**) wenvp
);
764 /* Close the other process's ends of the pipes in this process,
765 * otherwise the reader will never get EOF.
767 close_and_invalidate (&child_err_report_pipe
[1]);
768 close_and_invalidate (&helper_sync_pipe
[0]);
769 close_and_invalidate (&stdin_pipe
[0]);
770 close_and_invalidate (&stdout_pipe
[1]);
771 close_and_invalidate (&stderr_pipe
[1]);
773 g_strfreev (protected_argv
);
775 g_free (new_argv
[0]);
776 g_free (new_argv
[ARG_WORKING_DIRECTORY
]);
779 /* Check if gspawn-win32-helper couldn't be run */
780 if (rc
== -1 && saved_errno
!= 0)
782 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
783 _("Failed to execute helper program (%s)"),
784 g_strerror (saved_errno
));
785 goto cleanup_and_fail
;
788 if (exit_status
!= NULL
)
790 /* Synchronous case. Pass helper's report pipe back to caller,
791 * which takes care of reading it after the grandchild has
794 g_assert (err_report
!= NULL
);
795 *err_report
= child_err_report_pipe
[0];
796 write (helper_sync_pipe
[1], " ", 1);
797 close_and_invalidate (&helper_sync_pipe
[1]);
801 /* Asynchronous case. We read the helper's report right away. */
802 if (!read_helper_report (child_err_report_pipe
[0], helper_report
, error
))
803 goto cleanup_and_fail
;
805 close_and_invalidate (&child_err_report_pipe
[0]);
807 switch (helper_report
[0])
810 if (child_handle
&& do_return_handle
)
812 /* rc is our HANDLE for gspawn-win32-helper. It has
813 * told us the HANDLE of its child. Duplicate that into
814 * a HANDLE valid in this process.
816 if (!DuplicateHandle ((HANDLE
) rc
, (HANDLE
) helper_report
[1],
817 GetCurrentProcess (), (LPHANDLE
) child_handle
,
818 0, TRUE
, DUPLICATE_SAME_ACCESS
))
820 char *emsg
= g_win32_error_message (GetLastError ());
821 g_print("%s\n", emsg
);
825 else if (child_handle
)
827 write (helper_sync_pipe
[1], " ", 1);
828 close_and_invalidate (&helper_sync_pipe
[1]);
832 write (helper_sync_pipe
[1], " ", 1);
833 close_and_invalidate (&helper_sync_pipe
[1]);
834 set_child_error (helper_report
, working_directory
, error
);
835 goto cleanup_and_fail
;
839 /* Success against all odds! return the information */
842 *standard_input
= stdin_pipe
[1];
844 *standard_output
= stdout_pipe
[0];
846 *standard_error
= stderr_pipe
[0];
848 CloseHandle ((HANDLE
) rc
);
855 CloseHandle ((HANDLE
) rc
);
856 if (child_err_report_pipe
[0] != -1)
857 close (child_err_report_pipe
[0]);
858 if (child_err_report_pipe
[1] != -1)
859 close (child_err_report_pipe
[1]);
860 if (helper_sync_pipe
[0] != -1)
861 close (helper_sync_pipe
[0]);
862 if (helper_sync_pipe
[1] != -1)
863 close (helper_sync_pipe
[1]);
864 if (stdin_pipe
[0] != -1)
865 close (stdin_pipe
[0]);
866 if (stdin_pipe
[1] != -1)
867 close (stdin_pipe
[1]);
868 if (stdout_pipe
[0] != -1)
869 close (stdout_pipe
[0]);
870 if (stdout_pipe
[1] != -1)
871 close (stdout_pipe
[1]);
872 if (stderr_pipe
[0] != -1)
873 close (stderr_pipe
[0]);
874 if (stderr_pipe
[1] != -1)
875 close (stderr_pipe
[1]);
881 g_spawn_sync_utf8 (const gchar
*working_directory
,
885 GSpawnChildSetupFunc child_setup
,
887 gchar
**standard_output
,
888 gchar
**standard_error
,
894 gint reportpipe
= -1;
895 GIOChannel
*outchannel
= NULL
;
896 GIOChannel
*errchannel
= NULL
;
897 GPollFD outfd
, errfd
;
903 GString
*outstr
= NULL
;
904 GString
*errstr
= NULL
;
908 g_return_val_if_fail (argv
!= NULL
, FALSE
);
909 g_return_val_if_fail (!(flags
& G_SPAWN_DO_NOT_REAP_CHILD
), FALSE
);
910 g_return_val_if_fail (standard_output
== NULL
||
911 !(flags
& G_SPAWN_STDOUT_TO_DEV_NULL
), FALSE
);
912 g_return_val_if_fail (standard_error
== NULL
||
913 !(flags
& G_SPAWN_STDERR_TO_DEV_NULL
), FALSE
);
915 /* Just to ensure segfaults if callers try to use
916 * these when an error is reported.
919 *standard_output
= NULL
;
922 *standard_error
= NULL
;
924 if (!do_spawn_with_pipes (&status
,
933 standard_output
? &outpipe
: NULL
,
934 standard_error
? &errpipe
: NULL
,
939 /* Read data from child. */
945 outstr
= g_string_new (NULL
);
946 outchannel
= g_io_channel_win32_new_fd (outpipe
);
947 g_io_channel_set_encoding (outchannel
, NULL
, NULL
);
948 g_io_channel_set_buffered (outchannel
, FALSE
);
949 g_io_channel_win32_make_pollfd (outchannel
,
950 G_IO_IN
| G_IO_ERR
| G_IO_HUP
,
953 g_print ("outfd=%p\n", (HANDLE
) outfd
.fd
);
958 errstr
= g_string_new (NULL
);
959 errchannel
= g_io_channel_win32_new_fd (errpipe
);
960 g_io_channel_set_encoding (errchannel
, NULL
, NULL
);
961 g_io_channel_set_buffered (errchannel
, FALSE
);
962 g_io_channel_win32_make_pollfd (errchannel
,
963 G_IO_IN
| G_IO_ERR
| G_IO_HUP
,
966 g_print ("errfd=%p\n", (HANDLE
) errfd
.fd
);
969 /* Read data until we get EOF on all pipes. */
970 while (!failed
&& (outpipe
>= 0 || errpipe
>= 0))
987 g_print ("g_spawn_sync: calling g_io_channel_win32_poll, nfds=%d\n",
990 ret
= g_io_channel_win32_poll (fds
, nfds
, -1);
996 g_set_error_literal (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_READ
,
997 _("Unexpected error in g_io_channel_win32_poll() reading data from a child process"));
1002 if (outpipe
>= 0 && (fds
[outindex
].revents
& G_IO_IN
))
1004 switch (read_data (outstr
, outchannel
, error
))
1008 g_print ("g_spawn_sync: outchannel: READ_FAILED\n");
1013 g_print ("g_spawn_sync: outchannel: READ_EOF\n");
1014 g_io_channel_unref (outchannel
);
1016 close_and_invalidate (&outpipe
);
1020 g_print ("g_spawn_sync: outchannel: OK\n");
1028 if (errpipe
>= 0 && (fds
[errindex
].revents
& G_IO_IN
))
1030 switch (read_data (errstr
, errchannel
, error
))
1034 g_print ("g_spawn_sync: errchannel: READ_FAILED\n");
1039 g_print ("g_spawn_sync: errchannel: READ_EOF\n");
1040 g_io_channel_unref (errchannel
);
1042 close_and_invalidate (&errpipe
);
1046 g_print ("g_spawn_sync: errchannel: OK\n");
1055 if (reportpipe
== -1)
1057 /* No helper process, exit status of actual spawned process
1058 * already available.
1061 *exit_status
= status
;
1065 /* Helper process was involved. Read its report now after the
1066 * grandchild has finished.
1068 gintptr helper_report
[2];
1070 if (!read_helper_report (reportpipe
, helper_report
, error
))
1074 switch (helper_report
[0])
1076 case CHILD_NO_ERROR
:
1078 *exit_status
= helper_report
[1];
1081 set_child_error (helper_report
, working_directory
, error
);
1086 close_and_invalidate (&reportpipe
);
1090 /* These should only be open still if we had an error. */
1092 if (outchannel
!= NULL
)
1093 g_io_channel_unref (outchannel
);
1094 if (errchannel
!= NULL
)
1095 g_io_channel_unref (errchannel
);
1097 close_and_invalidate (&outpipe
);
1099 close_and_invalidate (&errpipe
);
1104 g_string_free (outstr
, TRUE
);
1106 g_string_free (errstr
, TRUE
);
1112 if (standard_output
)
1113 *standard_output
= g_string_free (outstr
, FALSE
);
1116 *standard_error
= g_string_free (errstr
, FALSE
);
1123 g_spawn_async_with_pipes_utf8 (const gchar
*working_directory
,
1127 GSpawnChildSetupFunc child_setup
,
1130 gint
*standard_input
,
1131 gint
*standard_output
,
1132 gint
*standard_error
,
1135 g_return_val_if_fail (argv
!= NULL
, FALSE
);
1136 g_return_val_if_fail (standard_output
== NULL
||
1137 !(flags
& G_SPAWN_STDOUT_TO_DEV_NULL
), FALSE
);
1138 g_return_val_if_fail (standard_error
== NULL
||
1139 !(flags
& G_SPAWN_STDERR_TO_DEV_NULL
), FALSE
);
1140 /* can't inherit stdin if we have an input pipe. */
1141 g_return_val_if_fail (standard_input
== NULL
||
1142 !(flags
& G_SPAWN_CHILD_INHERITS_STDIN
), FALSE
);
1144 return do_spawn_with_pipes (NULL
,
1145 (flags
& G_SPAWN_DO_NOT_REAP_CHILD
),
1160 g_spawn_command_line_sync_utf8 (const gchar
*command_line
,
1161 gchar
**standard_output
,
1162 gchar
**standard_error
,
1169 g_return_val_if_fail (command_line
!= NULL
, FALSE
);
1171 if (!g_shell_parse_argv (command_line
,
1176 retval
= g_spawn_sync_utf8 (NULL
,
1179 G_SPAWN_SEARCH_PATH
,
1192 g_spawn_command_line_async_utf8 (const gchar
*command_line
,
1198 g_return_val_if_fail (command_line
!= NULL
, FALSE
);
1200 if (!g_shell_parse_argv (command_line
,
1205 retval
= g_spawn_async_utf8 (NULL
,
1208 G_SPAWN_SEARCH_PATH
,
1219 g_spawn_close_pid (GPid pid
)
1224 #if !defined (_WIN64)
1226 /* Binary compatibility versions that take system codepage pathnames,
1227 * argument vectors and environments. These get used only by code
1228 * built against 2.8.1 or earlier. Code built against 2.8.2 or later
1229 * will use the _utf8 versions above (see the #defines in gspawn.h).
1232 #undef g_spawn_async
1233 #undef g_spawn_async_with_pipes
1235 #undef g_spawn_command_line_sync
1236 #undef g_spawn_command_line_async
1239 setup_utf8_copies (const gchar
*working_directory
,
1240 gchar
**utf8_working_directory
,
1249 if (working_directory
== NULL
)
1250 *utf8_working_directory
= NULL
;
1253 GError
*conv_error
= NULL
;
1255 *utf8_working_directory
= g_locale_to_utf8 (working_directory
, -1, NULL
, NULL
, &conv_error
);
1256 if (*utf8_working_directory
== NULL
)
1258 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_CHDIR
,
1259 _("Invalid working directory: %s"),
1260 conv_error
->message
);
1261 g_error_free (conv_error
);
1269 *utf8_argv
= g_new (gchar
*, argc
+ 1);
1270 for (i
= 0; i
< argc
; i
++)
1272 GError
*conv_error
= NULL
;
1274 (*utf8_argv
)[i
] = g_locale_to_utf8 (argv
[i
], -1, NULL
, NULL
, &conv_error
);
1275 if ((*utf8_argv
)[i
] == NULL
)
1277 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
1278 _("Invalid string in argument vector at %d: %s"),
1279 i
, conv_error
->message
);
1280 g_error_free (conv_error
);
1282 g_strfreev (*utf8_argv
);
1285 g_free (*utf8_working_directory
);
1286 *utf8_working_directory
= NULL
;
1291 (*utf8_argv
)[argc
] = NULL
;
1302 *utf8_envp
= g_new (gchar
*, envc
+ 1);
1303 for (i
= 0; i
< envc
; i
++)
1305 GError
*conv_error
= NULL
;
1307 (*utf8_envp
)[i
] = g_locale_to_utf8 (envp
[i
], -1, NULL
, NULL
, &conv_error
);
1308 if ((*utf8_envp
)[i
] == NULL
)
1310 g_set_error (error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
,
1311 _("Invalid string in environment: %s"),
1312 conv_error
->message
);
1313 g_error_free (conv_error
);
1315 g_strfreev (*utf8_envp
);
1318 g_strfreev (*utf8_argv
);
1321 g_free (*utf8_working_directory
);
1322 *utf8_working_directory
= NULL
;
1327 (*utf8_envp
)[envc
] = NULL
;
1333 free_utf8_copies (gchar
*utf8_working_directory
,
1337 g_free (utf8_working_directory
);
1338 g_strfreev (utf8_argv
);
1339 g_strfreev (utf8_envp
);
1343 g_spawn_async_with_pipes (const gchar
*working_directory
,
1347 GSpawnChildSetupFunc child_setup
,
1350 gint
*standard_input
,
1351 gint
*standard_output
,
1352 gint
*standard_error
,
1355 gchar
*utf8_working_directory
;
1360 if (!setup_utf8_copies (working_directory
, &utf8_working_directory
,
1366 retval
= g_spawn_async_with_pipes_utf8 (utf8_working_directory
,
1367 utf8_argv
, utf8_envp
,
1368 flags
, child_setup
, user_data
,
1370 standard_input
, standard_output
, standard_error
,
1373 free_utf8_copies (utf8_working_directory
, utf8_argv
, utf8_envp
);
1379 g_spawn_async (const gchar
*working_directory
,
1383 GSpawnChildSetupFunc child_setup
,
1388 return g_spawn_async_with_pipes (working_directory
,
1399 g_spawn_sync (const gchar
*working_directory
,
1403 GSpawnChildSetupFunc child_setup
,
1405 gchar
**standard_output
,
1406 gchar
**standard_error
,
1410 gchar
*utf8_working_directory
;
1415 if (!setup_utf8_copies (working_directory
, &utf8_working_directory
,
1421 retval
= g_spawn_sync_utf8 (utf8_working_directory
,
1422 utf8_argv
, utf8_envp
,
1423 flags
, child_setup
, user_data
,
1424 standard_output
, standard_error
, exit_status
,
1427 free_utf8_copies (utf8_working_directory
, utf8_argv
, utf8_envp
);
1433 g_spawn_command_line_sync (const gchar
*command_line
,
1434 gchar
**standard_output
,
1435 gchar
**standard_error
,
1442 g_return_val_if_fail (command_line
!= NULL
, FALSE
);
1444 if (!g_shell_parse_argv (command_line
,
1449 retval
= g_spawn_sync (NULL
,
1452 G_SPAWN_SEARCH_PATH
,
1465 g_spawn_command_line_async (const gchar
*command_line
,
1471 g_return_val_if_fail (command_line
!= NULL
, FALSE
);
1473 if (!g_shell_parse_argv (command_line
,
1478 retval
= g_spawn_async (NULL
,
1481 G_SPAWN_SEARCH_PATH
,
1491 #endif /* !_WIN64 */
1493 #endif /* !GSPAWN_HELPER */