?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Mark functions with G_GNUC_MALLOC when appropriate.
[glib.git] / glib / gspawn-win32.c
blob70eaaa8ef3168188745d1ab5e2412999db056113
1 /* gspawn-win32.c - Process launching on Win32
2 *
3 * Copyright 2000 Red Hat, Inc.
4 * Copyright 2003 Tor Lillqvist
5 *
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.
10 *
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.
15 *
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.
20 */
21
22 /*
23 * Implementation details on Win32.
24 *
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.)
32 *
33 * Thus, we must in most 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.
38 *
39 * The structure of the source code in this file is a mess, I know.
40 */
41
42 /* Define this to get some logging all the time */
43 /* #define G_SPAWN_WIN32_DEBUG */
44
45 #include <config.h>
46
47 #include "galias.h"
48 #include "glib.h"
49 #include "gprintfint.h"
50
51 #include <string.h>
52 #include <stdlib.h>
53 #include <stdio.h>
54
55 #include <windows.h>
56 #include <errno.h>
57 #include <fcntl.h>
58 #include <io.h>
59 #include <process.h>
60 #include <direct.h>
61
62 #include "glibintl.h"
63
64 #ifdef G_SPAWN_WIN32_DEBUG
65 static int debug = 1;
66 #define SETUP_DEBUG() /* empty */
67
68 #else
69 static int debug = -1;
70 #define SETUP_DEBUG() \
71 G_STMT_START \
72 { \
73 if (debug == -1) \
74 { \
75 if (getenv ("G_SPAWN_WIN32_DEBUG") != NULL) \
76 debug = 1; \
77 else \
78 debug = 0; \
79 } \
80 } \
81 G_STMT_END
82 #endif
83
84 enum
85 {
86 CHILD_NO_ERROR,
87 CHILD_CHDIR_FAILED,
88 CHILD_SPAWN_FAILED,
89 };
90
91 enum {
92 ARG_CHILD_ERR_REPORT = 1,
93 ARG_STDIN,
94 ARG_STDOUT,
95 ARG_STDERR,
96 ARG_WORKING_DIRECTORY,
97 ARG_CLOSE_DESCRIPTORS,
98 ARG_USE_PATH,
99 ARG_WAIT,
100 ARG_PROGRAM,
101 ARG_COUNT = ARG_PROGRAM
102 };
103
104 /* Return codes from do_spawn() */
105 #define DO_SPAWN_ERROR_HELPER -1
106 #define DO_SPAWN_OK_NO_HELPER -2
107 #define DO_SPAWN_ERROR_NO_HELPER -3
108
109 static gint
110 protect_argv (gchar **argv,
111 gchar ***new_argv)
112 {
113 gint i;
114 gint argc = 0;
115
116 while (argv[argc])
117 ++argc;
118 *new_argv = g_new (gchar *, argc+1);
119
120 /* Quote each argv element if necessary, so that it will get
121 * reconstructed correctly in the C runtime startup code. Note that
122 * the unquoting algorithm in the C runtime is really weird, and
123 * rather different than what Unix shells do. See stdargv.c in the C
124 * runtime sources (in the Platform SDK, in src/crt).
125 *
126 * Note that an new_argv[0] constructed by this function should
127 * *not* be passed as the filename argument to a spawn* or exec*
128 * family function. That argument should be the real file name
129 * without any quoting.
130 */
131 for (i = 0; i < argc; i++)
132 {
133 gchar *p = argv[i];
134 gchar *q;
135 gint len = 0;
136 gboolean need_dblquotes = FALSE;
137 while (*p)
138 {
139 if (*p == ' ' || *p == '\t')
140 need_dblquotes = TRUE;
141 else if (*p == '"')
142 len++;
143 else if (*p == '\\')
144 {
145 gchar *pp = p;
146 while (*pp && *pp == '\\')
147 pp++;
148 if (*pp == '"')
149 len++;
150 }
151 len++;
152 p++;
153 }
154
155 q = (*new_argv)[i] = g_malloc (len + need_dblquotes*2 + 1);
156 p = argv[i];
157
158 if (need_dblquotes)
159 *q++ = '"';
160
161 while (*p)
162 {
163 if (*p == '"')
164 *q++ = '\\';
165 else if (*p == '\\')
166 {
167 gchar *pp = p;
168 while (*pp && *pp == '\\')
169 pp++;
170 if (*pp == '"')
171 *q++ = '\\';
172 }
173 *q++ = *p;
174 p++;
175 }
176
177 if (need_dblquotes)
178 *q++ = '"';
179 *q++ = '\0';
180 /* printf ("argv[%d]:%s, need_dblquotes:%s len:%d => %s\n", i, argv[i], need_dblquotes?"TRUE":"FALSE", len, (*new_argv)[i]); */
181 }
182 (*new_argv)[argc] = NULL;
183
184 return argc;
185 }
186
187 #ifndef GSPAWN_HELPER
188
189 static gboolean make_pipe (gint p[2],
190 GError **error);
191 static gboolean do_spawn_with_pipes (gboolean dont_wait,
192 gboolean dont_return_handle,
193 const gchar *working_directory,
194 gchar **argv,
195 gchar **envp,
196 gboolean close_descriptors,
197 gboolean search_path,
198 gboolean stdout_to_null,
199 gboolean stderr_to_null,
200 gboolean child_inherits_stdin,
201 gboolean file_and_argv_zero,
202 GSpawnChildSetupFunc child_setup,
203 gpointer user_data,
204 GPid *child_handle,
205 gint *standard_input,
206 gint *standard_output,
207 gint *standard_error,
208 gint *exit_status,
209 GError **error);
210
211 GQuark
212 g_spawn_error_quark (void)
213 {
214 static GQuark quark = 0;
215 if (quark == 0)
216 quark = g_quark_from_static_string ("g-exec-error-quark");
217 return quark;
218 }
219
220 gboolean
221 g_spawn_async (const gchar *working_directory,
222 gchar **argv,
223 gchar **envp,
224 GSpawnFlags flags,
225 GSpawnChildSetupFunc child_setup,
226 gpointer user_data,
227 GPid *child_handle,
228 GError **error)
229 {
230 g_return_val_if_fail (argv != NULL, FALSE);
231
232 return g_spawn_async_with_pipes (working_directory,
233 argv, envp,
234 flags,
235 child_setup,
236 user_data,
237 child_handle,
238 NULL, NULL, NULL,
239 error);
240 }
241
242 /* Avoids a danger in threaded situations (calling close()
243 * on a file descriptor twice, and another thread has
244 * re-opened it since the first close)
245 */
246 static gint
247 close_and_invalidate (gint *fd)
248 {
249 gint ret;
250
251 if (*fd < 0)
252 return -1;
253 else
254 {
255 ret = close (*fd);
256 *fd = -1;
257 }
258
259 return ret;
260 }
261
262 typedef enum
263 {
264 READ_FAILED = 0, /* FALSE */
265 READ_OK,
266 READ_EOF
267 } ReadResult;
268
269 static ReadResult
270 read_data (GString *str,
271 GIOChannel *iochannel,
272 GError **error)
273 {
274 GIOStatus giostatus;
275 gssize bytes;
276 gchar buf[4096];
277
278 again:
279
280 giostatus = g_io_channel_read_chars (iochannel, buf, sizeof (buf), &bytes, NULL);
281
282 if (bytes == 0)
283 return READ_EOF;
284 else if (bytes > 0)
285 {
286 g_string_append_len (str, buf, bytes);
287 return READ_OK;
288 }
289 else if (giostatus == G_IO_STATUS_AGAIN)
290 goto again;
291 else if (giostatus == G_IO_STATUS_ERROR)
292 {
293 g_set_error (error,
294 G_SPAWN_ERROR,
295 G_SPAWN_ERROR_READ,
296 _("Failed to read data from child process"));
297
298 return READ_FAILED;
299 }
300 else
301 return READ_OK;
302 }
303
304 gboolean
305 g_spawn_sync (const gchar *working_directory,
306 gchar **argv,
307 gchar **envp,
308 GSpawnFlags flags,
309 GSpawnChildSetupFunc child_setup,
310 gpointer user_data,
311 gchar **standard_output,
312 gchar **standard_error,
313 gint *exit_status,
314 GError **error)
315 {
316 gint outpipe = -1;
317 gint errpipe = -1;
318 GPid pid;
319 GIOChannel *outchannel = NULL;
320 GIOChannel *errchannel = NULL;
321 GPollFD outfd, errfd;
322 GPollFD fds[2];
323 gint nfds;
324 gint outindex = -1;
325 gint errindex = -1;
326 gint ret;
327 GString *outstr = NULL;
328 GString *errstr = NULL;
329 gboolean failed;
330 gint status;
331
332 g_return_val_if_fail (argv != NULL, FALSE);
333 g_return_val_if_fail (!(flags & G_SPAWN_DO_NOT_REAP_CHILD), FALSE);
334 g_return_val_if_fail (standard_output == NULL ||
335 !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
336 g_return_val_if_fail (standard_error == NULL ||
337 !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
338
339 /* Just to ensure segfaults if callers try to use
340 * these when an error is reported.
341 */
342 if (standard_output)
343 *standard_output = NULL;
344
345 if (standard_error)
346 *standard_error = NULL;
347
348 if (!do_spawn_with_pipes (FALSE,
349 TRUE,
350 working_directory,
351 argv,
352 envp,
353 !(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN),
354 (flags & G_SPAWN_SEARCH_PATH) != 0,
355 (flags & G_SPAWN_STDOUT_TO_DEV_NULL) != 0,
356 (flags & G_SPAWN_STDERR_TO_DEV_NULL) != 0,
357 (flags & G_SPAWN_CHILD_INHERITS_STDIN) != 0,
358 (flags & G_SPAWN_FILE_AND_ARGV_ZERO) != 0,
359 child_setup,
360 user_data,
361 &pid,
362 NULL,
363 standard_output ? &outpipe : NULL,
364 standard_error ? &errpipe : NULL,
365 &status,
366 error))
367 return FALSE;
368
369 /* Read data from child. */
370
371 failed = FALSE;
372
373 if (outpipe >= 0)
374 {
375 outstr = g_string_new (NULL);
376 outchannel = g_io_channel_win32_new_fd (outpipe);
377 g_io_channel_set_encoding (outchannel, NULL, NULL);
378 g_io_channel_win32_make_pollfd (outchannel,
379 G_IO_IN | G_IO_ERR | G_IO_HUP,
380 &outfd);
381 }
382
383 if (errpipe >= 0)
384 {
385 errstr = g_string_new (NULL);
386 errchannel = g_io_channel_win32_new_fd (errpipe);
387 g_io_channel_set_encoding (errchannel, NULL, NULL);
388 g_io_channel_win32_make_pollfd (errchannel,
389 G_IO_IN | G_IO_ERR | G_IO_HUP,
390 &errfd);
391 }
392
393 /* Read data until we get EOF on both pipes. */
394 while (!failed &&
395 (outpipe >= 0 ||
396 errpipe >= 0))
397 {
398 nfds = 0;
399 if (outpipe >= 0)
400 {
401 fds[nfds] = outfd;
402 outindex = nfds;
403 nfds++;
404 }
405 if (errpipe >= 0)
406 {
407 fds[nfds] = errfd;
408 errindex = nfds;
409 nfds++;
410 }
411
412 if (debug)
413 g_print ("%s:g_spawn_sync: calling g_io_channel_win32_poll, nfds=%d\n",
414 __FILE__, nfds);
415
416 ret = g_io_channel_win32_poll (fds, nfds, -1);
417
418 if (ret < 0)
419 {
420 failed = TRUE;
421
422 g_set_error (error,
423 G_SPAWN_ERROR,
424 G_SPAWN_ERROR_READ,
425 _("Unexpected error in g_io_channel_win32_poll() reading data from a child process"));
426
427 break;
428 }
429
430 if (outpipe >= 0 && (fds[outindex].revents & G_IO_IN))
431 {
432 switch (read_data (outstr, outchannel, error))
433 {
434 case READ_FAILED:
435 if (debug)
436 g_print ("g_spawn_sync: outchannel: READ_FAILED\n");
437 failed = TRUE;
438 break;
439 case READ_EOF:
440 if (debug)
441 g_print ("g_spawn_sync: outchannel: READ_EOF\n");
442 g_io_channel_unref (outchannel);
443 outchannel = NULL;
444 close_and_invalidate (&outpipe);
445 break;
446 default:
447 if (debug)
448 g_print ("g_spawn_sync: outchannel: OK\n");
449 break;
450 }
451
452 if (failed)
453 break;
454 }
455
456 if (errpipe >= 0 && (fds[errindex].revents & G_IO_IN))
457 {
458 switch (read_data (errstr, errchannel, error))
459 {
460 case READ_FAILED:
461 if (debug)
462 g_print ("g_spawn_sync: errchannel: READ_FAILED\n");
463 failed = TRUE;
464 break;
465 case READ_EOF:
466 if (debug)
467 g_print ("g_spawn_sync: errchannel: READ_EOF\n");
468 g_io_channel_unref (errchannel);
469 errchannel = NULL;
470 close_and_invalidate (&errpipe);
471 break;
472 default:
473 if (debug)
474 g_print ("g_spawn_sync: errchannel: OK\n");
475 break;
476 }
477
478 if (failed)
479 break;
480 }
481 }
482
483 /* These should only be open still if we had an error. */
484
485 if (outchannel != NULL)
486 g_io_channel_unref (outchannel);
487 if (errchannel != NULL)
488 g_io_channel_unref (errchannel);
489 if (outpipe >= 0)
490 close_and_invalidate (&outpipe);
491 if (errpipe >= 0)
492 close_and_invalidate (&errpipe);
493
494 g_spawn_close_pid(pid);
495
496 if (failed)
497 {
498 if (outstr)
499 g_string_free (outstr, TRUE);
500 if (errstr)
501 g_string_free (errstr, TRUE);
502
503 return FALSE;
504 }
505 else
506 {
507 if (exit_status)
508 *exit_status = status;
509
510 if (standard_output)
511 *standard_output = g_string_free (outstr, FALSE);
512
513 if (standard_error)
514 *standard_error = g_string_free (errstr, FALSE);
515
516 return TRUE;
517 }
518 }
519
520 gboolean
521 g_spawn_async_with_pipes (const gchar *working_directory,
522 gchar **argv,
523 gchar **envp,
524 GSpawnFlags flags,
525 GSpawnChildSetupFunc child_setup,
526 gpointer user_data,
527 GPid *child_handle,
528 gint *standard_input,
529 gint *standard_output,
530 gint *standard_error,
531 GError **error)
532 {
533 g_return_val_if_fail (argv != NULL, FALSE);
534 g_return_val_if_fail (standard_output == NULL ||
535 !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
536 g_return_val_if_fail (standard_error == NULL ||
537 !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
538 /* can't inherit stdin if we have an input pipe. */
539 g_return_val_if_fail (standard_input == NULL ||
540 !(flags & G_SPAWN_CHILD_INHERITS_STDIN), FALSE);
541
542 return do_spawn_with_pipes (TRUE,
543 !(flags & G_SPAWN_DO_NOT_REAP_CHILD),
544 working_directory,
545 argv,
546 envp,
547 !(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN),
548 (flags & G_SPAWN_SEARCH_PATH) != 0,
549 (flags & G_SPAWN_STDOUT_TO_DEV_NULL) != 0,
550 (flags & G_SPAWN_STDERR_TO_DEV_NULL) != 0,
551 (flags & G_SPAWN_CHILD_INHERITS_STDIN) != 0,
552 (flags & G_SPAWN_FILE_AND_ARGV_ZERO) != 0,
553 child_setup,
554 user_data,
555 child_handle,
556 standard_input,
557 standard_output,
558 standard_error,
559 NULL,
560 error);
561 }
562
563 gboolean
564 g_spawn_command_line_sync (const gchar *command_line,
565 gchar **standard_output,
566 gchar **standard_error,
567 gint *exit_status,
568 GError **error)
569 {
570 gboolean retval;
571 gchar **argv = 0;
572
573 g_return_val_if_fail (command_line != NULL, FALSE);
574
575 if (!g_shell_parse_argv (command_line,
576 NULL, &argv,
577 error))
578 return FALSE;
579
580 retval = g_spawn_sync (NULL,
581 argv,
582 NULL,
583 G_SPAWN_SEARCH_PATH,
584 NULL,
585 NULL,
586 standard_output,
587 standard_error,
588 exit_status,
589 error);
590 g_strfreev (argv);
591
592 return retval;
593 }
594
595 gboolean
596 g_spawn_command_line_async (const gchar *command_line,
597 GError **error)
598 {
599 gboolean retval;
600 gchar **argv = 0;
601
602 g_return_val_if_fail (command_line != NULL, FALSE);
603
604 if (!g_shell_parse_argv (command_line,
605 NULL, &argv,
606 error))
607 return FALSE;
608
609 retval = g_spawn_async (NULL,
610 argv,
611 NULL,
612 G_SPAWN_SEARCH_PATH,
613 NULL,
614 NULL,
615 NULL,
616 error);
617 g_strfreev (argv);
618
619 return retval;
620 }
621
622 /* This stinks, code reorg needed. Presumably do_spawn() should be
623 * inserted into its only caller, do_spawn_with_pipes(), and then code
624 * snippets from that function should be split out to separate
625 * functions if necessary.
626 */
627
628 static gint shortcut_spawn_retval;
629
630 static gint
631 do_spawn (gboolean dont_wait,
632 gint child_err_report_fd,
633 gint stdin_fd,
634 gint stdout_fd,
635 gint stderr_fd,
636 const gchar *working_directory,
637 gchar **argv,
638 gchar **envp,
639 gboolean close_descriptors,
640 gboolean search_path,
641 gboolean stdout_to_null,
642 gboolean stderr_to_null,
643 gboolean child_inherits_stdin,
644 gboolean file_and_argv_zero,
645 GSpawnChildSetupFunc child_setup,
646 gpointer user_data)
647 {
648 gchar **protected_argv;
649 gchar **new_argv;
650 gchar args[ARG_COUNT][10];
651 gint i;
652 int rc;
653 int argc;
654
655 SETUP_DEBUG();
656
657 argc = protect_argv (argv, &protected_argv);
658
659 if (stdin_fd == -1 && stdout_fd == -1 && stderr_fd == -1 &&
660 (working_directory == NULL || !*working_directory) &&
661 !close_descriptors &&
662 !stdout_to_null && !stderr_to_null &&
663 child_inherits_stdin)
664 {
665 /* We can do without the helper process */
666 int mode = dont_wait ? P_NOWAIT : P_WAIT;
667
668 if (debug)
669 g_print ("doing without gspawn-win32-helper\n");
670
671 if (search_path)
672 rc = spawnvp (mode, argv[0], file_and_argv_zero ? protected_argv + 1 : protected_argv);
673 else
674 rc = spawnv (mode, argv[0], file_and_argv_zero ? protected_argv + 1 : protected_argv);
675
676 for (i = 0; i < argc; i++)
677 g_free (protected_argv[i]);
678 g_free (protected_argv);
679
680 if (rc == -1)
681 {
682 return DO_SPAWN_ERROR_NO_HELPER;
683 }
684 else
685 {
686 shortcut_spawn_retval = rc;
687 return DO_SPAWN_OK_NO_HELPER;
688 }
689 }
690
691 new_argv = g_new (gchar *, argc + 1 + ARG_COUNT);
692
693 new_argv[0] = "gspawn-win32-helper";
694 _g_sprintf (args[ARG_CHILD_ERR_REPORT], "%d", child_err_report_fd);
695 new_argv[ARG_CHILD_ERR_REPORT] = args[ARG_CHILD_ERR_REPORT];
696
697 if (file_and_argv_zero)
698 {
699 /* Overload ARG_CHILD_ERR_REPORT to also encode the
700 * G_SPAWN_FILE_AND_ARGV_ZERO functionality.
701 */
702 strcat (args[ARG_CHILD_ERR_REPORT], "#");
703 }
704
705 if (stdin_fd >= 0)
706 {
707 _g_sprintf (args[ARG_STDIN], "%d", stdin_fd);
708 new_argv[ARG_STDIN] = args[ARG_STDIN];
709 }
710 else if (child_inherits_stdin)
711 {
712 /* Let stdin be alone */
713 new_argv[ARG_STDIN] = "-";
714 }
715 else
716 {
717 /* Keep process from blocking on a read of stdin */
718 new_argv[ARG_STDIN] = "z";
719 }
720
721 if (stdout_fd >= 0)
722 {
723 _g_sprintf (args[ARG_STDOUT], "%d", stdout_fd);
724 new_argv[ARG_STDOUT] = args[ARG_STDOUT];
725 }
726 else if (stdout_to_null)
727 {
728 new_argv[ARG_STDOUT] = "z";
729 }
730 else
731 {
732 new_argv[ARG_STDOUT] = "-";
733 }
734
735 if (stderr_fd >= 0)
736 {
737 _g_sprintf (args[ARG_STDERR], "%d", stderr_fd);
738 new_argv[ARG_STDERR] = args[ARG_STDERR];
739 }
740 else if (stderr_to_null)
741 {
742 new_argv[ARG_STDERR] = "z";
743 }
744 else
745 {
746 new_argv[ARG_STDERR] = "-";
747 }
748
749 if (working_directory && *working_directory)
750 /* The g_strdup() to lose the constness */
751 new_argv[ARG_WORKING_DIRECTORY] = g_strdup (working_directory);
752 else
753 new_argv[ARG_WORKING_DIRECTORY] = g_strdup ("-");
754
755 if (close_descriptors)
756 new_argv[ARG_CLOSE_DESCRIPTORS] = "y";
757 else
758 new_argv[ARG_CLOSE_DESCRIPTORS] = "-";
759
760 if (search_path)
761 new_argv[ARG_USE_PATH] = "y";
762 else
763 new_argv[ARG_USE_PATH] = "-";
764
765 if (dont_wait)
766 new_argv[ARG_WAIT] = "-";
767 else
768 new_argv[ARG_WAIT] = "w";
769
770 for (i = 0; i <= argc; i++)
771 new_argv[ARG_PROGRAM + i] = protected_argv[i];
772
773 /* Call user function just before we execute the helper program,
774 * which executes the program. Dunno what's the usefulness of this.
775 * A child setup function used on Unix probably isn't of much use
776 * as such on Win32, anyhow
777 */
778 if (child_setup)
779 {
780 (* child_setup) (user_data);
781 }
782
783 if (debug)
784 {
785 g_print ("calling gspawn-win32-helper with argv:\n");
786 for (i = 0; i < argc + 1 + ARG_COUNT; i++)
787 g_print ("argv[%d]: %s\n", i, (new_argv[i] ? new_argv[i] : "NULL"));
788 }
789
790 if (envp != NULL)
791 /* Let's hope envp hasn't mucked with PATH so that
792 * gspawn-win32-helper.exe isn't found.
793 */
794 rc = spawnvpe (P_NOWAIT, "gspawn-win32-helper", new_argv, envp);
795 else
796 rc = spawnvp (P_NOWAIT, "gspawn-win32-helper", new_argv);
797
798 /* Close the child_err_report_fd and the other process's ends of the
799 * pipes in this process, otherwise the reader will never get
800 * EOF.
801 */
802 close (child_err_report_fd);
803 if (stdin_fd >= 0)
804 close (stdin_fd);
805 if (stdout_fd >= 0)
806 close (stdout_fd);
807 if (stderr_fd >= 0)
808 close (stderr_fd);
809
810 for (i = 0; i < argc; i++)
811 g_free (protected_argv[i]);
812 g_free (protected_argv);
813
814 g_free (new_argv[ARG_WORKING_DIRECTORY]);
815 g_free (new_argv);
816
817 return rc;
818 }
819
820 static gboolean
821 read_ints (int fd,
822 gint* buf,
823 gint n_ints_in_buf,
824 gint *n_ints_read,
825 GError **error)
826 {
827 gint bytes = 0;
828
829 while (bytes < sizeof(gint)*n_ints_in_buf)
830 {
831 gint chunk;
832
833 if (debug)
834 g_print ("%s:read_ints: trying to read %d bytes from pipe...\n",
835 __FILE__,
836 sizeof(gint)*n_ints_in_buf - bytes);
837
838 chunk = read (fd, ((gchar*)buf) + bytes,
839 sizeof(gint)*n_ints_in_buf - bytes);
840
841 if (debug)
842 g_print ("... got %d bytes\n", chunk);
843
844 if (chunk < 0)
845 {
846 /* Some weird shit happened, bail out */
847
848 g_set_error (error,
849 G_SPAWN_ERROR,
850 G_SPAWN_ERROR_FAILED,
851 _("Failed to read from child pipe (%s)"),
852 g_strerror (errno));
853
854 return FALSE;
855 }
856 else if (chunk == 0)
857 break; /* EOF */
858 else
859 bytes += chunk;
860 }
861
862 *n_ints_read = bytes/sizeof(gint);
863
864 return TRUE;
865 }
866
867 static gboolean
868 do_spawn_with_pipes (gboolean dont_wait,
869 gboolean dont_return_handle,
870 const gchar *working_directory,
871 gchar **argv,
872 gchar **envp,
873 gboolean close_descriptors,
874 gboolean search_path,
875 gboolean stdout_to_null,
876 gboolean stderr_to_null,
877 gboolean child_inherits_stdin,
878 gboolean file_and_argv_zero,
879 GSpawnChildSetupFunc child_setup,
880 gpointer user_data,
881 GPid *child_handle,
882 gint *standard_input,
883 gint *standard_output,
884 gint *standard_error,
885 gint *exit_status,
886 GError **error)
887 {
888 gint stdin_pipe[2] = { -1, -1 };
889 gint stdout_pipe[2] = { -1, -1 };
890 gint stderr_pipe[2] = { -1, -1 };
891 gint child_err_report_pipe[2] = { -1, -1 };
892 gint helper = -1;
893 gint buf[2];
894 gint n_ints = 0;
895
896 if (!make_pipe (child_err_report_pipe, error))
897 return FALSE;
898
899 if (standard_input && !make_pipe (stdin_pipe, error))
900 goto cleanup_and_fail;
901
902 if (standard_output && !make_pipe (stdout_pipe, error))
903 goto cleanup_and_fail;
904
905 if (standard_error && !make_pipe (stderr_pipe, error))
906 goto cleanup_and_fail;
907
908 helper = do_spawn (dont_wait,
909 child_err_report_pipe[1],
910 stdin_pipe[0],
911 stdout_pipe[1],
912 stderr_pipe[1],
913 working_directory,
914 argv,
915 envp,
916 close_descriptors,
917 search_path,
918 stdout_to_null,
919 stderr_to_null,
920 child_inherits_stdin,
921 file_and_argv_zero,
922 child_setup,
923 user_data);
924
925 /* Check if gspawn-win32-helper couldn't be run */
926 if (helper == DO_SPAWN_ERROR_HELPER)
927 {
928 g_set_error (error,
929 G_SPAWN_ERROR,
930 G_SPAWN_ERROR_FAILED,
931 _("Failed to execute helper program"));
932 goto cleanup_and_fail;
933 }
934
935 else if (helper == DO_SPAWN_OK_NO_HELPER)
936 {
937 if (child_handle && dont_wait && !dont_return_handle)
938 *child_handle = (GPid) shortcut_spawn_retval;
939 else if (!dont_wait && exit_status)
940 *exit_status = shortcut_spawn_retval;
941
942 close_and_invalidate (&child_err_report_pipe[0]);
943 close_and_invalidate (&child_err_report_pipe[1]);
944
945 return TRUE;
946 }
947 else if (helper == DO_SPAWN_ERROR_NO_HELPER)
948 {
949 g_set_error (error,
950 G_SPAWN_ERROR,
951 G_SPAWN_ERROR_FAILED,
952 _("Failed to execute child process (%s)"),
953 g_strerror (errno));
954 helper = -1;
955 goto cleanup_and_fail;
956 }
957
958 if (!read_ints (child_err_report_pipe[0],
959 buf, 2, &n_ints,
960 error) ||
961 n_ints != 2)
962 goto cleanup_and_fail;
963
964 /* Error code from gspawn-win32-helper. */
965 switch (buf[0])
966 {
967 case CHILD_NO_ERROR:
968 if (child_handle && dont_wait && !dont_return_handle)
969 {
970 /* helper is our HANDLE for gspawn-win32-helper. It has
971 * told us the HANDLE of its child. Duplicate that into
972 * a HANDLE valid in this process.
973 */
974 if (!DuplicateHandle ((HANDLE) helper, (HANDLE) buf[1],
975 GetCurrentProcess (), (LPHANDLE) child_handle,
976 0, TRUE, DUPLICATE_SAME_ACCESS))
977 *child_handle = 0;
978 }
979 else if (child_handle)
980 *child_handle = 0;
981 break;
982
983 case CHILD_CHDIR_FAILED:
984 g_set_error (error,
985 G_SPAWN_ERROR,
986 G_SPAWN_ERROR_CHDIR,
987 _("Failed to change to directory '%s' (%s)"),
988 working_directory,
989 g_strerror (buf[1]));
990 goto cleanup_and_fail;
991
992 case CHILD_SPAWN_FAILED:
993 g_set_error (error,
994 G_SPAWN_ERROR,
995 G_SPAWN_ERROR_FAILED,
996 _("Failed to execute child process (%s)"),
997 g_strerror (buf[1]));
998 goto cleanup_and_fail;
999 }
1000
1001 /* Success against all odds! return the information */
1002
1003 if (standard_input)
1004 *standard_input = stdin_pipe[1];
1005 if (standard_output)
1006 *standard_output = stdout_pipe[0];
1007 if (standard_error)
1008 *standard_error = stderr_pipe[0];
1009 if (exit_status)
1010 *exit_status = buf[1];
1011 CloseHandle ((HANDLE) helper);
1012
1013 close_and_invalidate (&child_err_report_pipe[0]);
1014
1015 return TRUE;
1016
1017 cleanup_and_fail:
1018 if (helper != -1)
1019 CloseHandle ((HANDLE) helper);
1020 close_and_invalidate (&child_err_report_pipe[0]);
1021 close_and_invalidate (&child_err_report_pipe[1]);
1022 close_and_invalidate (&stdin_pipe[0]);
1023 close_and_invalidate (&stdin_pipe[1]);
1024 close_and_invalidate (&stdout_pipe[0]);
1025 close_and_invalidate (&stdout_pipe[1]);
1026 close_and_invalidate (&stderr_pipe[0]);
1027 close_and_invalidate (&stderr_pipe[1]);
1028
1029 return FALSE;
1030 }
1031
1032 static gboolean
1033 make_pipe (gint p[2],
1034 GError **error)
1035 {
1036 if (pipe (p) < 0)
1037 {
1038 g_set_error (error,
1039 G_SPAWN_ERROR,
1040 G_SPAWN_ERROR_FAILED,
1041 _("Failed to create pipe for communicating with child process (%s)"),
1042 g_strerror (errno));
1043 return FALSE;
1044 }
1045 else
1046 return TRUE;
1047 }
1048 #endif /* !GSPAWN_HELPER */
1049
1050 void
1051 g_spawn_close_pid (GPid pid)
1052 {
1053 CloseHandle (pid);
1054 }
glib mirror