2 * spawn.c - this file is part of Geany, a fast and lightweight IDE
4 * Copyright 2013 Dimitar Toshkov Zhekov <dimitar(dot)zhekov(at)gmail(dot)com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program 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
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 /* An ongoing effort to improve the tool spawning situation under Windows.
23 * - There is no g_shell_parse_argv() for windows. It's not hard to write one,
24 * but the command line recreated by mscvrt may be wrong.
25 * - GLib converts the argument vector to UNICODE. For non-UTF8 arguments,
26 * the result is often "Invalid string in argument vector at %d: %s: Invalid
27 * byte sequence in conversion input" (YMMV). Our tools (make, grep, gcc, ...)
28 * are "ANSI", so converting to UNICODE and then back only causes problems.
29 * - For various reasons, GLib uses an intermediate program to start children
30 * (see gspawn-win32.c), the result being that the grandchildren output (such
31 * as make -> gcc) is not captured.
32 * - With non-blocking pipes, the g_io_add_watch() callbacks are never invoked,
33 * while with blocking pipes, g_io_channel_read_line() blocks.
34 * - Some other problems are explained in separate comments below.
36 * Even under Unix, using g_io_channel_read_line() is not a good idea, since it may
37 * buffer lines of unlimited length.
39 * This module does not depend on Geany when compiled for testing (-DSPAWN_TEST).
43 * Portable and convenient process spawning and communication.
56 # include <ctype.h> /* isspace() */
57 # include <fcntl.h> /* _O_RDONLY, _O_WRONLY */
58 # include <io.h> /* _open_osfhandle, _close */
60 #else /* G_OS_WIN32 */
62 #endif /* G_OS_WIN32 */
66 # define GEANY_API_SYMBOL
72 /* Each 4KB under Windows seem to come in 2 portions, so 2K + 2K is more
73 balanced than 4095 + 1. May be different on the latest Windows/glib? */
74 # define DEFAULT_IO_LENGTH 2048
76 # define DEFAULT_IO_LENGTH 4096
78 /* helper function that cuts glib citing of the original text on bad quoting: it may be long,
79 and only the caller knows whether it's UTF-8. Thought we lose the ' or " failed info. */
80 static gboolean
spawn_parse_argv(const gchar
*command_line
, gint
*argcp
, gchar
***argvp
,
83 GError
*gerror
= NULL
;
85 if (g_shell_parse_argv(command_line
, argcp
, argvp
, &gerror
))
88 g_set_error_literal(error
, gerror
->domain
, gerror
->code
,
89 gerror
->code
== G_SHELL_ERROR_BAD_QUOTING
?
90 _("Text ended before matching quote was found") : gerror
->message
);
96 #define G_IO_FAILURE (G_IO_ERR | G_IO_HUP | G_IO_NVAL) /* always used together */
100 * Checks whether a command line is syntactically valid and extracts the program name from it.
102 * See @c spawn_check_command() for details.
104 * @param command_line the command line to check and get the program name from.
105 * @param error return location for error.
107 * @return allocated string with the program name on success, @c NULL on error.
109 static gchar
*spawn_get_program_name(const gchar
*command_line
, GError
**error
)
114 gboolean open_quote
= FALSE
;
115 const gchar
*s
, *arguments
;
117 g_return_val_if_fail(command_line
!= NULL
, FALSE
);
119 while (*command_line
&& strchr(" \t\r\n", *command_line
))
124 g_set_error_literal(error
, G_SHELL_ERROR
, G_SHELL_ERROR_EMPTY_STRING
,
125 /* TL note: from glib */
126 _("Text was empty (or contained only whitespace)"));
130 /* To prevent Windows from doing something weird, we want to be 100% sure that the
131 character after the program name is a delimiter, so we allow space and tab only. */
133 if (*command_line
== '"')
136 /* Windows allows "foo.exe, but we may have extra arguments */
137 if ((s
= strchr(command_line
, '"')) == NULL
)
139 g_set_error_literal(error
, G_SHELL_ERROR
, G_SHELL_ERROR_BAD_QUOTING
,
140 _("Text ended before matching quote was found"));
144 if (!strchr(" \t", s
[1])) /* strchr() catches s[1] == '\0' */
146 g_set_error_literal(error
, G_SHELL_ERROR
, G_SHELL_ERROR_BAD_QUOTING
,
147 _("A quoted Windows program name must be entirely inside the quotes"));
153 const gchar
*quote
= strchr(command_line
, '"');
155 /* strchr() catches *s == '\0', and the for body is empty */
156 for (s
= command_line
; !strchr(" \t", *s
); s
++);
158 if (quote
&& quote
< s
)
160 g_set_error_literal(error
, G_SHELL_ERROR
, G_SHELL_ERROR_BAD_QUOTING
,
161 _("A quoted Windows program name must be entirely inside the quotes"));
166 program
= g_strndup(command_line
, s
- command_line
);
167 arguments
= s
+ (*s
== '"');
169 for (s
= arguments
; *s
; s
++)
175 for (slash
= s
; slash
> arguments
&& slash
[-1] == '\\'; slash
--);
176 if ((s
- slash
) % 2 == 0)
183 g_set_error_literal(error
, G_SHELL_ERROR
, G_SHELL_ERROR_BAD_QUOTING
,
184 _("Text ended before matching quote was found"));
188 #else /* G_OS_WIN32 */
192 if (!spawn_parse_argv(command_line
, &argc
, &argv
, error
))
195 /* empty string results in parse error, so argv[0] is not NULL */
196 program
= g_strdup(argv
[0]);
198 #endif /* G_OS_WIN32 */
205 * Checks whether a command line is valid.
207 * Checks if @a command_line is syntactically valid.
210 * - any leading spaces, tabs and new lines are skipped
211 * - an empty command is invalid
214 * - the standard shell quoting and escaping rules are used, see @c g_shell_parse_argv()
215 * - as a consequence, an unqouted # at the start of an argument comments to the end of line
218 * - leading carriage returns are skipped too
219 * - a quoted program name must be entirely inside the quotes. No "C:\Foo\Bar".pdf or
220 * "C:\Foo\Bar".bat, which would be executed by Windows as `C:\Foo\Bar.exe`
221 * - an unquoted program name may not contain spaces. `Foo Bar Qux` will not be considered
222 * `"Foo Bar.exe" Qux` or `"Foo Bar Qux.exe"`, depending on what executables exist, as
223 * Windows normally does.
224 * - the program name must be separated from the arguments by at least one space or tab
225 * - the standard Windows quoting and escaping rules are used: double quote is escaped with
226 * backslash, and any literal backslashes before a double quote must be duplicated.
228 * If @a execute is TRUE, also checks, using @c g_find_program_in_path(), if the program
229 * specified in @a command_line exists and is executable.
231 * @param command_line the command line to check.
232 * @param execute whether to check if the command line is really executable.
233 * @param error return location for error.
235 * @return @c TRUE on success, @c FALSE on error.
240 gboolean
spawn_check_command(const gchar
*command_line
, gboolean execute
, GError
**error
)
242 gchar
*program
= spawn_get_program_name(command_line
, error
);
249 gchar
*executable
= g_find_program_in_path(program
);
253 g_set_error_literal(error
, G_SHELL_ERROR
, G_SHELL_ERROR_FAILED
,
254 _("Program not found"));
270 * @param pid id of the process to kill.
271 * @param error return location for error.
273 * On Unix, sends a SIGTERM to the process.
275 * On Windows, terminates the process with exit code 255 (used sometimes as "generic"
276 * error code, or for programs terminated with Ctrl+C / Ctrl+Break).
278 * @return @c TRUE on success, @c FALSE on error.
283 gboolean
spawn_kill_process(GPid pid
, GError
**error
)
286 if (!TerminateProcess(pid
, 255))
288 gchar
*message
= g_win32_error_message(GetLastError());
290 g_set_error_literal(error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
, message
);
295 if (kill(pid
, SIGTERM
))
297 g_set_error_literal(error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
, g_strerror(errno
));
306 static gchar
*spawn_create_process_with_pipes(char *command_line
, const char *working_directory
,
307 void *environment
, HANDLE
*hprocess
, int *stdin_fd
, int *stdout_fd
, int *stderr_fd
)
309 enum { WRITE_STDIN
, READ_STDOUT
, READ_STDERR
, READ_STDIN
, WRITE_STDOUT
, WRITE_STDERR
};
311 PROCESS_INFORMATION process
;
312 HANDLE hpipe
[6] = { NULL
, NULL
, NULL
, NULL
, NULL
, NULL
};
313 int *fd
[3] = { stdin_fd
, stdout_fd
, stderr_fd
};
314 const char *failed
; /* failed WIN32/CRTL function, if any */
315 gchar
*message
= NULL
; /* glib WIN32/CTRL error message */
316 gchar
*failure
= NULL
; /* full error text */
320 ZeroMemory(&startup
, sizeof startup
);
321 startup
.cb
= sizeof startup
;
322 pipe_io
= stdin_fd
|| stdout_fd
|| stderr_fd
;
326 startup
.dwFlags
|= STARTF_USESTDHANDLES
;
328 /* not all programs accept mixed NULL and non-NULL hStd*, so we create all */
329 for (i
= 0; i
< 3; i
++)
331 static int pindex
[3][2] = { { READ_STDIN
, WRITE_STDIN
},
332 { READ_STDOUT
, WRITE_STDOUT
}, { READ_STDERR
, WRITE_STDERR
} };
334 if (!CreatePipe(&hpipe
[pindex
[i
][0]], &hpipe
[pindex
[i
][1]], NULL
, 0))
336 hpipe
[pindex
[i
][0]] = hpipe
[pindex
[i
][1]] = NULL
;
337 failed
= "create pipe";
343 static int mode
[3] = { _O_WRONLY
, _O_RDONLY
, _O_RDONLY
};
345 if ((*fd
[i
] = _open_osfhandle((intptr_t) hpipe
[i
], mode
[i
])) == -1)
347 failed
= "convert pipe handle to file descriptor";
348 message
= g_strdup(g_strerror(errno
));
352 else if (!CloseHandle(hpipe
[i
]))
354 failed
= "close pipe";
358 if (!SetHandleInformation(hpipe
[i
+ 3], HANDLE_FLAG_INHERIT
,
359 HANDLE_FLAG_INHERIT
))
361 failed
= "set pipe handle to inheritable";
367 startup
.hStdInput
= hpipe
[READ_STDIN
];
368 startup
.hStdOutput
= hpipe
[WRITE_STDOUT
];
369 startup
.hStdError
= hpipe
[WRITE_STDERR
];
371 if (!CreateProcess(NULL
, command_line
, NULL
, NULL
, TRUE
, pipe_io
? CREATE_NO_WINDOW
: 0,
372 environment
, working_directory
, &startup
, &process
))
374 failed
= ""; /* report the message only */
375 /* further errors will not be reported */
380 CloseHandle(process
.hThread
); /* we don't need this */
383 *hprocess
= process
.hProcess
;
385 CloseHandle(process
.hProcess
);
395 message
= g_win32_error_message(GetLastError());
396 len
= strlen(message
);
398 /* unlike g_strerror(), the g_win32_error messages may include a final '.' */
399 if (len
> 0 && message
[len
- 1] == '.')
400 message
[len
- 1] = '\0';
407 failure
= g_strdup_printf("Failed to %s (%s)", failed
, message
);
414 for (i
= 0; i
< 3; i
++)
418 if (fd
[i
] && *fd
[i
] != -1)
421 CloseHandle(hpipe
[i
]);
425 CloseHandle(hpipe
[i
+ 3]);
433 static void spawn_append_argument(GString
*command
, const char *text
)
438 g_string_append_c(command
, ' ');
440 for (s
= text
; *s
; s
++)
442 /* g_ascii_isspace() fails for '\v', and locale spaces (if any) will do no harm */
443 if (*s
== '"' || isspace(*s
))
448 g_string_append(command
, text
);
451 g_string_append_c(command
, '"');
453 for (s
= text
; *s
; s
++)
457 for (slash
= s
; *slash
== '\\'; slash
++);
461 g_string_append_len(command
, s
, slash
- s
);
463 if (!*slash
|| *slash
== '"')
465 g_string_append_len(command
, s
, slash
- s
);
475 g_string_append_c(command
, '\\');
477 g_string_append_c(command
, *s
);
480 g_string_append_c(command
, '"');
483 #endif /* G_OS_WIN32 */
487 * Executes a child program asynchronously and setups pipes.
489 * This is the low-level spawning function. Please use @c spawn_with_callbacks() unless
490 * you need to setup specific event source(s).
492 * A command line or an argument vector must be passed. If both are present, the argument
493 * vector is appended to the command line. An empty command line is not allowed.
495 * Under Windows, if the child is a console application, and at least one file descriptor is
496 * specified, the new child console (if any) will be hidden.
498 * If a @a child_pid is passed, it's your responsibility to invoke @c g_spawn_close_pid().
500 * @param working_directory child's current working directory, or @c NULL.
501 * @param command_line child program and arguments, or @c NULL.
502 * @param argv child's argument vector, or @c NULL.
503 * @param envp child's environment, or @c NULL.
504 * @param child_pid return location for child process ID, or @c NULL.
505 * @param stdin_fd return location for file descriptor to write to child's stdin, or @c NULL.
506 * @param stdout_fd return location for file descriptor to read child's stdout, or @c NULL.
507 * @param stderr_fd return location for file descriptor to read child's stderr, or @c NULL.
508 * @param error return location for error.
510 * @return @c TRUE on success, @c FALSE on error.
512 static gboolean
spawn_async_with_pipes(const gchar
*working_directory
, const gchar
*command_line
,
513 gchar
**argv
, gchar
**envp
, GPid
*child_pid
, gint
*stdin_fd
, gint
*stdout_fd
,
514 gint
*stderr_fd
, GError
**error
)
516 g_return_val_if_fail(command_line
!= NULL
|| argv
!= NULL
, FALSE
);
525 gchar
*program
= spawn_get_program_name(command_line
, error
);
526 const gchar
*arguments
;
531 command
= g_string_new(NULL
);
532 arguments
= strstr(command_line
, program
) + strlen(program
);
534 if (*arguments
== '"')
536 g_string_append(command
, program
);
541 /* quote the first token, to avoid Windows attemps to run two or more
542 unquoted tokens as a program until an existing file name is found */
543 g_string_printf(command
, "\"%s\"", program
);
546 g_string_append(command
, arguments
);
550 command
= g_string_new(NULL
);
552 environment
= g_array_new(TRUE
, FALSE
, sizeof(char));
554 while (argv
&& *argv
)
555 spawn_append_argument(command
, *argv
++);
558 g_message("full spawn command line: %s\n", command
->str
);
561 while (envp
&& *envp
)
563 g_array_append_vals(environment
, *envp
, strlen(*envp
) + 1);
567 failure
= spawn_create_process_with_pipes(command
->str
, working_directory
,
568 envp
? environment
->data
: NULL
, child_pid
, stdin_fd
, stdout_fd
, stderr_fd
);
570 g_string_free(command
, TRUE
);
571 g_array_free(environment
, TRUE
);
575 g_set_error_literal(error
, G_SPAWN_ERROR
, G_SPAWN_ERROR_FAILED
, failure
);
581 #else /* G_OS_WIN32 */
585 GError
*gerror
= NULL
;
592 if (!spawn_parse_argv(command_line
, &cl_argc
, &cl_argv
, error
))
596 for (argc
= 0; argv
[argc
]; argc
++);
598 full_argv
= g_renew(gchar
*, cl_argv
, cl_argc
+ argc
+ 1);
599 memcpy(full_argv
+ cl_argc
, argv
, argc
* sizeof(gchar
*));
600 full_argv
[cl_argc
+ argc
] = NULL
;
605 spawned
= g_spawn_async_with_pipes(working_directory
, full_argv
, envp
,
606 G_SPAWN_SEARCH_PATH
| (child_pid
? G_SPAWN_DO_NOT_REAP_CHILD
: 0), NULL
, NULL
,
607 child_pid
, stdin_fd
, stdout_fd
, stderr_fd
, &gerror
);
612 const gchar
*message
= gerror
->message
;
614 /* try to cut glib citing of the program name or working directory: they may be long,
615 and only the caller knows whether they're UTF-8. We lose the exact chdir error. */
616 switch (gerror
->code
)
619 case G_SPAWN_ERROR_ACCES
: en
= EACCES
; break;
622 case G_SPAWN_ERROR_PERM
: en
= EPERM
; break;
625 case G_SPAWN_ERROR_TOO_BIG
: en
= E2BIG
; break;
628 case G_SPAWN_ERROR_NOEXEC
: en
= ENOEXEC
; break;
631 case G_SPAWN_ERROR_NAMETOOLONG
: en
= ENAMETOOLONG
; break;
634 case G_SPAWN_ERROR_NOENT
: en
= ENOENT
; break;
637 case G_SPAWN_ERROR_NOMEM
: en
= ENOMEM
; break;
640 case G_SPAWN_ERROR_NOTDIR
: en
= ENOTDIR
; break;
643 case G_SPAWN_ERROR_LOOP
: en
= ELOOP
; break;
646 case G_SPAWN_ERROR_TXTBUSY
: en
= ETXTBUSY
; break;
649 case G_SPAWN_ERROR_IO
: en
= EIO
; break;
652 case G_SPAWN_ERROR_NFILE
: en
= ENFILE
; break;
655 case G_SPAWN_ERROR_MFILE
: en
= EMFILE
; break;
658 case G_SPAWN_ERROR_INVAL
: en
= EINVAL
; break;
661 case G_SPAWN_ERROR_ISDIR
: en
= EISDIR
; break;
664 case G_SPAWN_ERROR_LIBBAD
: en
= ELIBBAD
; break;
666 case G_SPAWN_ERROR_CHDIR
:
668 message
= _("Failed to change to the working directory");
671 case G_SPAWN_ERROR_FAILED
:
673 message
= _("Unknown error executing child process");
679 message
= g_strerror(en
);
681 g_set_error_literal(error
, gerror
->domain
, gerror
->code
, message
);
682 g_error_free(gerror
);
685 if (full_argv
!= argv
)
687 full_argv
[cl_argc
] = NULL
;
688 g_strfreev(full_argv
);
692 #endif /* G_OS_WIN32 */
697 * Executes a child asynchronously.
699 * A command line or an argument vector must be passed. If both are present, the argument
700 * vector is appended to the command line. An empty command line is not allowed.
702 * If a @a child_pid is passed, it's your responsibility to invoke @c g_spawn_close_pid().
704 * @param working_directory child's current working directory, or @c NULL.
705 * @param command_line child program and arguments, or @c NULL.
706 * @param argv child's argument vector, or @c NULL.
707 * @param envp child's environment, or @c NULL.
708 * @param child_pid return location for child process ID, or @c NULL.
709 * @param error return location for error.
711 * @return @c TRUE on success, @c FALSE on error.
716 gboolean
spawn_async(const gchar
*working_directory
, const gchar
*command_line
, gchar
**argv
,
717 gchar
**envp
, GPid
*child_pid
, GError
**error
)
719 return spawn_async_with_pipes(working_directory
, command_line
, argv
, envp
, child_pid
,
720 NULL
, NULL
, NULL
, error
);
725 * Spawn with callbacks - general event sequence:
727 * - Launch the child.
728 * - Setup any I/O callbacks and a child watch callback.
729 * - On sync execution, run a main loop.
730 * - Wait for the child to terminate.
731 * - Check for active I/O sources. If any, add a timeout source to watch them, they should
732 * become inactive real soon now that the child is dead. Otherwise, finalize immediately.
733 * - In the timeout source: check for active I/O sources and finalize if none.
736 typedef struct _SpawnChannelData
738 GIOChannel
*channel
; /* NULL if not created / already destroyed */
745 /* stdout/stderr only */
746 GString
*buffer
; /* NULL if recursive */
747 GString
*line_buffer
; /* NULL if char buffered */
752 static void spawn_destroy_cb(gpointer data
)
754 SpawnChannelData
*sc
= (SpawnChannelData
*) data
;
756 g_io_channel_shutdown(sc
->channel
, FALSE
, NULL
);
760 g_string_free(sc
->buffer
, TRUE
);
763 g_string_free(sc
->line_buffer
, TRUE
);
767 static gboolean
spawn_write_cb(GIOChannel
*channel
, GIOCondition condition
, gpointer data
)
769 SpawnChannelData
*sc
= (SpawnChannelData
*) data
;
771 if (!sc
->cb
.write(channel
, condition
, sc
->cb_data
))
774 return !(condition
& G_IO_FAILURE
);
778 static gboolean
spawn_read_cb(GIOChannel
*channel
, GIOCondition condition
, gpointer data
)
780 SpawnChannelData
*sc
= (SpawnChannelData
*) data
;
781 GString
*line_buffer
= sc
->line_buffer
;
782 GString
*buffer
= sc
->buffer
? sc
->buffer
: g_string_sized_new(sc
->max_length
);
783 GIOCondition input_cond
= condition
& (G_IO_IN
| G_IO_PRI
);
784 GIOCondition failure_cond
= condition
& G_IO_FAILURE
;
786 * - Normally, read only once. With IO watches, our data processing must be immediate,
787 * which may give the child time to emit more data, and a read loop may combine it into
788 * large stdout and stderr portions. Under Windows, looping blocks.
789 * - On failure, read in a loop. It won't block now, there will be no more data, and the
790 * IO watch is not guaranteed to be called again (under Windows this is the last call).
799 gsize n
= line_buffer
->len
;
801 while ((status
= g_io_channel_read_chars(channel
, line_buffer
->str
+ n
,
802 DEFAULT_IO_LENGTH
, &chars_read
, NULL
)) == G_IO_STATUS_NORMAL
)
804 g_string_set_size(line_buffer
, n
+ chars_read
);
806 while (n
< line_buffer
->len
)
810 if (n
== sc
->max_length
)
812 else if (strchr("\n", line_buffer
->str
[n
])) /* '\n' or '\0' */
814 else if (n
< line_buffer
->len
- 1 && line_buffer
->str
[n
] == '\r')
815 line_len
= n
+ 1 + (line_buffer
->str
[n
+ 1] == '\n');
821 g_string_append_len(buffer
, line_buffer
->str
, line_len
);
822 g_string_erase(line_buffer
, 0, line_len
);
823 /* input only, failures are reported separately below */
824 sc
->cb
.read(buffer
, input_cond
, sc
->cb_data
);
825 g_string_truncate(buffer
, 0);
836 while ((status
= g_io_channel_read_chars(channel
, buffer
->str
, sc
->max_length
,
837 &chars_read
, NULL
)) == G_IO_STATUS_NORMAL
)
839 g_string_set_size(buffer
, chars_read
);
840 /* input only, failures are reported separately below */
841 sc
->cb
.read(buffer
, input_cond
, sc
->cb_data
);
848 /* Under OSX, after child death, the read watches receive input conditions instead
849 of error conditions, so we convert the termination statuses into conditions.
850 Should not hurt the other OS. */
851 if (status
== G_IO_STATUS_ERROR
)
852 failure_cond
|= G_IO_ERR
;
853 else if (status
== G_IO_STATUS_EOF
)
854 failure_cond
|= G_IO_HUP
;
857 if (failure_cond
) /* we must signal the callback */
859 if (line_buffer
&& line_buffer
->len
) /* flush the line buffer */
861 g_string_append_len(buffer
, line_buffer
->str
, line_buffer
->len
);
862 /* all data may be from a previous call */
864 input_cond
= G_IO_IN
;
869 g_string_truncate(buffer
, 0);
872 sc
->cb
.read(buffer
, input_cond
| failure_cond
, sc
->cb_data
);
875 if (buffer
!= sc
->buffer
)
876 g_string_free(buffer
, TRUE
);
878 return !failure_cond
;
882 typedef struct _SpawnWatcherData
884 SpawnChannelData sc
[3]; /* stdin, stdout, stderr */
885 GChildWatchFunc exit_cb
;
889 GMainContext
*main_context
; /* NULL if async execution */
890 GMainLoop
*main_loop
; /* NULL if async execution */
894 static void spawn_finalize(SpawnWatcherData
*sw
)
897 sw
->exit_cb(sw
->pid
, sw
->exit_status
, sw
->exit_data
);
901 g_main_loop_quit(sw
->main_loop
);
902 g_main_loop_unref(sw
->main_loop
);
905 g_spawn_close_pid(sw
->pid
);
906 g_slice_free(SpawnWatcherData
, sw
);
910 static gboolean
spawn_timeout_cb(gpointer data
)
912 SpawnWatcherData
*sw
= (SpawnWatcherData
*) data
;
915 for (i
= 0; i
< 3; i
++)
916 if (sw
->sc
[i
].channel
)
924 static void spawn_watch_cb(GPid pid
, gint status
, gpointer data
)
926 SpawnWatcherData
*sw
= (SpawnWatcherData
*) data
;
930 sw
->exit_status
= status
;
932 for (i
= 0; i
< 3; i
++)
934 if (sw
->sc
[i
].channel
)
936 GSource
*source
= g_timeout_source_new(50);
938 g_source_set_callback(source
, spawn_timeout_cb
, data
, NULL
);
939 g_source_attach(source
, sw
->main_context
);
940 g_source_unref(source
);
950 * Executes a child program and setups callbacks.
952 * A command line or an argument vector must be passed. If both are present, the argument
953 * vector is appended to the command line. An empty command line is not allowed.
955 * The synchronous execution may not be combined with recursive callbacks.
957 * In line buffered mode, the child input is broken on `\n`, `\r\n`, `\r`, `\0` and max length.
959 * All I/O callbacks are guaranteed to be invoked at least once with @c G_IO_ERR, @c G_IO_HUP
960 * or @c G_IO_NVAL set (except for a @a stdin_cb which returns @c FALSE before that). For the
961 * non-recursive callbacks, this is guaranteed to be the last call, and may be used to free any
962 * resources associated with the callback.
964 * The @a stdin_cb may write to @c channel only once per invocation, only if @c G_IO_OUT is
965 * set, and only a non-zero number of characters.
967 * @c stdout_cb and @c stderr_cb may modify the received strings in any way, but must not
970 * The default max lengths are 24K for line buffered stdout, 8K for line buffered stderr,
971 * 4K for unbuffered input under Unix, and 2K for unbuffered input under Windows.
973 * @c exit_cb is always invoked last, after all I/O callbacks.
975 * The @a child_pid will be closed automatically, after @a exit_cb is invoked.
977 * @param working_directory child's current working directory, or @c NULL.
978 * @param command_line child program and arguments, or @c NULL.
979 * @param argv child's argument vector, or @c NULL.
980 * @param envp child's environment, or @c NULL.
981 * @param spawn_flags flags from SpawnFlags.
982 * @param stdin_cb callback to send data to childs's stdin, or @c NULL.
983 * @param stdin_data data to pass to @a stdin_cb.
984 * @param stdout_cb callback to receive child's stdout, or @c NULL.
985 * @param stdout_data data to pass to @a stdout_cb.
986 * @param stdout_max_length maximum data length to pass to stdout_cb, @c 0 = default.
987 * @param stderr_cb callback to receive child's stderr, or @c NULL.
988 * @param stderr_data data to pass to @a stderr_cb.
989 * @param stderr_max_length maximum data length to pass to stderr_cb, @c 0 = default.
990 * @param exit_cb callback to invoke when the child exits, or @c NULL.
991 * @param exit_data data to pass to @a exit_cb.
992 * @param child_pid return location for child process ID, or @c NULL.
993 * @param error return location for error.
995 * @return @c TRUE on success, @c FALSE on error.
1000 gboolean
spawn_with_callbacks(const gchar
*working_directory
, const gchar
*command_line
,
1001 gchar
**argv
, gchar
**envp
, SpawnFlags spawn_flags
, GIOFunc stdin_cb
, gpointer stdin_data
,
1002 SpawnReadFunc stdout_cb
, gpointer stdout_data
, gsize stdout_max_length
,
1003 SpawnReadFunc stderr_cb
, gpointer stderr_data
, gsize stderr_max_length
,
1004 GChildWatchFunc exit_cb
, gpointer exit_data
, GPid
*child_pid
, GError
**error
)
1007 int pipe
[3] = { -1, -1, -1 };
1009 g_return_val_if_fail(!(spawn_flags
& SPAWN_RECURSIVE
) || !(spawn_flags
& SPAWN_SYNC
),
1012 if (spawn_async_with_pipes(working_directory
, command_line
, argv
, envp
, &pid
,
1013 stdin_cb
? &pipe
[0] : NULL
, stdout_cb
? &pipe
[1] : NULL
,
1014 stderr_cb
? &pipe
[2] : NULL
, error
))
1016 SpawnWatcherData
*sw
= g_slice_new0(SpawnWatcherData
);
1017 gpointer cb_data
[3] = { stdin_data
, stdout_data
, stderr_data
};
1021 sw
->main_context
= spawn_flags
& SPAWN_SYNC
? g_main_context_new() : NULL
;
1026 for (i
= 0; i
< 3; i
++)
1028 SpawnChannelData
*sc
= &sw
->sc
[i
];
1029 GIOCondition condition
;
1030 GSourceFunc callback
;
1036 sc
->channel
= g_io_channel_win32_new_fd(pipe
[i
]);
1038 sc
->channel
= g_io_channel_unix_new(pipe
[i
]);
1039 g_io_channel_set_flags(sc
->channel
, G_IO_FLAG_NONBLOCK
, NULL
);
1041 g_io_channel_set_encoding(sc
->channel
, NULL
, NULL
);
1042 /* we have our own buffers, and GIO buffering blocks under Windows */
1043 g_io_channel_set_buffered(sc
->channel
, FALSE
);
1044 sc
->cb_data
= cb_data
[i
];
1048 sc
->cb
.write
= stdin_cb
;
1049 condition
= G_IO_OUT
| G_IO_FAILURE
;
1050 callback
= (GSourceFunc
) spawn_write_cb
;
1054 gboolean line_buffered
= !(spawn_flags
&
1055 ((SPAWN_STDOUT_UNBUFFERED
>> 1) << i
));
1057 condition
= G_IO_IN
| G_IO_PRI
| G_IO_FAILURE
;
1058 callback
= (GSourceFunc
) spawn_read_cb
;
1062 sc
->cb
.read
= stdout_cb
;
1063 sc
->max_length
= stdout_max_length
? stdout_max_length
:
1064 line_buffered
? 24576 : DEFAULT_IO_LENGTH
;
1068 sc
->cb
.read
= stderr_cb
;
1069 sc
->max_length
= stderr_max_length
? stderr_max_length
:
1070 line_buffered
? 8192 : DEFAULT_IO_LENGTH
;
1075 sc
->line_buffer
= g_string_sized_new(sc
->max_length
+
1080 source
= g_io_create_watch(sc
->channel
, condition
);
1081 g_io_channel_unref(sc
->channel
);
1083 if (spawn_flags
& (SPAWN_STDIN_RECURSIVE
<< i
))
1084 g_source_set_can_recurse(source
, TRUE
);
1085 else if (i
) /* to avoid new string on each call */
1086 sc
->buffer
= g_string_sized_new(sc
->max_length
);
1088 g_source_set_callback(source
, callback
, sc
, spawn_destroy_cb
);
1089 g_source_attach(source
, sw
->main_context
);
1090 g_source_unref(source
);
1093 sw
->exit_cb
= exit_cb
;
1094 sw
->exit_data
= exit_data
;
1095 source
= g_child_watch_source_new(pid
);
1096 g_source_set_callback(source
, (GSourceFunc
) spawn_watch_cb
, sw
, NULL
);
1097 g_source_attach(source
, sw
->main_context
);
1098 g_source_unref(source
);
1100 if (spawn_flags
& SPAWN_SYNC
)
1102 sw
->main_loop
= g_main_loop_new(sw
->main_context
, FALSE
);
1103 g_main_context_unref(sw
->main_context
);
1104 g_main_loop_run(sw
->main_loop
);
1115 * Writes (a portion of) the data pointed by @a data->ptr to the @a channel.
1117 * If @c G_IO_OUT in @a condition is set, and the @a data->size is > 0, attempts to write
1118 * @a data->ptr (or a portion of it, depending on the size) to the @a channel. On success,
1119 * increases ptr and decreases size with the number of characters written.
1121 * This function may converted to @c GIOFunc and passed to @c spawn_with_callbacks() as
1122 * @c stdin_cb, together with a @c SpawnWriteData for @c stdin_data. As with any other
1123 * callback data, make sure that @c stdin_data exists while the child is being executed.
1124 * (For example, on asynchronous execution, you can allocate the data in the heap, and free
1125 * it in your @c spawn_with_callbacks() @c exit_cb callback.)
1127 * @param channel the channel to write data to.
1128 * @param condition condition to check for @c G_IO_OUT.
1129 * @param data @c SpawnWriteData to write to @a channel.
1131 * @return @c TRUE if the remaining size is > 0 and @a condition does not indicate any error,
1132 * @c FALSE otherwise.
1137 gboolean
spawn_write_data(GIOChannel
*channel
, GIOCondition condition
, SpawnWriteData
*data
)
1139 if ((condition
& G_IO_OUT
) && data
->size
)
1141 gsize chars_written
= 0;
1143 g_io_channel_write_chars(channel
, data
->ptr
, data
->size
< DEFAULT_IO_LENGTH
?
1144 data
->size
: DEFAULT_IO_LENGTH
, &chars_written
, NULL
);
1146 /* "This can be nonzero even if the return value is not G_IO_STATUS_NORMAL." */
1149 data
->ptr
+= chars_written
;
1150 data
->size
-= chars_written
;
1154 return data
->size
> 0 && !(condition
& G_IO_FAILURE
);
1158 static void spawn_append_gstring_cb(GString
*string
, GIOCondition condition
, gpointer data
)
1160 if (condition
& (G_IO_IN
| G_IO_PRI
))
1161 g_string_append_len((GString
*) data
, string
->str
, string
->len
);
1165 static void spawn_get_exit_status_cb(G_GNUC_UNUSED GPid pid
, gint status
, gpointer exit_status
)
1167 *(gint
*) exit_status
= status
;
1172 * Executes a child synchronously.
1174 * A command line or an argument vector must be passed. If both are present, the argument
1175 * vector is appended to the command line. An empty command line is not allowed.
1177 * The @a stdin_data is sent to the child with @c spawn_write_data().
1179 * All output from the child, including the nul characters, is stored in @a stdout_data and
1180 * @a stderr_data (if non-NULL). Any existing data in these strings will be erased.
1182 * @param working_directory child's current working directory, or @c NULL.
1183 * @param command_line child program and arguments, or @c NULL.
1184 * @param argv child's argument vector, or @c NULL.
1185 * @param envp child's environment, or @c NULL.
1186 * @param stdin_data data to send to childs's stdin, or @c NULL.
1187 * @param stdout_data GString location to receive the child's stdout, or NULL.
1188 * @param stderr_data GString location to receive the child's stderr, or NULL.
1189 * @param exit_status return location for the child exit code, or NULL.
1190 * @param error return location for error.
1192 * @return @c TRUE on success, @c FALSE on error.
1197 gboolean
spawn_sync(const gchar
*working_directory
, const gchar
*command_line
, gchar
**argv
,
1198 gchar
**envp
, SpawnWriteData
*stdin_data
, GString
*stdout_data
, GString
*stderr_data
,
1199 gint
*exit_status
, GError
**error
)
1201 g_string_truncate(stdout_data
, 0);
1202 g_string_truncate(stderr_data
, 0);
1204 return spawn_with_callbacks(working_directory
, command_line
, argv
, envp
, SPAWN_SYNC
|
1205 SPAWN_UNBUFFERED
, stdin_data
? (GIOFunc
) spawn_write_data
: NULL
, stdin_data
,
1206 stdout_data
? spawn_append_gstring_cb
: NULL
, stdout_data
, 0,
1207 stderr_data
? spawn_append_gstring_cb
: NULL
, stderr_data
, 0,
1208 exit_status
? spawn_get_exit_status_cb
: NULL
, exit_status
, NULL
, error
);
1212 /* tests, not part of the API */
1217 static gboolean
read_line(const char *prompt
, char *buffer
, size_t size
)
1219 fputs(prompt
, stderr
);
1222 if (fgets(buffer
, size
, stdin
))
1224 char *s
= strchr(buffer
, '\n');
1234 static GString
*read_string(const char *prompt
)
1236 char buffer
[0x1000]; /* larger portions for spawn < file */
1237 GString
*string
= g_string_sized_new(sizeof buffer
);
1239 while (read_line(prompt
, buffer
, sizeof buffer
))
1242 g_string_append_c(string
, '\n');
1244 g_string_append(string
, buffer
);
1249 g_string_free(string
, TRUE
);
1257 static void print_cb(GString
*string
, GIOCondition condition
, gpointer data
)
1259 if (condition
& (G_IO_IN
| G_IO_PRI
))
1263 printf("%s: ", (const gchar
*) data
);
1264 /*fputs(string->str, stdout);*/
1265 for (i
= 0; i
< string
->len
; i
++)
1267 unsigned char c
= (unsigned char) string
->str
[i
];
1268 printf(c
>= ' ' && c
< 0x80 ? "%c" : "\\x%02x", c
);
1275 static void print_status(gint status
)
1277 fputs("finished, ", stderr
);
1279 if (SPAWN_WIFEXITED(status
))
1280 fprintf(stderr
, "exit code %d\n", SPAWN_WEXITSTATUS(status
));
1282 fputs("abnormal termination\n", stderr
);
1286 static void exit_cb(GPid pid
, gint status
, G_GNUC_UNUSED gpointer data
)
1288 fprintf(stderr
, "process %u ", (guint
) pid
);
1289 print_status(status
);
1293 static void watch_cb(GPid pid
, gint status
, gpointer data
)
1295 g_spawn_close_pid(pid
);
1296 exit_cb(pid
, status
, NULL
);
1297 g_main_loop_quit((GMainLoop
*) data
);
1301 int main(int argc
, char **argv
)
1307 fputs("usage: spawn <test-type>\n", stderr
);
1311 test_type
= argv
[1];
1313 if (!strcmp(test_type
, "syntax") || !strcmp(test_type
, "syntexec"))
1315 char command_line
[0x100];
1317 while (read_line("command line: ", command_line
, sizeof command_line
))
1319 GError
*error
= NULL
;
1321 if (spawn_check_command(command_line
, argv
[1][4] == 'e', &error
))
1322 fputs("valid\n", stderr
);
1325 fprintf(stderr
, "error: %s\n", error
->message
);
1326 g_error_free(error
);
1330 else if (!strcmp(test_type
, "execute"))
1332 char command_line
[0x100];
1334 while (read_line("command line: ", command_line
, sizeof command_line
))
1336 char working_directory
[0x100];
1337 char args
[4][0x100];
1338 char envs
[4][0x100];
1339 char *argv
[] = { args
[0], args
[1], args
[2], args
[3], NULL
};
1340 char *envp
[] = { envs
[0], envs
[1], envs
[2], envs
[3], NULL
};
1343 GError
*error
= NULL
;
1345 read_line("working directory: ", working_directory
, sizeof working_directory
);
1347 fputs("up to 4 arguments\n", stderr
);
1348 for (i
= 0; i
< 4 && read_line("argument: ", args
[i
], sizeof args
[i
]); i
++);
1351 fputs("up to 4 variables, or empty line for parent environment\n", stderr
);
1352 for (i
= 0; i
< 4 && read_line("variable: ", envs
[i
], sizeof envs
[i
]); i
++);
1355 if (spawn_async_with_pipes(*working_directory
? working_directory
: NULL
,
1356 *command_line
? command_line
: NULL
, argv
, i
? envp
: NULL
, &pid
, NULL
,
1357 NULL
, NULL
, &error
))
1359 GMainLoop
*loop
= g_main_loop_new(NULL
, TRUE
);
1361 g_child_watch_add(pid
, watch_cb
, loop
);
1362 g_main_loop_run(loop
);
1363 g_main_loop_unref(loop
);
1367 fprintf(stderr
, "error: %s\n", error
->message
);
1368 g_error_free(error
);
1372 else if (!strcmp(test_type
, "redirect") || !strcmp(test_type
, "redinput"))
1374 char command_line
[0x100];
1375 gboolean output
= test_type
[4] == 'r';
1377 while (read_line("command line: ", command_line
, sizeof command_line
))
1379 GString
*stdin_text
= read_string("text to send: ");
1380 SpawnWriteData stdin_data
;
1381 GError
*error
= NULL
;
1385 stdin_data
.ptr
= stdin_text
->str
;
1386 stdin_data
.size
= stdin_text
->len
;
1389 if (!spawn_with_callbacks(NULL
, command_line
, NULL
, NULL
, SPAWN_SYNC
,
1390 stdin_text
? (GIOFunc
) spawn_write_data
: NULL
, &stdin_data
,
1391 output
? print_cb
: NULL
, "stdout", 0, output
? print_cb
: NULL
,
1392 "stderr", 0, exit_cb
, NULL
, NULL
, &error
))
1394 fprintf(stderr
, "error: %s\n", error
->message
);
1395 g_error_free(error
);
1399 g_string_free(stdin_text
, TRUE
);
1402 else if (!strcmp(test_type
, "capture"))
1404 char command_line
[0x100];
1406 while (read_line("command line: ", command_line
, sizeof command_line
))
1408 GString
*stdin_text
= read_string("text to send: ");
1409 SpawnWriteData stdin_data
= { NULL
, 0 };
1410 GString
*stdout_data
= g_string_sized_new(0x10000); /* may grow */
1411 GString
*stderr_data
= g_string_sized_new(0x1000); /* may grow */
1413 GError
*error
= NULL
;
1417 stdin_data
.ptr
= stdin_text
->str
;
1418 stdin_data
.size
= stdin_text
->len
;
1421 if (spawn_sync(NULL
, command_line
, NULL
, NULL
, &stdin_data
, stdout_data
,
1422 stderr_data
, &exit_status
, &error
))
1424 printf("stdout: %s\n", stdout_data
->str
);
1425 printf("stderr: %s\n", stderr_data
->str
);
1426 print_status(exit_status
);
1430 fprintf(stderr
, "error: %s\n", error
->message
);
1431 g_error_free(error
);
1435 g_string_free(stdin_text
, TRUE
);
1437 g_string_free(stdout_data
, TRUE
);
1438 g_string_free(stderr_data
, TRUE
);
1443 fprintf(stderr
, "spawn: unknown test type '%s'", argv
[1]);
1449 #endif /* SPAWN_TEST */