static void
on_reformatter_exited (GTask *task,
GError *error)
{
GisPage *page = GIS_PAGE (g_task_get_source_object (task));
gis_driver_show_window (page->driver);
if (error == NULL)
{
g_task_return_boolean (task, TRUE);
return;
}
GtkWindow *toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (page)));
GtkWidget *message_dialog;
g_critical ("Error running the reformatter: %s", error->message);
message_dialog = gtk_message_dialog_new (toplevel,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
/* Translators: this is shown when launching the
* reformatter (an external program) fails. The
* placeholder is an error message describing what went
* wrong.
*/
_("Error running the reformatter: %s"), error->message);
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, run_dialog_cb,
message_dialog, (GDestroyNotify) gtk_widget_destroy);
g_task_return_error (task, g_steal_pointer (&error));
}
static gchar *
gis_page_util_get_image_version (const gchar *path,
GError **error)
{
ssize_t attrsize;
g_autofree gchar *value = NULL;
g_return_val_if_fail (path != NULL, NULL);
attrsize = getxattr (path, EOS_IMAGE_VERSION_XATTR, NULL, 0);
if (attrsize >= 0)
{
value = g_malloc (attrsize + 1);
value[attrsize] = 0;
attrsize = getxattr (path, EOS_IMAGE_VERSION_XATTR, value,
attrsize);
}
if (attrsize >= 0)
{
return g_steal_pointer (&value);
}
else
{
int errsv = errno;
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
"Error examining " EOS_IMAGE_VERSION_XATTR " on %s: %s",
path, g_strerror (errsv));
return NULL;
}
}
static gboolean
add_ref_to_set (const char *remote,
int base_fd,
const char *path,
GHashTable *refs,
GCancellable *cancellable,
GError **error)
{
gsize len;
char *contents = glnx_file_get_contents_utf8_at (base_fd, path, &len, cancellable, error);
if (!contents)
return FALSE;
g_strchomp (contents);
g_autoptr(GString) refname = g_string_new ("");
if (remote)
{
g_string_append (refname, remote);
g_string_append_c (refname, ':');
}
g_string_append (refname, path);
g_hash_table_insert (refs, g_string_free (g_steal_pointer (&refname), FALSE), contents);
return TRUE;
}
static void
photos_glib_file_copy_read (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GCancellable *cancellable;
GFile *source = G_FILE (source_object);
g_autoptr (GFileInputStream) istream = NULL;
g_autoptr (GTask) task = G_TASK (user_data);
PhotosGLibFileCopyData *data;
cancellable = g_task_get_cancellable (task);
data = (PhotosGLibFileCopyData *) g_task_get_task_data (task);
{
g_autoptr (GError) error = NULL;
istream = g_file_read_finish (source, res, &error);
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_output_stream_splice_async (G_OUTPUT_STREAM (data->ostream),
G_INPUT_STREAM (istream),
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
data->io_priority,
cancellable,
photos_glib_file_copy_splice,
g_object_ref (task));
out:
return;
}
void
ide_build_system_get_build_flags_for_dir_async (IdeBuildSystem *self,
GFile *directory,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(IdeTask) task = NULL;
g_return_if_fail (IDE_IS_BUILD_SYSTEM (self));
g_return_if_fail (G_IS_FILE (directory));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = ide_task_new (self, cancellable, callback, user_data);
ide_task_set_source_tag (task, ide_build_system_get_build_flags_for_dir_async);
ide_task_set_priority (task, G_PRIORITY_LOW);
ide_g_file_get_children_async (directory,
G_FILE_ATTRIBUTE_STANDARD_NAME","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_LOW,
cancellable,
ide_build_system_get_build_flags_for_dir_cb,
g_steal_pointer (&task));
}
static void
on_import_complete (GObject *source, GAsyncResult *result, gpointer user_data)
{
SeahorsePgpBackend *backend = SEAHORSE_PGP_BACKEND (source);
g_autoptr(SeahorseKeyserverResultsRow) row =
SEAHORSE_KEYSERVER_RESULTS_ROW (user_data);
const gchar *result_icon_name;
g_autoptr(GtkWidget) result_icon = NULL;
g_autofree gchar *result_tooltip = NULL;
g_autoptr(GError) err = NULL;
if (!seahorse_pgp_backend_transfer_finish (backend, result, &err)) {
result_icon_name = "dialog-warning-symbolic";
result_tooltip = g_strdup_printf (_("Couldn’t import key: %s"),
err->message);
} else {
result_icon_name = "emblem-ok-symbolic";
result_tooltip = g_strdup (_("Key import succeeded"));
}
result_icon = gtk_image_new_from_icon_name (result_icon_name,
GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (row->import_button, g_steal_pointer (&result_icon));
gtk_widget_set_tooltip_text (GTK_WIDGET (row->import_button),
result_tooltip);
}
void
photos_glib_file_copy_async (GFile *source,
GFile *destination,
GFileCopyFlags flags,
gint io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GFileCreateFlags create_flags = G_FILE_CREATE_NONE;
g_autoptr (GTask) task = NULL;
g_autoptr (PhotosGLibFileCopyData) data = NULL;
g_return_if_fail (G_IS_FILE (source));
g_return_if_fail (G_IS_FILE (destination));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
task = g_task_new (source, cancellable, callback, user_data);
g_task_set_source_tag (task, photos_glib_file_copy_async);
data = photos_glib_file_copy_data_new (io_priority);
g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) photos_glib_file_copy_data_free);
if ((flags & G_FILE_COPY_OVERWRITE) != 0)
create_flags |= G_FILE_CREATE_REPLACE_DESTINATION;
photos_glib_file_create_async (destination,
create_flags,
io_priority,
cancellable,
photos_glib_file_copy_create,
g_object_ref (task));
}
gboolean
ostree_option_context_parse (GOptionContext *context,
const GOptionEntry *main_entries,
int *argc,
char ***argv,
OstreeBuiltinFlags flags,
OstreeRepo **out_repo,
GCancellable *cancellable,
GError **error)
{
g_autoptr(OstreeRepo) repo = NULL;
/* Entries are listed in --help output in the order added. We add the
* main entries ourselves so that we can add the --repo entry first. */
if (!(flags & OSTREE_BUILTIN_FLAG_NO_REPO))
g_option_context_add_main_entries (context, repo_entry, NULL);
if (main_entries != NULL)
g_option_context_add_main_entries (context, main_entries, NULL);
g_option_context_add_main_entries (context, global_entries, NULL);
if (!g_option_context_parse (context, argc, argv, error))
return FALSE;
if (opt_version)
{
/* This should now be YAML, like `docker version`, so it's both nice to read
* possible to parse */
g_auto(GStrv) features = g_strsplit (OSTREE_FEATURES, " ", -1);
g_print ("%s:\n", PACKAGE_NAME);
g_print (" Version: %s\n", PACKAGE_VERSION);
if (strlen (OSTREE_GITREV) > 0)
g_print (" Git: %s\n", OSTREE_GITREV);
#ifdef BUILDOPT_IS_DEVEL_BUILD
g_print (" DevelBuild: yes\n");
#endif
g_print (" Features:\n");
for (char **iter = features; iter && *iter; iter++)
g_print (" - %s\n", *iter);
exit (EXIT_SUCCESS);
}
if (opt_verbose)
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, message_handler, NULL);
if (!(flags & OSTREE_BUILTIN_FLAG_NO_REPO))
{
repo = parse_repo_option (context, opt_repo, (flags & OSTREE_BUILTIN_FLAG_NO_CHECK) > 0,
cancellable, error);
if (!repo)
return FALSE;
}
if (out_repo)
*out_repo = g_steal_pointer (&repo);
return TRUE;
}
/**
* gdata_access_handler_get_rules_async:
* @self: a #GDataAccessHandler
* @service: a #GDataService
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @progress_callback: (allow-none) (closure progress_user_data): a #GDataQueryProgressCallback to call when a rule is loaded, or %NULL
* @progress_user_data: (closure): data to pass to the @progress_callback function
* @destroy_progress_user_data: (allow-none): the function to call when @progress_callback will not be called any more, or %NULL. This function will be
* called with @progress_user_data as a parameter and can be used to free any memory allocated for it.
* @callback: a #GAsyncReadyCallback to call when the query is finished
* @user_data: (closure): data to pass to the @callback function
*
* Retrieves a #GDataFeed containing all the access rules which apply to the given #GDataAccessHandler. Only the owner of a #GDataAccessHandler may
* view its rule feed. @self and @service are both reffed when this function is called, so can safely be unreffed after this function returns.
*
* For more details, see gdata_access_handler_get_rules(), which is the synchronous version of this function, and gdata_service_query_async(), which
* is the base asynchronous query function.
*
* When the operation is finished, @callback will be called. You can then call gdata_service_query_finish()
* to get the results of the operation.
*
* Since: 0.9.1
*/
void
gdata_access_handler_get_rules_async (GDataAccessHandler *self, GDataService *service, GCancellable *cancellable,
GDataQueryProgressCallback progress_callback, gpointer progress_user_data,
GDestroyNotify destroy_progress_user_data,
GAsyncReadyCallback callback, gpointer user_data)
{
g_autoptr(GTask) task = NULL;
GetRulesAsyncData *data;
g_return_if_fail (GDATA_IS_ACCESS_HANDLER (self));
g_return_if_fail (GDATA_IS_SERVICE (service));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
g_return_if_fail (callback != NULL);
data = g_slice_new (GetRulesAsyncData);
data->service = g_object_ref (service);
data->progress_callback = progress_callback;
data->progress_user_data = progress_user_data;
data->destroy_progress_user_data = destroy_progress_user_data;
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, gdata_service_query_async);
g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) get_rules_async_data_free);
g_task_run_in_thread (task, get_rules_thread);
}
static void
ide_run_manager_run_discover_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeRunManager *self = (IdeRunManager *)object;
g_autoptr(IdeBuildTarget) build_target = NULL;
g_autoptr(GTask) task = user_data;
GError *error = NULL;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (G_IS_ASYNC_RESULT (result));
build_target = ide_run_manager_discover_default_target_finish (self, result, &error);
if (build_target == NULL)
{
g_task_return_error (task, error);
return;
}
ide_run_manager_set_build_target (self, build_target);
g_task_set_task_data (task, g_steal_pointer (&build_target), g_object_unref);
do_run_async (self, task);
}
gboolean
get_origin_refspec (OstreeDeployment *booted_deployment,
gchar **out_refspec,
GError **error)
{
GKeyFile *origin;
g_autofree gchar *refspec = NULL;
g_return_val_if_fail (OSTREE_IS_DEPLOYMENT (booted_deployment), FALSE);
g_return_val_if_fail (out_refspec != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
origin = ostree_deployment_get_origin (booted_deployment);
if (origin == NULL)
{
const gchar *osname = ostree_deployment_get_osname (booted_deployment);
const gchar *booted = ostree_deployment_get_csum (booted_deployment);
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
"No origin found for %s (%s), cannot upgrade",
osname, booted);
return FALSE;
}
refspec = g_key_file_get_string (origin, "origin", "refspec", error);
if (refspec == NULL)
return FALSE;
*out_refspec = g_steal_pointer (&refspec);
return TRUE;
}
gchar *
gs_snapd_get_resource (const gchar *macaroon, gchar **discharges,
const gchar *path,
gsize *data_length,
GCancellable *cancellable, GError **error)
{
guint status_code;
g_autofree gchar *reason_phrase = NULL;
g_autofree gchar *response_type = NULL;
g_autofree gchar *data = NULL;
if (!send_request ("GET", path, NULL,
macaroon, discharges,
&status_code, &reason_phrase,
NULL, &data, data_length,
cancellable, error))
return NULL;
if (status_code != SOUP_STATUS_OK) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"snapd returned status code %u: %s",
status_code, reason_phrase);
return NULL;
}
return g_steal_pointer (&data);
}
void
gs_page_authenticate (GsPage *page,
GsApp *app,
const gchar *auth_id,
GCancellable *cancellable,
GsPageAuthCallback callback,
gpointer user_data)
{
GsPagePrivate *priv = gs_page_get_instance_private (page);
g_autoptr(GsPageHelper) helper = NULL;
GtkWidget *dialog;
g_autoptr(GError) error = NULL;
helper = g_slice_new0 (GsPageHelper);
helper->app = app != NULL ? g_object_ref (app) : NULL;
helper->page = g_object_ref (page);
helper->callback = callback;
helper->callback_data = user_data;
dialog = gs_auth_dialog_new (priv->plugin_loader,
app,
auth_id,
&error);
if (dialog == NULL) {
g_warning ("%s", error->message);
return;
}
gs_shell_modal_dialog_present (priv->shell, GTK_DIALOG (dialog));
g_signal_connect (dialog, "response",
G_CALLBACK (gs_page_authenticate_cb),
helper);
g_steal_pointer (&helper);
}
static GBytes *
download_file (SoupURI *uri)
{
g_autoptr(GBytes) contents = NULL;
if (soup_uri_get_scheme (uri) == SOUP_URI_SCHEME_FILE)
{
g_autoptr(GFile) file = g_file_new_for_path (soup_uri_get_path (uri));
eos_updater_read_file_to_bytes (file, NULL, &contents, NULL);
}
else
{
g_autoptr(SoupSession) soup = soup_session_new ();
g_autoptr(SoupMessage) msg = soup_message_new_from_uri ("GET", uri);
guint status = soup_session_send_message (soup, msg);
if (SOUP_STATUS_IS_SUCCESSFUL (status))
g_object_get (msg,
SOUP_MESSAGE_RESPONSE_BODY_DATA, &contents,
NULL);
}
return g_steal_pointer (&contents);
}
static void
gs_page_remove_app_response_cb (GtkDialog *dialog,
gint response,
gpointer user_data)
{
g_autoptr(GsPageHelper) helper = (GsPageHelper *) user_data;
GsPagePrivate *priv = gs_page_get_instance_private (helper->page);
g_autoptr(GsPluginJob) plugin_job = NULL;
/* unmap the dialog */
gtk_widget_destroy (GTK_WIDGET (dialog));
/* not agreed */
if (response != GTK_RESPONSE_OK)
return;
g_debug ("remove %s", gs_app_get_id (helper->app));
plugin_job = gs_plugin_job_newv (helper->action,
"interactive", TRUE,
"app", helper->app,
NULL);
gs_plugin_loader_job_process_async (priv->plugin_loader, plugin_job,
helper->cancellable,
gs_page_app_removed_cb,
helper);
g_steal_pointer (&helper);
}
static void
parse_xml_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
DspyIntrospectionModel *self = source_object;
GBytes *bytes = task_data;
g_autoptr(GError) error = NULL;
DspyNodeInfo *info;
const gchar *xml;
g_assert (G_IS_TASK (task));
g_assert (DSPY_IS_INTROSPECTION_MODEL (source_object));
g_assert (bytes != NULL);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
xml = (const gchar *)g_bytes_get_data (bytes, NULL);
g_mutex_lock (&self->chunks_mutex);
info = _dspy_node_parse (xml, self->chunks, &error);
g_mutex_unlock (&self->chunks_mutex);
if (info != NULL)
g_task_return_pointer (task, info, (GDestroyNotify) _dspy_node_free);
else
g_task_return_error (task, g_steal_pointer (&error));
}
static void
dspy_introspection_model_get_value (GtkTreeModel *model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
LOG_DEBUG (G_STRFUNC);
if (column == 0)
{
DspyNode *node = iter->user_data;
g_autofree gchar *str = NULL;
g_assert (node != NULL);
g_assert (DSPY_IS_NODE (node));
g_value_init (value, G_TYPE_STRING);
str = _dspy_node_get_text (node);
if (_dspy_node_is_group (node))
{
if (gtk_tree_model_iter_has_child (model, iter))
g_value_take_string (value, g_strdup_printf ("<b>%s</b>", str));
else
g_value_take_string (value, g_strdup_printf ("<span fgalpha='25000' weight='bold'>%s</span>", str));
}
else
g_value_take_string (value, g_steal_pointer (&str));
}
}
static void
on_import_button_clicked (GtkButton *import_button, gpointer user_data)
{
SeahorseKeyserverResultsRow *row = user_data;
g_autoptr(GtkWidget) spinner = NULL;
g_autoptr(GList) keys = NULL;
g_autoptr(GCancellable) cancellable = NULL;
SeahorsePgpBackend *backend;
SeahorseGpgmeKeyring *keyring;
/* Let the button show a spinner while importing */
gtk_widget_set_sensitive (GTK_WIDGET (import_button), FALSE);
spinner = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (spinner));
gtk_button_set_image (import_button, g_steal_pointer (&spinner));
/* Now import the key */
keys = g_list_append (keys, row->key);
cancellable = g_cancellable_new ();
backend = seahorse_pgp_backend_get ();
keyring = seahorse_pgp_backend_get_default_keyring (backend);
seahorse_pgp_backend_transfer_async (backend, keys,
SEAHORSE_PLACE (keyring),
cancellable, on_import_complete,
g_object_ref (row));
}
static void
photos_glib_file_copy_splice (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GOutputStream *ostream = G_OUTPUT_STREAM (source_object);
g_autoptr (GTask) task = G_TASK (user_data);
PhotosGLibFileCopyData *data;
data = (PhotosGLibFileCopyData *) g_task_get_task_data (task);
g_assert_true (G_IS_FILE_OUTPUT_STREAM (ostream));
g_assert_true (G_FILE_OUTPUT_STREAM (ostream) == data->ostream);
{
g_autoptr (GError) error = NULL;
g_output_stream_splice_finish (ostream, res, &error);
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_task_return_pointer (task, g_object_ref (data->unique_file), g_object_unref);
out:
return;
}
static void
ide_keybindings_load_plugin (IdeKeybindings *self,
PeasPluginInfo *plugin_info,
PeasEngine *engine)
{
g_autofree gchar *path = NULL;
const gchar *module_name;
g_autoptr(GBytes) bytes = NULL;
g_autoptr(GtkCssProvider) provider = NULL;
g_assert (IDE_IS_KEYBINDINGS (self));
g_assert (plugin_info != NULL);
g_assert (PEAS_IS_ENGINE (engine));
if (!self->mode || !self->plugin_providers)
return;
module_name = peas_plugin_info_get_module_name (plugin_info);
path = g_strdup_printf ("/org/gnome/builder/plugins/%s/keybindings/%s.css",
module_name, self->mode);
bytes = g_resources_lookup_data (path, 0, NULL);
if (bytes == NULL)
return;
IDE_TRACE_MSG ("Loading %s keybindings for \"%s\" plugin", self->mode, module_name);
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (provider, path);
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
g_hash_table_insert (self->plugin_providers,
g_strdup (module_name),
g_steal_pointer (&provider));
}
static void
gbp_cmake_toolchain_provider_load_async (IdeToolchainProvider *provider,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GbpCMakeToolchainProvider *self = (GbpCMakeToolchainProvider *)provider;
g_autoptr(IdeTask) task = NULL;
g_autoptr(GFile) workdir = NULL;
IdeContext *context;
IDE_ENTRY;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (GBP_IS_CMAKE_TOOLCHAIN_PROVIDER (self));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
context = ide_object_get_context (IDE_OBJECT (self));
workdir = ide_context_ref_workdir (context);
task = ide_task_new (provider, cancellable, callback, user_data);
ide_task_set_source_tag (task, gbp_cmake_toolchain_provider_load_async);
ide_task_set_priority (task, G_PRIORITY_LOW);
ide_g_file_find_with_depth_async (workdir,
"*.cmake",
CMAKE_TOOLCHAIN_MAX_FIND_DEPTH,
cancellable,
load_find_files_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
/*
* Send the given method call and wait for a reply, spinning the main
* context as necessary.
*/
DBusMessage *
test_main_context_call_and_wait (TestMainContext *ctx,
DBusConnection *connection,
DBusMessage *call,
int timeout)
{
DBusPendingCall *pc = NULL;
DBusMessage *reply = NULL;
if (!dbus_connection_send_with_reply (connection, call, &pc, timeout) ||
pc == NULL)
test_oom ();
if (dbus_pending_call_get_completed (pc))
test_pending_call_store_reply (pc, &reply);
else if (!dbus_pending_call_set_notify (pc, test_pending_call_store_reply,
&reply, NULL))
test_oom ();
while (reply == NULL)
test_main_context_iterate (ctx, TRUE);
dbus_clear_pending_call (&pc);
return g_steal_pointer (&reply);
}
/* swiss-army knife: takes an strv of pkgspecs destined for
* install, and splits it into repo pkgs, and for local
* pkgs, an fd list & idx variant. */
gboolean
rpmostree_sort_pkgs_strv (const char *const* pkgs,
GUnixFDList *fd_list,
GPtrArray **out_repo_pkgs,
GVariant **out_fd_idxs,
GError **error)
{
g_autoptr(GPtrArray) repo_pkgs = g_ptr_array_new_with_free_func (g_free);
g_auto(GVariantBuilder) builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("ah"));
for (const char *const* pkg = pkgs; pkg && *pkg; pkg++)
{
if (!g_str_has_suffix (*pkg, ".rpm"))
g_ptr_array_add (repo_pkgs, g_strdup (*pkg));
else
{
glnx_fd_close int fd = -1;
if (!glnx_openat_rdonly (AT_FDCWD, *pkg, TRUE, &fd, error))
return FALSE;
int idx = g_unix_fd_list_append (fd_list, fd, error);
if (idx < 0)
return FALSE;
g_variant_builder_add (&builder, "h", idx);
}
}
*out_fd_idxs = g_variant_ref_sink (g_variant_new ("ah", &builder));
*out_repo_pkgs = g_steal_pointer (&repo_pkgs);
return TRUE;
}
static AsApp *
load_appdata (const gchar *prefix, const gchar *app_name, GError **error)
{
g_autofree gchar *appdata_basename = NULL;
g_autofree gchar *appdata_path = NULL;
g_autoptr(AsApp) app = NULL;
g_autoptr(GPtrArray) problems = NULL;
AsProblemKind problem_kind;
AsProblem *problem;
guint i;
appdata_basename = g_strconcat (app_name,
".appdata.xml",
NULL);
appdata_path = g_build_filename (prefix,
"share",
"appdata",
appdata_basename,
NULL);
g_debug ("Looking for %s", appdata_path);
app = as_app_new ();
if (!as_app_parse_file (app, appdata_path,
AS_APP_PARSE_FLAG_USE_HEURISTICS,
error))
return NULL;
if (as_app_get_kind (app) == AS_APP_KIND_UNKNOWN) {
g_set_error (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"%s has no recognised type",
as_app_get_id (AS_APP (app)));
return NULL;
}
problems = as_app_validate (app,
AS_APP_VALIDATE_FLAG_NO_NETWORK |
AS_APP_VALIDATE_FLAG_RELAX,
error);
if (problems == NULL)
return NULL;
for (i = 0; i < problems->len; i++) {
problem = g_ptr_array_index (problems, i);
problem_kind = as_problem_get_kind (problem);
as_compose_app_log (app,
"AppData problem: %s : %s",
as_problem_kind_to_string (problem_kind),
as_problem_get_message (problem));
}
if (problems->len > 0) {
g_set_error (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"AppData file %s was not valid",
appdata_path);
return NULL;
}
return g_steal_pointer (&app);
}
/**
* rpmostree_load_sysroot
* @sysroot: sysroot path
* @force_peer: Force a peer connection
* @cancellable: A GCancellable
* @out_sysroot: (out) Return location for sysroot
* @error: A pointer to a GError pointer.
*
* Returns: True on success
**/
gboolean
rpmostree_load_sysroot (gchar *sysroot,
gboolean force_peer,
GCancellable *cancellable,
RPMOSTreeSysroot **out_sysroot_proxy,
GPid *out_peer_pid,
GError **error)
{
const char *bus_name = NULL;
glnx_unref_object GDBusConnection *connection = NULL;
glnx_unref_object RPMOSTreeSysroot *sysroot_proxy = NULL;
g_autoptr(GVariantBuilder) options_builder =
g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
_cleanup_peer_ GPid peer_pid = 0;
connection = get_connection_for_path (sysroot, force_peer, &peer_pid,
cancellable, error);
if (connection == NULL)
return FALSE;
if (g_dbus_connection_get_unique_name (connection) != NULL)
bus_name = BUS_NAME;
sysroot_proxy = rpmostree_sysroot_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
bus_name,
"/org/projectatomic/rpmostree1/Sysroot",
NULL,
error);
if (sysroot_proxy == NULL)
return FALSE;
/* Try to register if we can; it doesn't matter much now since the daemon doesn't
* auto-exit, though that might change in the future. But only register if we're active or
* root; the daemon won't allow it otherwise. */
uid_t uid = getuid ();
gboolean should_register;
if (uid == 0)
should_register = TRUE;
else
{
g_autofree char *state = NULL;
if (sd_uid_get_state (uid, &state) >= 0)
should_register = (g_strcmp0 (state, "active") == 0);
else
should_register = FALSE;
}
if (should_register)
{
if (!rpmostree_sysroot_call_register_client_sync (sysroot_proxy,
g_variant_builder_end (options_builder),
cancellable, error))
return FALSE;
}
*out_sysroot_proxy = g_steal_pointer (&sysroot_proxy);
*out_peer_pid = peer_pid; peer_pid = 0;
return TRUE;
}
/**
* self: The SeahorseSource to use as server for the uri
* path: The path to add to the SOUP uri
*
* Returns: A #SoupUri with server, port and paths
*/
static SoupURI*
get_http_server_uri (SeahorseHKPSource *self, const char *path)
{
g_autoptr(SoupURI) uri = NULL;
g_autofree gchar *server = NULL;
gchar *port;
g_object_get (self, "key-server", &server, NULL);
g_return_val_if_fail (server != NULL, NULL);
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
/* If it already has a port then use that */
port = strchr (server, ':');
if (port) {
*port++ = '\0';
soup_uri_set_port (uri, atoi (port));
} else {
/* default HKP port */
soup_uri_set_port (uri, 11371);
}
soup_uri_set_host (uri, server);
soup_uri_set_path (uri, path);
return g_steal_pointer (&uri);
}
static void
on_import_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
source_import_closure *closure = g_task_get_task_data (task);
g_autoptr(GError) error = NULL;
g_autofree gchar *errmsg = NULL;
g_assert (closure->requests > 0);
seahorse_progress_end (closure->cancellable, GUINT_TO_POINTER (closure->requests));
closure->requests--;
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if ((errmsg = get_send_result (message->response_body->data)) != NULL) {
g_task_return_new_error (task, HKP_ERROR_DOMAIN, message->status_code,
"%s", errmsg);
return;
}
/* A successful status from the server is all we want in this case */
if (closure->requests == 0) {
/* We don't know which keys got imported, so just return NULL */
g_task_return_pointer (task, NULL, NULL);
}
}
static void
on_search_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
source_search_closure *closure = g_task_get_task_data (task);
g_autoptr(GError) error = NULL;
GList *keys, *l;
seahorse_progress_end (closure->cancellable, message);
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_task_return_error (task, g_steal_pointer (&error));
return;
}
keys = parse_hkp_index (message->response_body->data);
for (l = keys; l; l = g_list_next (l)) {
g_object_set (l->data, "place", closure->source, NULL);
gcr_simple_collection_add (closure->results, l->data);
}
g_list_free_full (keys, g_object_unref);
g_task_return_boolean (task, TRUE);
}
/* Process a --repo arg; used below, and for the remote builtins */
static OstreeRepo *
parse_repo_option (GOptionContext *context,
const char *repo_path,
gboolean skip_repo_open,
GCancellable *cancellable,
GError **error)
{
g_autoptr(OstreeRepo) repo = NULL;
if (repo_path == NULL)
{
g_autoptr(GError) local_error = NULL;
repo = ostree_repo_new_default ();
if (!ostree_repo_open (repo, cancellable, &local_error))
{
if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{
g_autofree char *help = NULL;
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Command requires a --repo argument");
help = g_option_context_get_help (context, FALSE, NULL);
g_printerr ("%s", help);
}
else
{
g_propagate_error (error, g_steal_pointer (&local_error));
}
return NULL;
}
}
else
{
g_autoptr(GFile) repo_file = g_file_new_for_path (repo_path);
repo = ostree_repo_new (repo_file);
if (!skip_repo_open)
{
if (!ostree_repo_open (repo, cancellable, error))
return NULL;
}
}
return g_steal_pointer (&repo);
}
/* TODO: Docs. Return value is only valid as long as @txt is. Reference: RFC 6763, §6. */
GHashTable *
_ostree_txt_records_parse (AvahiStringList *txt)
{
AvahiStringList *l;
g_autoptr(GHashTable) out = NULL;
out = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_bytes_unref);
for (l = txt; l != NULL; l = avahi_string_list_get_next (l))
{
const guint8 *txt;
gsize txt_len;
const gchar *key;
const guint8 *value;
gsize key_len, value_len;
g_autofree gchar *key_allocated = NULL;
g_autoptr(GBytes) value_allocated = NULL;
txt = avahi_string_list_get_text (l);
txt_len = avahi_string_list_get_size (l);
if (!parse_txt_record (txt, txt_len, &key, &key_len, &value, &value_len))
{
g_debug ("Ignoring invalid TXT record of length %" G_GSIZE_FORMAT,
txt_len);
continue;
}
key_allocated = g_ascii_strdown (key, key_len);
if (g_hash_table_lookup_extended (out, key_allocated, NULL, NULL))
{
g_debug ("Ignoring duplicate TXT record ‘%s’", key_allocated);
continue;
}
/* Distinguish between the case where the entire record is the key
* (value == NULL) and the case where the record is the key + ‘=’ and the
* value is empty (value != NULL && value_len == 0). */
if (value != NULL)
value_allocated = g_bytes_new_static (value, value_len);
g_hash_table_insert (out, g_steal_pointer (&key_allocated), g_steal_pointer (&value_allocated));
}
return g_steal_pointer (&out);
}
