glibmm: Spawning Processes

Process launching with fork()/exec(). More...

Classes

class  Glib::SpawnError
 Exception class for errors occuring when spawning processes. More...

 

Typedefs

using Glib::SlotSpawnChildSetup = sigc::slot< void()>
 For instance,

void on_child_setup();. More...

 

Enumerations

enum  Glib::SpawnError::Code {

  Glib::SpawnError::FORK,

  Glib::SpawnError::READ,

  Glib::SpawnError::CHDIR,

  Glib::SpawnError::ACCES,

  Glib::SpawnError::PERM,

  Glib::SpawnError::TOO_BIG,

  Glib::SpawnError::TOOBIG = TOO_BIG,

  Glib::SpawnError::NOEXEC,

  Glib::SpawnError::NAMETOOLONG,

  Glib::SpawnError::NOENT,

  Glib::SpawnError::NOMEM,

  Glib::SpawnError::NOTDIR,

  Glib::SpawnError::LOOP,

  Glib::SpawnError::TXTBUSY,

  Glib::SpawnError::IO,

  Glib::SpawnError::NFILE,

  Glib::SpawnError::MFILE,

  Glib::SpawnError::INVAL,

  Glib::SpawnError::ISDIR,

  Glib::SpawnError::LIBBAD,

  Glib::SpawnError::FAILED

}
 Error codes returned by spawning processes. More...

 

Functions

void Glib::spawn_async_with_pipes (const std::string& working_directory, const Glib::ArrayHandle< std::string >& argv, const Glib::ArrayHandle< std::string >& envp, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup& child_setup=SlotSpawnChildSetup(), Pid* child_pid=nullptr, int* standard_input=nullptr, int* standard_output=nullptr, int* standard_error=nullptr)
 Executes a child program asynchronously (your program will not block waiting for the child to exit). More...

 
void Glib::spawn_async_with_pipes (const std::string& working_directory, const Glib::ArrayHandle< std::string >& argv, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup& child_setup=SlotSpawnChildSetup(), Pid* child_pid=nullptr, int* standard_input=nullptr, int* standard_output=nullptr, int* standard_error=nullptr)
 Like the main spawn_async_with_pipes() method, but inheriting the parent's environment. More...

 
void Glib::spawn_async (const std::string& working_directory, const Glib::ArrayHandle< std::string >& argv, const Glib::ArrayHandle< std::string >& envp, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup& child_setup=SlotSpawnChildSetup(), Pid* child_pid=nullptr)
 See spawn_async_with_pipes() for a full description. More...

 
void Glib::spawn_async (const std::string& working_directory, const Glib::ArrayHandle< std::string >& argv, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup& child_setup=SlotSpawnChildSetup(), Pid* child_pid=nullptr)
 Like the main spawn_async() method, but inheriting the parent's environment. More...

 
void Glib::spawn_sync (const std::string& working_directory, const Glib::ArrayHandle< std::string >& argv, const Glib::ArrayHandle< std::string >& envp, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup& child_setup=SlotSpawnChildSetup(), std::string* standard_output=nullptr, std::string* standard_error=nullptr, int* exit_status=nullptr)
 Executes a child synchronously (waits for the child to exit before returning). More...

 
void Glib::spawn_sync (const std::string& working_directory, const Glib::ArrayHandle< std::string >& argv, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup& child_setup=SlotSpawnChildSetup(), std::string* standard_output=nullptr, std::string* standard_error=nullptr, int* exit_status=nullptr)
 Like the main spawn_sync() method, but inheriting the parent's environment. More...

 
void Glib::spawn_command_line_async (const std::string& command_line)
 A simple version of spawn_async() that parses a command line with shell_parse_argv() and passes it to spawn_async(). More...

 
void Glib::spawn_command_line_sync (const std::string& command_line, std::string* standard_output=nullptr, std::string* standard_error=nullptr, int* exit_status=nullptr)
 A simple version of spawn_sync() with little-used parameters removed, taking a command line instead of an argument vector. More...

 
void Glib::spawn_close_pid (Pid pid)
 On some platforms, notably WIN32, the Pid type represents a resource which must be closed to prevent resource leaking. More...

 

Detailed Description

Process launching with fork()/exec().

Typedef Documentation

using Glib::SlotSpawnChildSetup = typedef sigc::slot<void()>

For instance,

void on_child_setup();.

Enumeration Type Documentation

Error codes returned by spawning processes.

Enumerator
FORK 

Fork failed due to lack of memory.

READ 

Read or select on pipes failed.

CHDIR 

Changing to working directory failed.

ACCES 

Execv() returned EACCES.

PERM 

Execv() returned EPERM.

TOO_BIG 

Execv() returned E2BIG.

TOOBIG 

Deprecated alias for SPAWN_ERROR_TOO_BIG.

NOEXEC 

Execv() returned ENOEXEC.

NAMETOOLONG 

Execv() returned ENAMETOOLONG.

NOENT 

Execv() returned ENOENT.

NOMEM 

Execv() returned ENOMEM.

NOTDIR 

Execv() returned ENOTDIR.

LOOP 

Execv() returned ELOOP.

TXTBUSY 

Execv() returned ETXTBUSY.

IO 

Execv() returned EIO.

NFILE 

Execv() returned ENFILE.

MFILE 

Execv() returned EMFILE.

INVAL 

Execv() returned EINVAL.

ISDIR 

Execv() returned EISDIR.

LIBBAD 

Execv() returned ELIBBAD.

FAILED 

Some other fatal failure, error->message should explain.

Function Documentation

void Glib::spawn_async ( const std::string working_directory,
const Glib::ArrayHandle< std::string >&  argv,
const Glib::ArrayHandle< std::string >&  envp,
SpawnFlags  flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup child_setup = SlotSpawnChildSetup(),
Pid child_pid = nullptr 
)

See spawn_async_with_pipes() for a full description.

This function simply calls the spawn_async_with_pipes() without any pipes.

Note
If you are writing a GTK+ application, and the program you are spawning is a graphical application, too, then you may want to use gdk_spawn_on_screen() instead to ensure that the spawned program opens its windows on the right screen.
Parameters
working_directoryChild's current working directory, or an empty string to inherit parent's.
argvChild's argument vector.
envpChild's environment.
flagsFlags from SpawnFlags.
child_setupSlot to run in the child just before exec(), or an empty slot.
child_pidReturn location for child process ID, or nullptr
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users.
void Glib::spawn_async ( const std::string working_directory,
const Glib::ArrayHandle< std::string >&  argv,
SpawnFlags  flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup child_setup = SlotSpawnChildSetup(),
Pid child_pid = nullptr 
)

Like the main spawn_async() method, but inheriting the parent's environment.

Parameters
working_directoryChild's current working directory, or an empty string to inherit parent's.
argvChild's argument vector.
flagsFlags from SpawnFlags.
child_setupSlot to run in the child just before exec(), or an empty slot.
child_pidReturn location for child process ID, or nullptr
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users.
void Glib::spawn_async_with_pipes ( const std::string working_directory,
const Glib::ArrayHandle< std::string >&  argv,
const Glib::ArrayHandle< std::string >&  envp,
SpawnFlags  flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup child_setup = SlotSpawnChildSetup(),
Pid child_pid = nullptr,
int *  standard_input = nullptr,
int *  standard_output = nullptr,
int *  standard_error = nullptr 
)

Executes a child program asynchronously (your program will not block waiting for the child to exit).

The child program is specified by the only argument that must be provided, argv. The first string in argv is of course the name of the program to execute. By default, the name of the program must be a full path; the PATH shell variable will only be searched if you pass the SPAWN_SEARCH_PATH flag.

On Windows, note that all the string or string vector arguments to this function and the other spawn*() functions are in UTF-8, the GLib file name encoding. Unicode characters that are not part of the system codepage passed in these arguments will be correctly available in the spawned program only if it uses wide character API to retrieve its command line. For C programs built with Microsoft's tools it is enough to make the program have a wmain() instead of main(). wmain() has a wide character argument vector as parameter.

At least currently, mingw doesn't support wmain(), so if you use mingw to develop the spawned program, it will have to call the undocumented function __wgetmainargs() to get the wide character argument vector and environment. See gspawn-win32-helper.c in the GLib sources or init.c in the mingw runtime sources for a prototype for that function. Alternatively, you can retrieve the Win32 system level wide character command line passed to the spawned program using the GetCommandLineW() function.

On Windows the low-level child process creation API CreateProcess() doesn't use argument vectors, but a command line. The C runtime library's spawn*() family of functions (which spawn_async_with_pipes() eventually calls) paste the argument vector elements together into a command line, and the C runtime startup code does a corresponding reconstruction of an argument vector from the command line, to be passed to main(). Complications arise when you have argument vector elements that contain spaces of double quotes. The spawn*() functions don't do any quoting or escaping, but on the other hand the startup code does do unquoting and unescaping in order to enable receiving arguments with embedded spaces or double quotes. To work around this asymmetry, spawn_async_with_pipes() will do quoting and escaping on argument vector elements that need it before calling the C runtime spawn() function.

envp is a lists of strings, where each string has the form KEY=VALUE. This will become the child's environment.

flags should be the bitwise OR of any flags you want to affect the function's behaviour. The SPAWN_DO_NOT_REAP_CHILD flags means that the child will not automatically be reaped; you must use a ChildWatch source to be notified about the death of the child process. Eventually you must call spawn_close_pid() on the child_pid, in order to free resources which may be associated with the child process. (On Unix, using a ChildWatch source is equivalent to calling waitpid() or handling the SIGCHLD signal manually. On Windows, calling spawn_close_pid() is equivalent to calling CloseHandle() on the process handle returned in child_pid).

PAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin/stdout/stderr will be closed before calling exec() in the child. SPAWN_SEARCH_PATH means that argv[0] need not be an absolute path, it will be looked for in the user's PATH. SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will be discarded, instead of going to the same location as the parent's standard output. If you use this flag, standard_output must be nullptr. SPAWN_STDERR_TO_DEV_NULL means that the child's standard error will be discarded, instead of going to the same location as the parent's standard error. If you use this flag, standard_error must be nullptr. SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's standard input (by default, the child's standard input is attached to /dev/null). If you use this flag, standard_input must be nullptr. G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally spawn_async_with_pipes() uses argv[0] as the file to execute, and passes all of argv to the child.

child_setup is a callback slot. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform (including creating pipes, closing file descriptors, etc.) but before calling exec(). That is, child_setup is called just before calling exec() in the child. Obviously actions taken in this function will only affect the child, not the parent. On Windows, there is no separate fork() and exec() functionality. Child processes are created and run with a single API call, CreateProcess(). child_setup is called in the parent process just before creating the child process. You should carefully consider what you do in child_setup if you intend your software to be portable to Windows.

If non-nullptr, child_pid will on Unix be filled with the child's process ID. You can use the process ID to send signals to the child, or to use child_watch_add() (or waitpid()) if you specified the SPAWN_DO_NOT_REAP_CHILD flag. On Windows, child_pid will be filled with a handle to the child process only if you specified the SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child process using the Win32 API, for example wait for its termination with the WaitFor*() functions, or examine its exit code with GetExitCodeProcess(). You should close the handle with CloseHandle() or spawn_close_pid() when you no longer need it.

If non-nullptr, the standard_input, standard_output, standard_error locations will be filled with file descriptors for writing to the child's standard input or reading from its standard output or standard error. The caller of pawn_async_with_pipes() must close these file descriptors when they are no longer in use. If these parameters are nullptr, the corresponding pipe won't be created.

If standard_input is nullptr, the child's standard input is attached to /dev/null unless SPAWN_CHILD_INHERITS_STDIN is set.

If standard_error is nullptr, the child's standard error goes to the same location as the parent's standard error unless SPAWN_STDERR_TO_DEV_NULL is set.

If standard_output is nullptr, the child's standard output goes to the same location as the parent's standard output unless SPAWN_STDOUT_TO_DEV_NULL is set.

If child_pid is not nullptr and an error does not occur then the returned pid must be closed using spawn_close_pid().

Note
If you are writing a gtkmm application, and the program you are spawning is a graphical application, too, then you may want to use spawn_on_screen_with_pipes() instead to ensure that the spawned program opens its windows on the right screen.
Parameters
working_directoryChild's current working directory, or an empty string to inherit the parent's, in the GLib file name encoding.
argvChild's argument vector.
envpChild's environment.
flagsFlags from SpawnFlags
child_setupSlot to run in the child just before exec(), or an empty slot.
child_pidReturn location for child process ID, or nullptr.
standard_inputReturn location for file descriptor to write to child's stdin, or nullptr.
standard_outputReturn location for file descriptor to read child's stdout, or nullptr.
standard_errorReturn location for file descriptor to read child's stderr, or nullptr.
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users. If an error occurs, child_pid, standard_input, standard_output, and standard_error will not be filled with valid values.
void Glib::spawn_async_with_pipes ( const std::string working_directory,
const Glib::ArrayHandle< std::string >&  argv,
SpawnFlags  flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup child_setup = SlotSpawnChildSetup(),
Pid child_pid = nullptr,
int *  standard_input = nullptr,
int *  standard_output = nullptr,
int *  standard_error = nullptr 
)

Like the main spawn_async_with_pipes() method, but inheriting the parent's environment.

Parameters
working_directoryChild's current working directory, or an empty string to inherit the parent's, in the GLib file name encoding.
argvChild's argument vector.
flagsFlags from SpawnFlags
child_setupSlot to run in the child just before exec(), or an empty slot.
child_pidReturn location for child process ID, or nullptr.
standard_inputReturn location for file descriptor to write to child's stdin, or nullptr.
standard_outputReturn location for file descriptor to read child's stdout, or nullptr.
standard_errorReturn location for file descriptor to read child's stderr, or nullptr.
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users. If an error occurs, child_pid, standard_input, standard_output, and standard_error will not be filled with valid values.
void Glib::spawn_close_pid ( Pid  pid)

On some platforms, notably WIN32, the Pid type represents a resource which must be closed to prevent resource leaking.

close_pid() is provided for this purpose. It should be used on all platforms, even though it doesn't do anything under UNIX.

Parameters
pidThe process identifier to close.
void Glib::spawn_command_line_async ( const std::string command_line)

A simple version of spawn_async() that parses a command line with shell_parse_argv() and passes it to spawn_async().

It runs a command line in the background. Unlike spawn_async(), the SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note that SPAWN_SEARCH_PATH can have security implications, so consider using spawn_async() directly if appropriate.

The same concerns on Windows apply as for spawn_command_line_sync().

Parameters
command_lineA command line.
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users.
ShellErrorIf the command line could not be parsed.
void Glib::spawn_command_line_sync ( const std::string command_line,
std::string standard_output = nullptr,
std::string standard_error = nullptr,
int *  exit_status = nullptr 
)

A simple version of spawn_sync() with little-used parameters removed, taking a command line instead of an argument vector.

See spawn_sync() for full details. command_line will be parsed by shell_parse_argv(). Unlike spawn_sync(), the SPAWN_SEARCH_PATH flag is enabled. Note that SPAWN_SEARCH_PATH can have security implications, so consider using spawn_sync() directly if appropriate.

If exit_status is non-nullptr, the exit status of the child is stored there as it would be returned by waitpid(); standard UNIX macros such as WIFEXITED() and WEXITSTATUS() must be used to evaluate the exit status.

On Windows, please note the implications of shell_parse_argv() parsing command_line. Parsing is done according to Unix shell rules, not Windows command interpreter rules. Space is a separator, and backslashes are special. Thus you cannot simply pass a command_line containing canonical Windows paths, like "c:\\program files\\app\\app.exe", as the backslashes will be eaten, and the space will act as a separator. You need to enclose such paths with single quotes, like "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".

Parameters
command_lineA command line.
standard_outputReturn location for child output.
standard_errorReturn location for child errors.
exit_statusReturn location for child exit status, as returned by waitpid().
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users.
ShellErrorIf the command line could not be parsed.
void Glib::spawn_sync ( const std::string working_directory,
const Glib::ArrayHandle< std::string >&  argv,
const Glib::ArrayHandle< std::string >&  envp,
SpawnFlags  flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup child_setup = SlotSpawnChildSetup(),
std::string standard_output = nullptr,
std::string standard_error = nullptr,
int *  exit_status = nullptr 
)

Executes a child synchronously (waits for the child to exit before returning).

All output from the child is stored in standard_output and standard_error, if those parameters are non-nullptr. Note that you must set the SPAWN_STDOUT_TO_DEV_NULL and SPAWN_STDERR_TO_DEV_NULL flags when passing nullptr for standard_output and standard_error. If exit_status is non-nullptr, the exit status of the child is stored there as it would be returned by waitpid(); standard UNIX macros such as WIFEXITED() and WEXITSTATUS() must be used to evaluate the exit status. Note that this function calls waitpid() even if exit_status is nullptr, and does not accept the SPAWN_DO_NOT_REAP_CHILD flag. If an error occurs, no data is returned in standard_output, standard_error, or exit_status.

This function calls spawn_async_with_pipes() internally; see that function for full details on the other parameters and details on how these functions work on Windows.

Parameters
working_directoryChild's current working directory, or an empty string to inherit the parent's, in the GLib file name encoding.
argvChild's argument vector.
envpChild's environment.
flagsFlags from SpawnFlags
child_setupSlot to run in the child just before exec(), or an empty slot.
standard_outputReturn location for file descriptor to read child's stdout, or nullptr.
standard_errorReturn location for file descriptor to read child's stderr, or nullptr.
exit_statusReturn location for child exit status, as returned by waitpid(), or nullptr
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users. If an error occurs, child_pid, standard_input, standard_output, and standard_error will not be filled with valid values.
void Glib::spawn_sync ( const std::string working_directory,
const Glib::ArrayHandle< std::string >&  argv,
SpawnFlags  flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup child_setup = SlotSpawnChildSetup(),
std::string standard_output = nullptr,
std::string standard_error = nullptr,
int *  exit_status = nullptr 
)

Like the main spawn_sync() method, but inheriting the parent's environment.

Parameters
working_directoryChild's current working directory, or an empty string to inherit the parent's, in the GLib file name encoding.
argvChild's argument vector.
flagsFlags from SpawnFlags
child_setupSlot to run in the child just before exec(), or an empty slot.
standard_outputReturn location for file descriptor to read child's stdout, or nullptr.
standard_errorReturn location for file descriptor to read child's stderr, or nullptr.
exit_statusReturn location for child exit status, as returned by waitpid(), or nullptr
Exceptions
SpawnErrorErrors are reported even if they occur in the child (for example if the executable in argv[0] is not found). Typically the message field of returned errors should be displayed to users. If an error occurs, child_pid, standard_input, standard_output, and standard_error will not be filled with valid values.