## GSubprocess Launcher

GSubprocess Launcher — Environment options for launching a child process

## Functions

GSubprocessLauncher * | g_subprocess_launcher_new ()
GSubprocess * | g_subprocess_launcher_spawn ()
GSubprocess * | g_subprocess_launcher_spawnv ()
void | g_subprocess_launcher_set_environ ()
void | g_subprocess_launcher_setenv ()
void | g_subprocess_launcher_unsetenv ()
const gchar * | g_subprocess_launcher_getenv ()
void | g_subprocess_launcher_set_cwd ()
void | g_subprocess_launcher_set_flags ()
void | g_subprocess_launcher_set_stdin_file_path ()
void | g_subprocess_launcher_take_stdin_fd ()
void | g_subprocess_launcher_set_stdout_file_path ()
void | g_subprocess_launcher_take_stdout_fd ()
void | g_subprocess_launcher_set_stderr_file_path ()
void | g_subprocess_launcher_take_stderr_fd ()
void | g_subprocess_launcher_take_fd ()
void | g_subprocess_launcher_set_child_setup ()

## Properties

GSubprocessFlags | flags | Write / Construct Only

## Types and Values

| GSubprocessLauncher

## Object Hierarchy

        GObject
        ╰── GSubprocessLauncher

## Includes

    #include <gio/gio.h>

## Description

This class contains a set of options for launching child processes, such as where its standard input and output will be directed, the argument list, the environment, and more.

While the GSubprocess class has high level functions covering popular cases, use of this class allows access to more advanced options. It can also be used to launch multiple subprocesses with a similar configuration.

## Functions

### g_subprocess_launcher_new ()

    GSubprocessLauncher *
    g_subprocess_launcher_new (GSubprocessFlags flags);

Creates a new GSubprocessLauncher.

The launcher is created with the default options. A copy of the environment of the calling process is made at the time of this call and will be used as the environment that the process is launched in.

#### Parameters

flags | GSubprocessFlags |

Since: 2.40

### g_subprocess_launcher_spawn ()

    GSubprocess *
    g_subprocess_launcher_spawn (GSubprocessLauncher *self,
                                 GError **error,
                                 const gchar *argv0,
                                 ...);

Creates a GSubprocess given a provided varargs list of arguments.

#### Parameters

self | a GSubprocessLauncher |
error | Error |
argv0 | Command line arguments |
... | Continued arguments, `NULL` terminated |

#### Returns

A new GSubprocess, or `NULL` on error (and `error` will be set).

[transfer full]

Since: 2.40

### g_subprocess_launcher_spawnv ()

    GSubprocess *
    g_subprocess_launcher_spawnv (GSubprocessLauncher *self,
                                  const gchar * const *argv,
                                  GError **error);

Creates a GSubprocess given a provided array of arguments.

#### Parameters

self | a GSubprocessLauncher |
argv | Command line arguments. | [array zero-terminated=1][element-type utf8]
error | Error |

#### Returns

A new GSubprocess, or `NULL` on error (and `error` will be set).

[transfer full]

Since: 2.40

### g_subprocess_launcher_set_environ ()

    void
    g_subprocess_launcher_set_environ (GSubprocessLauncher *self,
                                       gchar **env);

Replace the entire environment of processes launched from this launcher with the given 'environ' variable.

Typically you will build this variable by using `g_listenv()` to copy the process 'environ' and using the functions `g_environ_setenv()`, `g_environ_unsetenv()`, etc.

As an alternative, you can use `g_subprocess_launcher_setenv()`, `g_subprocess_launcher_unsetenv()`, etc.

Pass `NULL` to inherit the parent process' environment. Pass an empty array to set an empty environment.

On UNIX, all strings in this array can be arbitrary byte strings. On Windows, they should be in UTF-8.

#### Parameters

self | a GSubprocess |
env | the replacement environment. | [array zero-terminated=1]

Since: 2.40

### g_subprocess_launcher_setenv ()

    void
    g_subprocess_launcher_setenv (GSubprocessLauncher *self,
                                  const gchar *variable,
                                  const gchar *value,
                                  gboolean overwrite);

Sets the environment variable `variable` in the environment of processes launched from this launcher.

On UNIX, both the variable's name and value can be arbitrary byte strings, except that the variable's name cannot contain '='. On Windows, they should be in UTF-8.

#### Parameters

self | a GSubprocess |
variable | the environment variable to set, must not contain '=' |
value | the new value for the variable |
overwrite | whether to change the variable if it already exists |

Since: 2.40

### g_subprocess_launcher_unsetenv ()

    void
    g_subprocess_launcher_unsetenv (GSubprocessLauncher *self,
                                    const gchar *variable);

Removes the environment variable `variable` from the environment of processes launched from this launcher.

On UNIX, the variable's name can be an arbitrary byte string not containing '='. On Windows, it should be in UTF-8.

#### Parameters

self | a GSubprocess |
variable | the environment variable to unset, must not contain '=' |

Since: 2.40

### g_subprocess_launcher_getenv ()

    const gchar *
    g_subprocess_launcher_getenv (GSubprocessLauncher *self,
                                  const gchar *variable);

Returns the value of the environment variable `variable` in the environment of processes launched from this launcher.

On UNIX, the returned string can be an arbitrary byte string. On Windows, it will be UTF-8.

#### Parameters

self | a GSubprocess |
variable | the environment variable to get |

#### Returns

the value of the environment variable, `NULL` if unset

Since: 2.40

### g_subprocess_launcher_set_cwd ()

    void
    g_subprocess_launcher_set_cwd (GSubprocessLauncher *self,
                                   const gchar *cwd);

Sets the current working directory that processes will be launched with.

By default processes are launched with the current working directory of the launching process at the time of launch.

#### Parameters

self | a GSubprocess |
cwd | the cwd for launched processes. | [type filename]

Since: 2.40

### g_subprocess_launcher_set_flags ()

    void
    g_subprocess_launcher_set_flags (GSubprocessLauncher *self,
                                     GSubprocessFlags flags);

Sets the flags on the launcher.

The default flags are `G_SUBPROCESS_FLAGS_NONE`.

You may not set flags that specify conflicting options for how to handle a particular stdio stream (eg: specifying both `G_SUBPROCESS_FLAGS_STDIN_PIPE` and `G_SUBPROCESS_FLAGS_STDIN_INHERIT`).

You may also not set a flag that conflicts with a previous call to a function like `g_subprocess_launcher_set_stdin_file_path()` or `g_subprocess_launcher_take_stdout_fd()`.

#### Parameters

self | a GSubprocessLauncher |
flags | GSubprocessFlags |

Since: 2.40

### g_subprocess_launcher_set_stdin_file_path ()

    void
    g_subprocess_launcher_set_stdin_file_path
                                   (GSubprocessLauncher *self,
                                    const gchar *path);

Sets the file path to use as the stdin for spawned processes.

If `path` is `NULL` then any previously given path is unset.

The file must exist or spawning the process will fail.

You may not set a stdin file path if a stdin fd is already set or if the launcher flags contain any flags directing stdin elsewhere.

This feature is only available on UNIX.

#### Parameters

self | a GSubprocessLauncher |
path | (type filename) (nullable: a filename or `NULL` |

Since: 2.40

### g_subprocess_launcher_take_stdin_fd ()

    void
    g_subprocess_launcher_take_stdin_fd (GSubprocessLauncher *self,
                                         gint fd);

Sets the file descriptor to use as the stdin for spawned processes.

If `fd` is -1 then any previously given fd is unset.

Note that if your intention is to have the stdin of the calling process inherited by the child then `G_SUBPROCESS_FLAGS_STDIN_INHERIT` is a better way to go about doing that.

The passed `fd` is noted but will not be touched in the current process. It is therefore necessary that it be kept open by the caller until the subprocess is spawned. The file descriptor will also not be explicitly closed on the child side, so it must be marked O_CLOEXEC if that's what you want.

You may not set a stdin fd if a stdin file path is already set or if the launcher flags contain any flags directing stdin elsewhere.

This feature is only available on UNIX.

#### Parameters

self | a GSubprocessLauncher |
fd | a file descriptor, or -1 |

Since: 2.40

### g_subprocess_launcher_set_stdout_file_path ()

    void
    g_subprocess_launcher_set_stdout_file_path
                                   (GSubprocessLauncher *self,
                                    const gchar *path);

Sets the file path to use as the stdout for spawned processes.

If `path` is `NULL` then any previously given path is unset.

The file will be created or truncated when the process is spawned, as would be the case if using '>' at the shell.

You may not set a stdout file path if a stdout fd is already set or if the launcher flags contain any flags directing stdout elsewhere.

This feature is only available on UNIX.

#### Parameters

self | a GSubprocessLauncher |
path | a filename or `NULL`. | [type filename][nullable]

Since: 2.40

### g_subprocess_launcher_take_stdout_fd ()

    void
    g_subprocess_launcher_take_stdout_fd (GSubprocessLauncher *self,
                                          gint fd);

Sets the file descriptor to use as the stdout for spawned processes.

If `fd` is -1 then any previously given fd is unset.

Note that the default behaviour is to pass stdout through to the stdout of the parent process.

The passed `fd` is noted but will not be touched in the current process. It is therefore necessary that it be kept open by the caller until the subprocess is spawned. The file descriptor will also not be explicitly closed on the child side, so it must be marked O_CLOEXEC if that's what you want.

You may not set a stdout fd if a stdout file path is already set or if the launcher flags contain any flags directing stdout elsewhere.

This feature is only available on UNIX.

#### Parameters

self | a GSubprocessLauncher |
fd | a file descriptor, or -1 |

Since: 2.40

### g_subprocess_launcher_set_stderr_file_path ()

    void
    g_subprocess_launcher_set_stderr_file_path
                                   (GSubprocessLauncher *self,
                                    const gchar *path);

Sets the file path to use as the stderr for spawned processes.

If `path` is `NULL` then any previously given path is unset.

The file will be created or truncated when the process is spawned, as would be the case if using '2>' at the shell.

If you want to send both stdout and stderr to the same file then use `G_SUBPROCESS_FLAGS_STDERR_MERGE`.

You may not set a stderr file path if a stderr fd is already set or if the launcher flags contain any flags directing stderr elsewhere.

This feature is only available on UNIX.

#### Parameters

self | a GSubprocessLauncher |
path | a filename or `NULL`. | [type filename][nullable]

Since: 2.40

### g_subprocess_launcher_take_stderr_fd ()

    void
    g_subprocess_launcher_take_stderr_fd (GSubprocessLauncher *self,
                                          gint fd);

Sets the file descriptor to use as the stderr for spawned processes.

If `fd` is -1 then any previously given fd is unset.

Note that the default behaviour is to pass stderr through to the stderr of the parent process.

The passed `fd` belongs to the GSubprocessLauncher. It will be automatically closed when the launcher is finalized. The file descriptor will also be closed on the child side when executing the spawned process.

You may not set a stderr fd if a stderr file path is already set or if the launcher flags contain any flags directing stderr elsewhere.

This feature is only available on UNIX.

#### Parameters

self | a GSubprocessLauncher |
fd | a file descriptor, or -1 |

Since: 2.40

### g_subprocess_launcher_take_fd ()

    void
    g_subprocess_launcher_take_fd (GSubprocessLauncher *self,
                                   gint source_fd,
                                   gint target_fd);

Transfer an arbitrary file descriptor from parent process to the child. This function takes "ownership" of the fd; it will be closed in the parent when `self` is freed.

By default, all file descriptors from the parent will be closed. This function allows you to create (for example) a custom `pipe()` or `socketpair()` before launching the process, and choose the target descriptor in the child.

An example use case is GNUPG, which has a command line argument --passphrase-fd providing a file descriptor number where it expects the passphrase to be written.

#### Parameters

self | a GSubprocessLauncher |
source_fd | File descriptor in parent process |
target_fd | Target descriptor for child process |

### g_subprocess_launcher_set_child_setup ()

    void
    g_subprocess_launcher_set_child_setup (GSubprocessLauncher *self,
                                           GSpawnChildSetupFunc child_setup,
                                           gpointer user_data,
                                           GDestroyNotify destroy_notify);

Sets up a child setup function.

The child setup function will be called after `fork()` but before `exec()` on the child's side.

`destroy_notify` will not be automatically called on the child's side of the `fork()`. It will only be called when the last reference on the GSubprocessLauncher is dropped or when a new child setup function is given.

`NULL` can be given as `child_setup` to disable the functionality.

Child setup functions are only available on UNIX.

#### Parameters

self | a GSubprocessLauncher |
child_setup | a GSpawnChildSetupFunc to use as the child setup function |
user_data | user data for `child_setup` |
destroy_notify | a GDestroyNotify for `user_data` |

Since: 2.40

## Types and Values

### GSubprocessLauncher

    typedef struct _GSubprocessLauncher GSubprocessLauncher;

Options for launching a child process.

Since: 2.40

## Property Details

### The `“flags”` property

      “flags”                    GSubprocessFlags

GSubprocessFlags for launched processes.

Flags: Write / Construct Only