static gboolean barebox_state_get_int(const gchar* name, int *value) {
GSubprocess *sub;
GError *error = NULL;
gboolean res = FALSE;
GInputStream *instream;
GDataInputStream *datainstream;
gchar* outline;
guint64 result = 0;
GPtrArray *args = g_ptr_array_new_full(10, g_free);
g_ptr_array_add(args, g_strdup(BAREBOX_STATE_NAME));
g_ptr_array_add(args, g_strdup("-g"));
g_ptr_array_add(args, g_strdup(name));
g_ptr_array_add(args, NULL);
sub = g_subprocess_newv((const gchar * const *)args->pdata,
G_SUBPROCESS_FLAGS_NONE, &error);
if (!sub) {
g_warning("getting state failed: %s", error->message);
g_clear_error(&error);
goto out;
}
instream = g_subprocess_get_stdout_pipe(sub);
datainstream = g_data_input_stream_new(instream);
outline = g_data_input_stream_read_line(datainstream, NULL, NULL, NULL);
if (!outline) {
g_warning("failed reading state");
goto out;
}
result = g_ascii_strtoull(outline, NULL, 10);
if (errno != 0) {
g_warning("Invalid return value: '%s'\n", outline);
goto out;
}
res = g_subprocess_wait_check(sub, NULL, &error);
if (!res) {
g_warning("getting state failed: %s", error->message);
g_clear_error(&error);
goto out;
}
out:
g_ptr_array_unref(args);
*value = result;
return res;
}
static TestClient *
test_client_new (const char *id,
MetaWindowClientType type,
GError **error)
{
TestClient *client = g_new0 (TestClient, 1);
GSubprocessLauncher *launcher;
GSubprocess *subprocess;
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE);
g_assert (meta_is_wayland_compositor ());
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
g_subprocess_launcher_setenv (launcher,
"WAYLAND_DISPLAY", meta_wayland_get_wayland_display_name (compositor),
TRUE);
g_subprocess_launcher_setenv (launcher,
"DISPLAY", meta_wayland_get_xwayland_display_name (compositor),
TRUE);
subprocess = g_subprocess_launcher_spawn (launcher,
error,
test_client_path,
"--client-id",
id,
type == META_WINDOW_CLIENT_TYPE_WAYLAND ? "--wayland" : NULL,
NULL);
g_object_unref (launcher);
if (!subprocess)
return NULL;
client->type = type;
client->id = g_strdup (id);
client->cancellable = g_cancellable_new ();
client->subprocess = subprocess;
client->in = g_data_output_stream_new (g_subprocess_get_stdin_pipe (subprocess));
client->out = g_data_input_stream_new (g_subprocess_get_stdout_pipe (subprocess));
client->loop = g_main_loop_new (NULL, FALSE);
if (client->type == META_WINDOW_CLIENT_TYPE_X11)
client->waiter = async_waiter_new ();
return client;
}
static gboolean
compute_and_append_legacy_archive_checksum (const char *commit,
GString *buf,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
const char *archive_argv[] = {"git", "archive", "--format=tar", commit, NULL};
GSubprocess *gitarchive_proc = NULL;
GInputStream *gitarchive_output = NULL;
guint64 legacy_checksum_start;
guint64 legacy_checksum_end;
GChecksum *legacy_archive_sha256 = g_checksum_new (G_CHECKSUM_SHA256);
gssize bytes_read;
char readbuf[4096];
char *gitversion = NULL;
int estatus;
char *nl;
legacy_checksum_start = g_get_monotonic_time ();
gitarchive_proc = g_subprocess_newv (archive_argv, G_SUBPROCESS_FLAGS_STDOUT_PIPE, error);
if (!gitarchive_proc)
goto out;
gitarchive_output = g_subprocess_get_stdout_pipe (gitarchive_proc);
while ((bytes_read = g_input_stream_read (gitarchive_output, readbuf, sizeof (readbuf),
cancellable, error)) > 0)
g_checksum_update (legacy_archive_sha256, (guint8*)readbuf, bytes_read);
if (bytes_read < 0)
goto out;
legacy_checksum_end = g_get_monotonic_time ();
g_string_append_printf (buf, "# git-evtag comment: Computed legacy checksum in %0.1fs\n",
(double)(legacy_checksum_end - legacy_checksum_start) / (double) G_USEC_PER_SEC);
g_string_append (buf, LEGACY_EVTAG_ARCHIVE_TAR);
g_string_append_c (buf, ' ');
g_string_append (buf, g_checksum_get_string (legacy_archive_sha256));
g_string_append_c (buf, '\n');
if (!g_spawn_command_line_sync ("git --version", &gitversion, NULL, &estatus, error))
goto out;
if (!g_spawn_check_exit_status (estatus, error))
goto out;
nl = strchr (gitversion, '\n');
if (!nl)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"git --version returned invalid content without a newline");
goto out;
}
*nl = '\0';
g_strchomp (gitversion);
g_string_append (buf, LEGACY_EVTAG_ARCHIVE_TAR_GITVERSION);
g_string_append_c (buf, ' ');
g_string_append (buf, gitversion);
g_string_append_c (buf, '\n');
ret = TRUE;
out:
return ret;
}
static gboolean launch_and_wait_variables_handler(gchar *handler_name, GHashTable *variables, GError **error)
{
g_autoptr(GSubprocessLauncher) handlelaunch = NULL;
g_autoptr(GSubprocess) handleproc = NULL;
GError *ierror = NULL;
GHashTableIter iter;
gchar *key = NULL;
gchar *value = NULL;
g_autoptr(GDataInputStream) datainstream = NULL;
GInputStream *instream;
gchar* outline;
g_return_val_if_fail(handler_name, FALSE);
g_return_val_if_fail(variables, FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
handlelaunch = g_subprocess_launcher_new(G_SUBPROCESS_FLAGS_STDOUT_PIPE | G_SUBPROCESS_FLAGS_STDERR_MERGE);
/* we copy the variables from the hashtable and add them to the
subprocess environment */
g_hash_table_iter_init(&iter, variables);
while (g_hash_table_iter_next(&iter, (gpointer*) &key, (gpointer*) &value)) {
g_subprocess_launcher_setenv(handlelaunch, g_strdup(key), g_strdup(value), 1);
}
handleproc = g_subprocess_launcher_spawn(
handlelaunch,
&ierror, handler_name,
NULL,
NULL);
if (!handleproc) {
g_propagate_error(error, ierror);
return FALSE;
}
instream = g_subprocess_get_stdout_pipe(handleproc);
datainstream = g_data_input_stream_new(instream);
do {
outline = g_data_input_stream_read_line(datainstream, NULL, NULL, NULL);
if (!outline)
continue;
if (g_str_has_prefix(outline, "RAUC_")) {
gchar **split = g_strsplit(outline, "=", 2);
if (g_strv_length(split) != 2)
continue;
g_hash_table_insert(variables, g_strdup(split[0]), g_strdup(split[1]));
g_strfreev(split);
}
} while (outline);
if (!g_subprocess_wait_check(handleproc, NULL, &ierror)) {
g_propagate_error(error, ierror);
return FALSE;
}
return TRUE;
}
static gboolean
archive_spawnv (GFile *dir,
char **output,
GError **error,
const gchar * const *argv)
{
g_autoptr(GSubprocessLauncher) launcher = NULL;
g_autoptr(GSubprocess) subp = NULL;
GInputStream *in;
g_autoptr(GOutputStream) out = NULL;
g_autoptr(GMainLoop) loop = NULL;
SpawnData data = {0};
g_autofree gchar *commandline = NULL;
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE);
if (output)
g_subprocess_launcher_set_flags (launcher, G_SUBPROCESS_FLAGS_STDOUT_PIPE);
if (dir)
{
g_autofree char *path = g_file_get_path (dir);
g_subprocess_launcher_set_cwd (launcher, path);
}
commandline = g_strjoinv (" ", (gchar **) argv);
g_debug ("Running '%s'", commandline);
subp = g_subprocess_launcher_spawnv (launcher, argv, error);
if (subp == NULL)
return FALSE;
loop = g_main_loop_new (NULL, FALSE);
data.loop = loop;
data.refs = 1;
if (output)
{
data.refs++;
in = g_subprocess_get_stdout_pipe (subp);
out = g_memory_output_stream_new_resizable ();
g_output_stream_splice_async (out,
in,
G_OUTPUT_STREAM_SPLICE_NONE,
0,
NULL,
spawn_output_spliced_cb,
&data);
}
g_subprocess_wait_async (subp, NULL, spawn_exit_cb, &data);
g_main_loop_run (loop);
if (data.error)
{
g_propagate_error (error, data.error);
g_clear_error (&data.splice_error);
return FALSE;
}
if (out)
{
if (data.splice_error)
{
g_propagate_error (error, data.splice_error);
return FALSE;
}
/* Null terminate */
g_output_stream_write (out, "\0", 1, NULL, NULL);
g_output_stream_close (out, NULL, NULL);
*output = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out));
}
return TRUE;
}
