From 6f0f7d1b40a8fa8d46a2d6f4317600001cdbbb18 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:57:27 +0200 Subject: Adding upstream version 43.5. Signed-off-by: Daniel Baumann --- lib/gs-plugin.c | 2187 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2187 insertions(+) create mode 100644 lib/gs-plugin.c (limited to 'lib/gs-plugin.c') diff --git a/lib/gs-plugin.c b/lib/gs-plugin.c new file mode 100644 index 0000000..51e0f7e --- /dev/null +++ b/lib/gs-plugin.c @@ -0,0 +1,2187 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * vi:set noexpandtab tabstop=8 shiftwidth=8: + * + * Copyright (C) 2013-2016 Richard Hughes + * Copyright (C) 2014-2020 Kalev Lember + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +/** + * SECTION:gs-plugin + * @title: GsPlugin Helpers + * @include: gnome-software.h + * @stability: Unstable + * @short_description: Runtime-loaded modules providing functionality + * + * Plugins are modules that are loaded at runtime to provide information + * about requests and to service user actions like installing, removing + * and updating. + * This allows different distributions to pick and choose how the + * application installer gathers data. + * + * Plugins also have a priority system where the largest number gets + * run first. That means if one plugin requires some property or + * metadata set by another plugin then it **must** depend on the other + * plugin to be run in the correct order. + * + * As a general rule, try to make plugins as small and self-contained + * as possible and remember to cache as much data as possible for speed. + * Memory is cheap, time less so. + */ + +#include "config.h" + +#include +#include +#include + +#include "gs-app-list-private.h" +#include "gs-download-utils.h" +#include "gs-enums.h" +#include "gs-os-release.h" +#include "gs-plugin-private.h" +#include "gs-plugin.h" +#include "gs-utils.h" + +typedef struct +{ + GHashTable *cache; + GMutex cache_mutex; + GModule *module; + GsPluginFlags flags; + GPtrArray *rules[GS_PLUGIN_RULE_LAST]; + GHashTable *vfuncs; /* string:pointer */ + GMutex vfuncs_mutex; + gboolean enabled; + guint interactive_cnt; + GMutex interactive_mutex; + gchar *language; /* allow-none */ + gchar *name; + gchar *appstream_id; + guint scale; + guint order; + guint priority; + guint timer_id; + GMutex timer_mutex; + GNetworkMonitor *network_monitor; + + GDBusConnection *session_bus_connection; /* (owned) (not nullable) */ + GDBusConnection *system_bus_connection; /* (owned) (not nullable) */ +} GsPluginPrivate; + +G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GsPlugin, gs_plugin, G_TYPE_OBJECT) + +G_DEFINE_QUARK (gs-plugin-error-quark, gs_plugin_error) + +typedef enum { + PROP_FLAGS = 1, + PROP_SESSION_BUS_CONNECTION, + PROP_SYSTEM_BUS_CONNECTION, +} GsPluginProperty; + +static GParamSpec *obj_props[PROP_SYSTEM_BUS_CONNECTION + 1] = { NULL, }; + +enum { + SIGNAL_UPDATES_CHANGED, + SIGNAL_STATUS_CHANGED, + SIGNAL_RELOAD, + SIGNAL_REPORT_EVENT, + SIGNAL_ALLOW_UPDATES, + SIGNAL_BASIC_AUTH_START, + SIGNAL_REPOSITORY_CHANGED, + SIGNAL_ASK_UNTRUSTED, + SIGNAL_LAST +}; + +static guint signals [SIGNAL_LAST] = { 0 }; + +typedef const gchar **(*GsPluginGetDepsFunc) (GsPlugin *plugin); + +/** + * gs_plugin_status_to_string: + * @status: a #GsPluginStatus, e.g. %GS_PLUGIN_STATUS_DOWNLOADING + * + * Converts the #GsPluginStatus enum to a string. + * + * Returns: the string representation, or "unknown" + * + * Since: 3.22 + **/ +const gchar * +gs_plugin_status_to_string (GsPluginStatus status) +{ + if (status == GS_PLUGIN_STATUS_WAITING) + return "waiting"; + if (status == GS_PLUGIN_STATUS_FINISHED) + return "finished"; + if (status == GS_PLUGIN_STATUS_SETUP) + return "setup"; + if (status == GS_PLUGIN_STATUS_DOWNLOADING) + return "downloading"; + if (status == GS_PLUGIN_STATUS_QUERYING) + return "querying"; + if (status == GS_PLUGIN_STATUS_INSTALLING) + return "installing"; + if (status == GS_PLUGIN_STATUS_REMOVING) + return "removing"; + return "unknown"; +} + +/** + * gs_plugin_set_name: + * @plugin: a #GsPlugin + * @name: a plugin name + * + * Sets the name of the plugin. + * + * Plugins are not required to set the plugin name as it is automatically set + * from the `.so` filename. + * + * Since: 3.26 + **/ +void +gs_plugin_set_name (GsPlugin *plugin, const gchar *name) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + if (priv->name != NULL) + g_free (priv->name); + priv->name = g_strdup (name); +} + +/** + * gs_plugin_create: + * @filename: an absolute filename + * @session_bus_connection: (not nullable) (transfer none): a session bus + * connection to use + * @system_bus_connection: (not nullable) (transfer none): a system bus + * connection to use + * @error: a #GError, or %NULL + * + * Creates a new plugin from an external module. + * + * Returns: (transfer full): the #GsPlugin, or %NULL on error + * + * Since: 43 + **/ +GsPlugin * +gs_plugin_create (const gchar *filename, + GDBusConnection *session_bus_connection, + GDBusConnection *system_bus_connection, + GError **error) +{ + GsPlugin *plugin = NULL; + GsPluginPrivate *priv; + g_autofree gchar *basename = NULL; + GModule *module = NULL; + GType (*query_type_function) (void) = NULL; + GType plugin_type; + + /* get the plugin name from the basename */ + basename = g_path_get_basename (filename); + if (!g_str_has_prefix (basename, "libgs_plugin_")) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_FAILED, + "plugin filename has wrong prefix: %s", + filename); + return NULL; + } + g_strdelimit (basename, ".", '\0'); + + /* create new plugin */ + module = g_module_open (filename, 0); + if (module == NULL || + !g_module_symbol (module, "gs_plugin_query_type", (gpointer *) &query_type_function)) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_FAILED, + "failed to open plugin %s: %s", + filename, g_module_error ()); + if (module != NULL) + g_module_close (module); + return NULL; + } + + /* Make the module resident so it can’t be unloaded: without using a + * full #GTypePlugin implementation for the modules, it’s not safe to + * re-load a module and re-register its types with GObject, as that will + * confuse the GType system. */ + g_module_make_resident (module); + + plugin_type = query_type_function (); + g_assert (g_type_is_a (plugin_type, GS_TYPE_PLUGIN)); + + plugin = g_object_new (plugin_type, + "session-bus-connection", session_bus_connection, + "system-bus-connection", system_bus_connection, + NULL); + priv = gs_plugin_get_instance_private (plugin); + priv->module = g_steal_pointer (&module); + + gs_plugin_set_name (plugin, basename + 13); + return plugin; +} + +static void +gs_plugin_dispose (GObject *object) +{ + GsPlugin *plugin = GS_PLUGIN (object); + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + + g_clear_object (&priv->session_bus_connection); + g_clear_object (&priv->system_bus_connection); + + G_OBJECT_CLASS (gs_plugin_parent_class)->dispose (object); +} + +static void +gs_plugin_finalize (GObject *object) +{ + GsPlugin *plugin = GS_PLUGIN (object); + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + guint i; + + for (i = 0; i < GS_PLUGIN_RULE_LAST; i++) + g_ptr_array_unref (priv->rules[i]); + + if (priv->timer_id > 0) + g_source_remove (priv->timer_id); + g_free (priv->name); + g_free (priv->appstream_id); + g_free (priv->language); + if (priv->network_monitor != NULL) + g_object_unref (priv->network_monitor); + g_hash_table_unref (priv->cache); + g_hash_table_unref (priv->vfuncs); + g_mutex_clear (&priv->cache_mutex); + g_mutex_clear (&priv->interactive_mutex); + g_mutex_clear (&priv->timer_mutex); + g_mutex_clear (&priv->vfuncs_mutex); + if (priv->module != NULL) + g_module_close (priv->module); + + G_OBJECT_CLASS (gs_plugin_parent_class)->finalize (object); +} + +/** + * gs_plugin_get_symbol: (skip) + * @plugin: a #GsPlugin + * @function_name: a symbol name + * + * Gets the symbol from the module that backs the plugin. If the plugin is not + * enabled then no symbol is returned. + * + * Returns: the pointer to the symbol, or %NULL + * + * Since: 3.22 + **/ +gpointer +gs_plugin_get_symbol (GsPlugin *plugin, const gchar *function_name) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + gpointer func = NULL; + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->vfuncs_mutex); + + g_return_val_if_fail (function_name != NULL, NULL); + + /* disabled plugins shouldn't be checked */ + if (!priv->enabled) + return NULL; + + /* look up the symbol from the cache */ + if (g_hash_table_lookup_extended (priv->vfuncs, function_name, NULL, &func)) + return func; + + /* look up the symbol using the elf headers */ + g_module_symbol (priv->module, function_name, &func); + g_hash_table_insert (priv->vfuncs, g_strdup (function_name), func); + + return func; +} + +/** + * gs_plugin_get_enabled: + * @plugin: a #GsPlugin + * + * Gets if the plugin is enabled. + * + * Returns: %TRUE if enabled + * + * Since: 3.22 + **/ +gboolean +gs_plugin_get_enabled (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->enabled; +} + +/** + * gs_plugin_set_enabled: + * @plugin: a #GsPlugin + * @enabled: the enabled state + * + * Enables or disables a plugin. + * This is normally only called from the init function for a #GsPlugin instance. + * + * Since: 3.22 + **/ +void +gs_plugin_set_enabled (GsPlugin *plugin, gboolean enabled) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + priv->enabled = enabled; +} + +void +gs_plugin_interactive_inc (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->interactive_mutex); + priv->interactive_cnt++; + gs_plugin_add_flags (plugin, GS_PLUGIN_FLAGS_INTERACTIVE); +} + +void +gs_plugin_interactive_dec (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_autoptr(GMutexLocker) locker = g_mutex_locker_new (&priv->interactive_mutex); + if (priv->interactive_cnt > 0) + priv->interactive_cnt--; + if (priv->interactive_cnt == 0) + gs_plugin_remove_flags (plugin, GS_PLUGIN_FLAGS_INTERACTIVE); +} + +/** + * gs_plugin_get_name: + * @plugin: a #GsPlugin + * + * Gets the plugin name. + * + * Returns: a string, e.g. "fwupd" + * + * Since: 3.22 + **/ +const gchar * +gs_plugin_get_name (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->name; +} + +/** + * gs_plugin_get_appstream_id: + * @plugin: a #GsPlugin + * + * Gets the plugin AppStream ID. + * + * Returns: a string, e.g. `org.gnome.Software.Plugin.Epiphany` + * + * Since: 3.24 + **/ +const gchar * +gs_plugin_get_appstream_id (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->appstream_id; +} + +/** + * gs_plugin_set_appstream_id: + * @plugin: a #GsPlugin + * @appstream_id: an appstream ID, e.g. `org.gnome.Software.Plugin.Epiphany` + * + * Sets the plugin AppStream ID. + * + * Since: 3.24 + **/ +void +gs_plugin_set_appstream_id (GsPlugin *plugin, const gchar *appstream_id) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_free (priv->appstream_id); + priv->appstream_id = g_strdup (appstream_id); +} + +/** + * gs_plugin_get_scale: + * @plugin: a #GsPlugin + * + * Gets the window scale factor. + * + * Returns: the factor, usually 1 for standard screens or 2 for HiDPI + * + * Since: 3.22 + **/ +guint +gs_plugin_get_scale (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->scale; +} + +/** + * gs_plugin_set_scale: + * @plugin: a #GsPlugin + * @scale: the window scale factor, usually 1 for standard screens or 2 for HiDPI + * + * Sets the window scale factor. + * + * Since: 3.22 + **/ +void +gs_plugin_set_scale (GsPlugin *plugin, guint scale) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + priv->scale = scale; +} + +/** + * gs_plugin_get_order: + * @plugin: a #GsPlugin + * + * Gets the plugin order, where higher numbers are run after lower + * numbers. + * + * Returns: the integer value + * + * Since: 3.22 + **/ +guint +gs_plugin_get_order (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->order; +} + +/** + * gs_plugin_set_order: + * @plugin: a #GsPlugin + * @order: a integer value + * + * Sets the plugin order, where higher numbers are run after lower + * numbers. + * + * Since: 3.22 + **/ +void +gs_plugin_set_order (GsPlugin *plugin, guint order) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + priv->order = order; +} + +/** + * gs_plugin_get_priority: + * @plugin: a #GsPlugin + * + * Gets the plugin priority, where higher values will be chosen where + * multiple #GsApp's match a specific rule. + * + * Returns: the integer value + * + * Since: 3.22 + **/ +guint +gs_plugin_get_priority (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->priority; +} + +/** + * gs_plugin_set_priority: + * @plugin: a #GsPlugin + * @priority: a integer value + * + * Sets the plugin priority, where higher values will be chosen where + * multiple #GsApp's match a specific rule. + * + * Since: 3.22 + **/ +void +gs_plugin_set_priority (GsPlugin *plugin, guint priority) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + priv->priority = priority; +} + +/** + * gs_plugin_get_language: + * @plugin: a #GsPlugin + * + * Gets the user language from the locale. This is the first component of the + * locale. + * + * Typically you should use the full locale rather than the language, as the + * same language can be used quite differently in different territories. + * + * Returns: the language string, e.g. `fr` + * + * Since: 3.22 + **/ +const gchar * +gs_plugin_get_language (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->language; +} + +/** + * gs_plugin_set_language: + * @plugin: a #GsPlugin + * @language: a language string, e.g. "fr" + * + * Sets the plugin language. + * + * Since: 3.22 + **/ +void +gs_plugin_set_language (GsPlugin *plugin, const gchar *language) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_free (priv->language); + priv->language = g_strdup (language); +} + +/** + * gs_plugin_set_network_monitor: + * @plugin: a #GsPlugin + * @monitor: a #GNetworkMonitor + * + * Sets the network monitor so that plugins can check the state of the network. + * + * Since: 3.28 + **/ +void +gs_plugin_set_network_monitor (GsPlugin *plugin, GNetworkMonitor *monitor) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_set_object (&priv->network_monitor, monitor); +} + +/** + * gs_plugin_get_network_available: + * @plugin: a #GsPlugin + * + * Gets whether a network connectivity is available. + * + * Returns: %TRUE if a network is available. + * + * Since: 3.28 + **/ +gboolean +gs_plugin_get_network_available (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + if (priv->network_monitor == NULL) { + g_debug ("no network monitor, so returning network-available=TRUE"); + return TRUE; + } + return g_network_monitor_get_network_available (priv->network_monitor); +} + +/** + * gs_plugin_has_flags: + * @plugin: a #GsPlugin + * @flags: a #GsPluginFlags, e.g. %GS_PLUGIN_FLAGS_INTERACTIVE + * + * Finds out if a plugin has a specific flag set. + * + * Returns: TRUE if the flag is set + * + * Since: 3.22 + **/ +gboolean +gs_plugin_has_flags (GsPlugin *plugin, GsPluginFlags flags) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return (priv->flags & flags) > 0; +} + +/** + * gs_plugin_add_flags: + * @plugin: a #GsPlugin + * @flags: a #GsPluginFlags, e.g. %GS_PLUGIN_FLAGS_INTERACTIVE + * + * Adds specific flags to the plugin. + * + * Since: 3.22 + **/ +void +gs_plugin_add_flags (GsPlugin *plugin, GsPluginFlags flags) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + priv->flags |= flags; + g_object_notify_by_pspec (G_OBJECT (plugin), obj_props[PROP_FLAGS]); +} + +/** + * gs_plugin_remove_flags: + * @plugin: a #GsPlugin + * @flags: a #GsPluginFlags, e.g. %GS_PLUGIN_FLAGS_INTERACTIVE + * + * Removes specific flags from the plugin. + * + * Since: 3.22 + **/ +void +gs_plugin_remove_flags (GsPlugin *plugin, GsPluginFlags flags) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + priv->flags &= ~flags; + g_object_notify_by_pspec (G_OBJECT (plugin), obj_props[PROP_FLAGS]); +} + +/** + * gs_plugin_add_rule: + * @plugin: a #GsPlugin + * @rule: a #GsPluginRule, e.g. %GS_PLUGIN_RULE_CONFLICTS + * @name: a plugin name, e.g. "appstream" + * + * If the plugin name is found, the rule will be used to sort the plugin list, + * for example the plugin specified by @name will be ordered after this plugin + * when %GS_PLUGIN_RULE_RUN_AFTER is used. + * + * NOTE: The depsolver is iterative and may not solve overly-complicated rules; + * If depsolving fails then gnome-software will not start. + * + * Since: 3.22 + **/ +void +gs_plugin_add_rule (GsPlugin *plugin, GsPluginRule rule, const gchar *name) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_ptr_array_add (priv->rules[rule], g_strdup (name)); +} + +/** + * gs_plugin_get_rules: + * @plugin: a #GsPlugin + * @rule: a #GsPluginRule, e.g. %GS_PLUGIN_RULE_CONFLICTS + * + * Gets the plugin IDs that should be run after this plugin. + * + * Returns: (element-type utf8) (transfer none): the list of plugin names, e.g. ['appstream'] + * + * Since: 3.22 + **/ +GPtrArray * +gs_plugin_get_rules (GsPlugin *plugin, GsPluginRule rule) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + return priv->rules[rule]; +} + +/** + * gs_plugin_check_distro_id: + * @plugin: a #GsPlugin + * @distro_id: a distro ID, e.g. "fedora" + * + * Checks if the distro is compatible. + * + * Returns: %TRUE if compatible + * + * Since: 3.22 + **/ +gboolean +gs_plugin_check_distro_id (GsPlugin *plugin, const gchar *distro_id) +{ + g_autoptr(GError) error = NULL; + g_autoptr(GsOsRelease) os_release = NULL; + const gchar *id = NULL; + + /* load /etc/os-release */ + os_release = gs_os_release_new (&error); + if (os_release == NULL) { + g_debug ("could not parse os-release: %s", error->message); + return FALSE; + } + + /* check that we are running on Fedora */ + id = gs_os_release_get_id (os_release); + if (id == NULL) { + g_debug ("could not get distro ID"); + return FALSE; + } + if (g_strcmp0 (id, distro_id) != 0) + return FALSE; + return TRUE; +} + +typedef struct { + GWeakRef plugin_weak; /* (element-type GsPlugin) */ + GsApp *app; /* (owned) */ + GsPluginStatus status; + guint percentage; +} GsPluginStatusHelper; + +static void +gs_plugin_status_helper_free (GsPluginStatusHelper *helper) +{ + g_weak_ref_clear (&helper->plugin_weak); + g_clear_object (&helper->app); + g_slice_free (GsPluginStatusHelper, helper); +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GsPluginStatusHelper, gs_plugin_status_helper_free) + +static gboolean +gs_plugin_status_update_cb (gpointer user_data) +{ + GsPluginStatusHelper *helper = (GsPluginStatusHelper *) user_data; + g_autoptr(GsPlugin) plugin = NULL; + + /* Does the plugin still exist? */ + plugin = g_weak_ref_get (&helper->plugin_weak); + + if (plugin != NULL) + g_signal_emit (plugin, + signals[SIGNAL_STATUS_CHANGED], 0, + helper->app, + helper->status); + + return G_SOURCE_REMOVE; +} + +/** + * gs_plugin_status_update: + * @plugin: a #GsPlugin + * @app: a #GsApp, or %NULL + * @status: a #GsPluginStatus, e.g. %GS_PLUGIN_STATUS_DOWNLOADING + * + * Update the state of the plugin so any UI can be updated. + * + * Since: 3.22 + **/ +void +gs_plugin_status_update (GsPlugin *plugin, GsApp *app, GsPluginStatus status) +{ + g_autoptr(GsPluginStatusHelper) helper = NULL; + g_autoptr(GSource) idle_source = NULL; + + helper = g_slice_new0 (GsPluginStatusHelper); + g_weak_ref_init (&helper->plugin_weak, plugin); + helper->status = status; + if (app != NULL) + helper->app = g_object_ref (app); + + idle_source = g_idle_source_new (); + g_source_set_callback (idle_source, gs_plugin_status_update_cb, g_steal_pointer (&helper), (GDestroyNotify) gs_plugin_status_helper_free); + g_source_attach (idle_source, NULL); +} + +typedef struct { + GsPlugin *plugin; + gchar *remote; + gchar *realm; + GCallback callback; + gpointer user_data; +} GsPluginBasicAuthHelper; + +static gboolean +gs_plugin_basic_auth_start_cb (gpointer user_data) +{ + GsPluginBasicAuthHelper *helper = user_data; + g_signal_emit (helper->plugin, + signals[SIGNAL_BASIC_AUTH_START], 0, + helper->remote, + helper->realm, + helper->callback, + helper->user_data); + g_free (helper->remote); + g_free (helper->realm); + g_slice_free (GsPluginBasicAuthHelper, helper); + return FALSE; +} + +/** + * gs_plugin_basic_auth_start: + * @plugin: a #GsPlugin + * @remote: a string + * @realm: a string + * @callback: callback to invoke to submit the user/password + * @user_data: callback data to pass to the callback + * + * Emit the basic-auth-start signal in the main thread. + * + * Since: 3.38 + **/ +void +gs_plugin_basic_auth_start (GsPlugin *plugin, + const gchar *remote, + const gchar *realm, + GCallback callback, + gpointer user_data) +{ + GsPluginBasicAuthHelper *helper; + g_autoptr(GSource) idle_source = NULL; + + helper = g_slice_new0 (GsPluginBasicAuthHelper); + helper->plugin = plugin; + helper->remote = g_strdup (remote); + helper->realm = g_strdup (realm); + helper->callback = callback; + helper->user_data = user_data; + + idle_source = g_idle_source_new (); + g_source_set_callback (idle_source, gs_plugin_basic_auth_start_cb, helper, NULL); + g_source_attach (idle_source, NULL); +} + +static gboolean +gs_plugin_app_launch_cb (gpointer user_data) +{ + GAppInfo *appinfo = (GAppInfo *) user_data; + GdkDisplay *display; + g_autoptr(GAppLaunchContext) context = NULL; + g_autoptr(GError) error = NULL; + + display = gdk_display_get_default (); + context = G_APP_LAUNCH_CONTEXT (gdk_display_get_app_launch_context (display)); + if (!g_app_info_launch (appinfo, NULL, context, &error)) + g_warning ("Failed to launch: %s", error->message); + + return G_SOURCE_REMOVE; +} + +/** + * gs_plugin_app_launch: + * @plugin: a #GsPlugin + * @app: a #GsApp + * @error: a #GError, or %NULL + * + * Launches the application using #GAppInfo. + * + * Returns: %TRUE for success + * + * Since: 3.22 + **/ +gboolean +gs_plugin_app_launch (GsPlugin *plugin, GsApp *app, GError **error) +{ + const gchar *desktop_id; + g_autoptr(GAppInfo) appinfo = NULL; + + desktop_id = gs_app_get_launchable (app, AS_LAUNCHABLE_KIND_DESKTOP_ID); + if (desktop_id == NULL) + desktop_id = gs_app_get_id (app); + if (desktop_id == NULL) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no such desktop file: %s", + desktop_id); + return FALSE; + } + appinfo = G_APP_INFO (gs_utils_get_desktop_app_info (desktop_id)); + if (appinfo == NULL) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no such desktop file: %s", + desktop_id); + return FALSE; + } + g_idle_add_full (G_PRIORITY_DEFAULT, + gs_plugin_app_launch_cb, + g_object_ref (appinfo), + (GDestroyNotify) g_object_unref); + return TRUE; +} + +static GDesktopAppInfo * +check_directory_for_desktop_file (GsPlugin *plugin, + GsApp *app, + GsPluginPickDesktopFileCallback cb, + gpointer user_data, + const gchar *desktop_id, + const gchar *data_dir) +{ + g_autofree gchar *filename = NULL; + g_autoptr(GKeyFile) key_file = NULL; + + filename = g_build_filename (data_dir, "applications", desktop_id, NULL); + key_file = g_key_file_new (); + + if (g_key_file_load_from_file (key_file, filename, G_KEY_FILE_KEEP_TRANSLATIONS, NULL) && + cb (plugin, app, filename, key_file)) { + g_autoptr(GDesktopAppInfo) appinfo = NULL; + appinfo = g_desktop_app_info_new_from_keyfile (key_file); + if (appinfo != NULL) + return g_steal_pointer (&appinfo); + g_debug ("Failed to load '%s' as a GDesktopAppInfo", filename); + return NULL; + } + + if (!g_str_has_suffix (desktop_id, ".desktop")) { + g_autofree gchar *desktop_filename = g_strconcat (filename, ".desktop", NULL); + if (g_key_file_load_from_file (key_file, desktop_filename, G_KEY_FILE_KEEP_TRANSLATIONS, NULL) && + cb (plugin, app, desktop_filename, key_file)) { + g_autoptr(GDesktopAppInfo) appinfo = NULL; + appinfo = g_desktop_app_info_new_from_keyfile (key_file); + if (appinfo != NULL) + return g_steal_pointer (&appinfo); + g_debug ("Failed to load '%s' as a GDesktopAppInfo", desktop_filename); + return NULL; + } + } + + return NULL; +} + +/** + * gs_plugin_app_launch_filtered: + * @plugin: a #GsPlugin + * @app: a #GsApp to launch + * @cb: a callback to pick the correct .desktop file + * @user_data: (closure cb) (scope call): user data for the @cb + * @error: a #GError, or %NULL + * + * Launches application @app, using the .desktop file picked by the @cb. + * This can help in case multiple versions of the @app are installed + * in the system (like a Flatpak and RPM versions). + * + * Returns: %TRUE on success + * + * Since: 43 + **/ +gboolean +gs_plugin_app_launch_filtered (GsPlugin *plugin, + GsApp *app, + GsPluginPickDesktopFileCallback cb, + gpointer user_data, + GError **error) +{ + const gchar *desktop_id; + g_autoptr(GDesktopAppInfo) appinfo = NULL; + + g_return_val_if_fail (GS_IS_PLUGIN (plugin), FALSE); + g_return_val_if_fail (GS_IS_APP (app), FALSE); + g_return_val_if_fail (cb != NULL, FALSE); + + desktop_id = gs_app_get_launchable (app, AS_LAUNCHABLE_KIND_DESKTOP_ID); + if (desktop_id == NULL) + desktop_id = gs_app_get_id (app); + if (desktop_id == NULL) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no desktop file for app: %s", + gs_app_get_name (app)); + return FALSE; + } + + /* First, the configs. Highest priority: the user's ~/.config */ + appinfo = check_directory_for_desktop_file (plugin, app, cb, user_data, desktop_id, g_get_user_config_dir ()); + + if (appinfo == NULL) { + /* Next, the system configs (/etc/xdg, and so on). */ + const gchar * const *dirs; + dirs = g_get_system_config_dirs (); + for (guint i = 0; dirs[i] && appinfo == NULL; i++) { + appinfo = check_directory_for_desktop_file (plugin, app, cb, user_data, desktop_id, dirs[i]); + } + } + + if (appinfo == NULL) { + /* Now the data. Highest priority: the user's ~/.local/share/applications */ + appinfo = check_directory_for_desktop_file (plugin, app, cb, user_data, desktop_id, g_get_user_data_dir ()); + } + + if (appinfo == NULL) { + /* Following that, XDG_DATA_DIRS/applications, in order */ + const gchar * const *dirs; + dirs = g_get_system_data_dirs (); + for (guint i = 0; dirs[i] && appinfo == NULL; i++) { + appinfo = check_directory_for_desktop_file (plugin, app, cb, user_data, desktop_id, dirs[i]); + } + } + + if (appinfo == NULL) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "no appropriate desktop file found: %s", + desktop_id); + return FALSE; + } + + g_idle_add_full (G_PRIORITY_DEFAULT, + gs_plugin_app_launch_cb, + g_object_ref (appinfo), + (GDestroyNotify) g_object_unref); + + return TRUE; +} + +static void +weak_ref_free (GWeakRef *weak) +{ + g_weak_ref_clear (weak); + g_free (weak); +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GWeakRef, weak_ref_free) + +/* @obj is a gpointer rather than a GObject* to avoid the need for casts */ +static GWeakRef * +weak_ref_new (gpointer obj) +{ + g_autoptr(GWeakRef) weak = g_new0 (GWeakRef, 1); + g_weak_ref_init (weak, obj); + return g_steal_pointer (&weak); +} + +static gboolean +gs_plugin_updates_changed_cb (gpointer user_data) +{ + GWeakRef *plugin_weak = user_data; + g_autoptr(GsPlugin) plugin = NULL; + + plugin = g_weak_ref_get (plugin_weak); + if (plugin != NULL) + g_signal_emit (plugin, signals[SIGNAL_UPDATES_CHANGED], 0); + + return G_SOURCE_REMOVE; +} + +/** + * gs_plugin_updates_changed: + * @plugin: a #GsPlugin + * + * Emit a signal that tells the plugin loader that the list of updates + * may have changed. + * + * Since: 3.22 + **/ +void +gs_plugin_updates_changed (GsPlugin *plugin) +{ + g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, gs_plugin_updates_changed_cb, + weak_ref_new (plugin), (GDestroyNotify) weak_ref_free); +} + +static gboolean +gs_plugin_reload_cb (gpointer user_data) +{ + GWeakRef *plugin_weak = user_data; + g_autoptr(GsPlugin) plugin = NULL; + + plugin = g_weak_ref_get (plugin_weak); + if (plugin != NULL) + g_signal_emit (plugin, signals[SIGNAL_RELOAD], 0); + + return G_SOURCE_REMOVE; +} + +/** + * gs_plugin_reload: + * @plugin: a #GsPlugin + * + * Plugins that call this function should expect that all panels will + * reload after a small delay, causing mush flashing, wailing and + * gnashing of teeth. + * + * Plugins should not call this unless absolutely required. + * + * Since: 3.22 + **/ +void +gs_plugin_reload (GsPlugin *plugin) +{ + g_debug ("emitting %s::reload in idle", gs_plugin_get_name (plugin)); + g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, gs_plugin_reload_cb, + weak_ref_new (plugin), (GDestroyNotify) weak_ref_free); +} + +typedef struct { + GsPlugin *plugin; + GsApp *app; +} GsPluginDownloadHelper; + +static void +download_file_progress_cb (gsize total_written_bytes, + gsize total_download_size, + gpointer user_data) +{ + GsPluginDownloadHelper *helper = user_data; + guint percentage; + + if (total_download_size > 0) + percentage = (guint) ((100 * total_written_bytes) / total_download_size); + else + percentage = 0; + + g_debug ("%s progress: %u%%", gs_app_get_id (helper->app), percentage); + gs_app_set_progress (helper->app, percentage); + gs_plugin_status_update (helper->plugin, + helper->app, + GS_PLUGIN_STATUS_DOWNLOADING); + +} + +static void +async_result_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GAsyncResult **result_out = user_data; + + g_assert (*result_out == NULL); + *result_out = g_object_ref (result); + g_main_context_wakeup (g_main_context_get_thread_default ()); +} + +/** + * gs_plugin_download_file: + * @plugin: a #GsPlugin + * @app: a #GsApp, or %NULL + * @uri: a remote URI + * @filename: a local filename + * @cancellable: a #GCancellable, or %NULL + * @error: a #GError, or %NULL + * + * Downloads data and saves it to a file. + * + * Returns: %TRUE for success + * + * Since: 3.22 + **/ +gboolean +gs_plugin_download_file (GsPlugin *plugin, + GsApp *app, + const gchar *uri, + const gchar *filename, + GCancellable *cancellable, + GError **error) +{ + g_autoptr(SoupSession) soup_session = NULL; + g_autoptr(GFile) output_file = NULL; + g_autoptr(GAsyncResult) result = NULL; + g_autoptr(GMainContext) context = g_main_context_new (); + g_autoptr(GMainContextPusher) context_pusher = g_main_context_pusher_new (context); + GsPluginDownloadHelper helper; + g_autoptr(GError) local_error = NULL; + + helper.plugin = plugin; + helper.app = app; + + soup_session = gs_build_soup_session (); + + /* Do the download. */ + output_file = g_file_new_for_path (filename); + gs_download_file_async (soup_session, uri, output_file, + G_PRIORITY_LOW, + download_file_progress_cb, &helper, + cancellable, async_result_cb, &result); + + while (result == NULL) + g_main_context_iteration (context, TRUE); + + if (!gs_download_file_finish (soup_session, result, &local_error) && + !g_error_matches (local_error, GS_DOWNLOAD_ERROR, GS_DOWNLOAD_ERROR_NOT_MODIFIED)) { + g_set_error_literal (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_DOWNLOAD_FAILED, + local_error->message); + return FALSE; + } + + return TRUE; +} + +static gchar * +gs_plugin_download_rewrite_resource_uri (GsPlugin *plugin, + GsApp *app, + const gchar *uri, + GCancellable *cancellable, + GError **error) +{ + g_autofree gchar *cachefn = NULL; + + /* local files */ + if (g_str_has_prefix (uri, "file://")) + uri += 7; + if (g_str_has_prefix (uri, "/")) { + if (!g_file_test (uri, G_FILE_TEST_EXISTS)) { + g_set_error (error, + GS_PLUGIN_ERROR, + GS_PLUGIN_ERROR_NOT_SUPPORTED, + "Failed to find file: %s", uri); + return NULL; + } + return g_strdup (uri); + } + + /* get cache location */ + cachefn = gs_utils_get_cache_filename ("cssresource", uri, + GS_UTILS_CACHE_FLAG_WRITEABLE | + GS_UTILS_CACHE_FLAG_USE_HASH | + GS_UTILS_CACHE_FLAG_CREATE_DIRECTORY, + error); + if (cachefn == NULL) + return NULL; + + /* already exists */ + if (g_file_test (cachefn, G_FILE_TEST_EXISTS)) + return g_steal_pointer (&cachefn); + + /* download */ + if (!gs_plugin_download_file (plugin, app, uri, cachefn, + cancellable, error)) { + return NULL; + } + return g_steal_pointer (&cachefn); +} + +/** + * gs_plugin_download_rewrite_resource: + * @plugin: a #GsPlugin + * @app: a #GsApp, or %NULL + * @resource: the CSS resource + * @cancellable: a #GCancellable, or %NULL + * @error: a #GError, or %NULL + * + * Downloads remote assets and rewrites a CSS resource to use cached local URIs. + * + * Returns: %TRUE for success + * + * Since: 3.26 + **/ +gchar * +gs_plugin_download_rewrite_resource (GsPlugin *plugin, + GsApp *app, + const gchar *resource, + GCancellable *cancellable, + GError **error) +{ + guint start = 0; + g_autoptr(GString) resource_str = g_string_new (resource); + g_autoptr(GString) str = g_string_new (NULL); + + g_return_val_if_fail (GS_IS_PLUGIN (plugin), NULL); + g_return_val_if_fail (resource != NULL, NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + /* replace datadir */ + as_gstring_replace (resource_str, "@datadir@", DATADIR); + resource = resource_str->str; + + /* look in string for any url() links */ + for (guint i = 0; resource[i] != '\0'; i++) { + if (i > 4 && strncmp (resource + i - 4, "url(", 4) == 0) { + start = i; + continue; + } + if (start == 0) { + g_string_append_c (str, resource[i]); + continue; + } + if (resource[i] == ')') { + guint len; + g_autofree gchar *cachefn = NULL; + g_autofree gchar *uri = NULL; + + /* remove optional single quotes */ + if (resource[start] == '\'' || resource[start] == '"') + start++; + len = i - start; + if (i > 0 && (resource[i - 1] == '\'' || resource[i - 1] == '"')) + len--; + uri = g_strndup (resource + start, len); + + /* download them to per-user cache */ + cachefn = gs_plugin_download_rewrite_resource_uri (plugin, + app, + uri, + cancellable, + error); + if (cachefn == NULL) + return NULL; + g_string_append_printf (str, "'file://%s'", cachefn); + g_string_append_c (str, resource[i]); + start = 0; + } + } + return g_strdup (str->str); +} + +/** + * gs_plugin_cache_lookup: + * @plugin: a #GsPlugin + * @key: a string + * + * Looks up an application object from the per-plugin cache + * + * Returns: (transfer full) (nullable): the #GsApp, or %NULL + * + * Since: 3.22 + **/ +GsApp * +gs_plugin_cache_lookup (GsPlugin *plugin, const gchar *key) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + GsApp *app; + g_autoptr(GMutexLocker) locker = NULL; + + g_return_val_if_fail (GS_IS_PLUGIN (plugin), NULL); + g_return_val_if_fail (key != NULL, NULL); + + locker = g_mutex_locker_new (&priv->cache_mutex); + app = g_hash_table_lookup (priv->cache, key); + if (app == NULL) + return NULL; + return g_object_ref (app); +} + +/** + * gs_plugin_cache_lookup_by_state: + * @plugin: a #GsPlugin + * @list: a #GsAppList to add applications to + * @state: a #GsAppState + * + * Adds each cached #GsApp with state @state into the @list. + * When the state is %GS_APP_STATE_UNKNOWN, then adds all + * cached applications. + * + * Since: 40 + **/ +void +gs_plugin_cache_lookup_by_state (GsPlugin *plugin, + GsAppList *list, + GsAppState state) +{ + GsPluginPrivate *priv; + GHashTableIter iter; + gpointer value; + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_PLUGIN (plugin)); + g_return_if_fail (GS_IS_APP_LIST (list)); + + priv = gs_plugin_get_instance_private (plugin); + locker = g_mutex_locker_new (&priv->cache_mutex); + + g_hash_table_iter_init (&iter, priv->cache); + while (g_hash_table_iter_next (&iter, NULL, &value)) { + GsApp *app = value; + + if (state == GS_APP_STATE_UNKNOWN || + state == gs_app_get_state (app)) + gs_app_list_add (list, app); + } +} + +/** + * gs_plugin_cache_remove: + * @plugin: a #GsPlugin + * @key: a key which matches + * + * Removes an application from the per-plugin cache. + * + * Since: 3.22 + **/ +void +gs_plugin_cache_remove (GsPlugin *plugin, const gchar *key) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_PLUGIN (plugin)); + g_return_if_fail (key != NULL); + + locker = g_mutex_locker_new (&priv->cache_mutex); + g_hash_table_remove (priv->cache, key); +} + +/** + * gs_plugin_cache_add: + * @plugin: a #GsPlugin + * @key: a string, or %NULL if the unique ID should be used + * @app: a #GsApp + * + * Adds an application to the per-plugin cache. This is optional, + * and the plugin can use the cache however it likes. + * + * Since: 3.22 + **/ +void +gs_plugin_cache_add (GsPlugin *plugin, const gchar *key, GsApp *app) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_PLUGIN (plugin)); + g_return_if_fail (GS_IS_APP (app)); + + locker = g_mutex_locker_new (&priv->cache_mutex); + + /* the user probably doesn't want to do this */ + if (gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD)) { + g_warning ("adding wildcard app %s to plugin cache", + gs_app_get_unique_id (app)); + } + + /* default */ + if (key == NULL) + key = gs_app_get_unique_id (app); + + g_return_if_fail (key != NULL); + + if (g_hash_table_lookup (priv->cache, key) == app) + return; + g_hash_table_insert (priv->cache, g_strdup (key), g_object_ref (app)); +} + +/** + * gs_plugin_cache_invalidate: + * @plugin: a #GsPlugin + * + * Invalidate the per-plugin cache by marking all entries as invalid. + * This is optional, and the plugin can evict the cache whenever it + * likes. Using this function may mean the front-end and the plugin + * may be operating on a different GsApp with the same cache ID. + * + * Most plugins do not need to call this function; if a suitable cache + * key is being used the old cache item can remain. + * + * Since: 3.22 + **/ +void +gs_plugin_cache_invalidate (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + g_autoptr(GMutexLocker) locker = NULL; + + g_return_if_fail (GS_IS_PLUGIN (plugin)); + + locker = g_mutex_locker_new (&priv->cache_mutex); + g_hash_table_remove_all (priv->cache); +} + +/** + * gs_plugin_report_event: + * @plugin: a #GsPlugin + * @event: a #GsPluginEvent + * + * Report a non-fatal event to the UI. Plugins should not assume that a + * specific event is actually shown to the user as it may be ignored + * automatically. + * + * Since: 3.24 + **/ +void +gs_plugin_report_event (GsPlugin *plugin, GsPluginEvent *event) +{ + g_return_if_fail (GS_IS_PLUGIN (plugin)); + g_return_if_fail (GS_IS_PLUGIN_EVENT (event)); + g_signal_emit (plugin, signals[SIGNAL_REPORT_EVENT], 0, event); +} + +/** + * gs_plugin_set_allow_updates: + * @plugin: a #GsPlugin + * @allow_updates: boolean + * + * This allows plugins to inhibit the showing of the updates panel. + * This will typically be used when the required permissions are not possible + * to obtain, or when a LiveUSB image is low on space. + * + * By default, the updates panel is shown so plugins do not need to call this + * function unless they called gs_plugin_set_allow_updates() with %FALSE. + * + * Since: 3.24 + **/ +void +gs_plugin_set_allow_updates (GsPlugin *plugin, gboolean allow_updates) +{ + g_return_if_fail (GS_IS_PLUGIN (plugin)); + g_signal_emit (plugin, signals[SIGNAL_ALLOW_UPDATES], 0, allow_updates); +} + +/** + * gs_plugin_error_to_string: + * @error: a #GsPluginError, e.g. %GS_PLUGIN_ERROR_NO_NETWORK + * + * Converts the enumerated error to a string. + * + * Returns: a string, or %NULL for invalid + **/ +const gchar * +gs_plugin_error_to_string (GsPluginError error) +{ + if (error == GS_PLUGIN_ERROR_FAILED) + return "failed"; + if (error == GS_PLUGIN_ERROR_NOT_SUPPORTED) + return "not-supported"; + if (error == GS_PLUGIN_ERROR_CANCELLED) + return "cancelled"; + if (error == GS_PLUGIN_ERROR_NO_NETWORK) + return "no-network"; + if (error == GS_PLUGIN_ERROR_NO_SECURITY) + return "no-security"; + if (error == GS_PLUGIN_ERROR_NO_SPACE) + return "no-space"; + if (error == GS_PLUGIN_ERROR_AUTH_REQUIRED) + return "auth-required"; + if (error == GS_PLUGIN_ERROR_AUTH_INVALID) + return "auth-invalid"; + if (error == GS_PLUGIN_ERROR_PLUGIN_DEPSOLVE_FAILED) + return "plugin-depsolve-failed"; + if (error == GS_PLUGIN_ERROR_DOWNLOAD_FAILED) + return "download-failed"; + if (error == GS_PLUGIN_ERROR_WRITE_FAILED) + return "write-failed"; + if (error == GS_PLUGIN_ERROR_INVALID_FORMAT) + return "invalid-format"; + if (error == GS_PLUGIN_ERROR_DELETE_FAILED) + return "delete-failed"; + if (error == GS_PLUGIN_ERROR_RESTART_REQUIRED) + return "restart-required"; + if (error == GS_PLUGIN_ERROR_AC_POWER_REQUIRED) + return "ac-power-required"; + if (error == GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW) + return "battery-level-too-low"; + if (error == GS_PLUGIN_ERROR_TIMED_OUT) + return "timed-out"; + return NULL; +} + +/** + * gs_plugin_action_to_function_name: (skip) + * @action: a #GsPluginAction, e.g. %GS_PLUGIN_ACTION_INSTALL + * + * Converts the enumerated action to the vfunc name. + * + * Returns: a string, or %NULL for invalid + **/ +const gchar * +gs_plugin_action_to_function_name (GsPluginAction action) +{ + if (action == GS_PLUGIN_ACTION_INSTALL) + return "gs_plugin_app_install"; + if (action == GS_PLUGIN_ACTION_REMOVE) + return "gs_plugin_app_remove"; + if (action == GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD) + return "gs_plugin_app_upgrade_download"; + if (action == GS_PLUGIN_ACTION_UPGRADE_TRIGGER) + return "gs_plugin_app_upgrade_trigger"; + if (action == GS_PLUGIN_ACTION_LAUNCH) + return "gs_plugin_launch"; + if (action == GS_PLUGIN_ACTION_UPDATE_CANCEL) + return "gs_plugin_update_cancel"; + if (action == GS_PLUGIN_ACTION_UPDATE) + return "gs_plugin_update"; + if (action == GS_PLUGIN_ACTION_DOWNLOAD) + return "gs_plugin_download"; + if (action == GS_PLUGIN_ACTION_FILE_TO_APP) + return "gs_plugin_file_to_app"; + if (action == GS_PLUGIN_ACTION_URL_TO_APP) + return "gs_plugin_url_to_app"; + if (action == GS_PLUGIN_ACTION_GET_SOURCES) + return "gs_plugin_add_sources"; + if (action == GS_PLUGIN_ACTION_GET_UPDATES_HISTORICAL) + return "gs_plugin_add_updates_historical"; + if (action == GS_PLUGIN_ACTION_GET_UPDATES) + return "gs_plugin_add_updates"; + if (action == GS_PLUGIN_ACTION_GET_LANGPACKS) + return "gs_plugin_add_langpacks"; + return NULL; +} + +/** + * gs_plugin_action_to_string: + * @action: a #GsPluginAction, e.g. %GS_PLUGIN_ACTION_INSTALL + * + * Converts the enumerated action to a string. + * + * Returns: a string, or %NULL for invalid + **/ +const gchar * +gs_plugin_action_to_string (GsPluginAction action) +{ + if (action == GS_PLUGIN_ACTION_UNKNOWN) + return "unknown"; + if (action == GS_PLUGIN_ACTION_INSTALL) + return "install"; + if (action == GS_PLUGIN_ACTION_DOWNLOAD) + return "download"; + if (action == GS_PLUGIN_ACTION_REMOVE) + return "remove"; + if (action == GS_PLUGIN_ACTION_UPDATE) + return "update"; + if (action == GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD) + return "upgrade-download"; + if (action == GS_PLUGIN_ACTION_UPGRADE_TRIGGER) + return "upgrade-trigger"; + if (action == GS_PLUGIN_ACTION_LAUNCH) + return "launch"; + if (action == GS_PLUGIN_ACTION_UPDATE_CANCEL) + return "update-cancel"; + if (action == GS_PLUGIN_ACTION_GET_UPDATES) + return "get-updates"; + if (action == GS_PLUGIN_ACTION_GET_SOURCES) + return "get-sources"; + if (action == GS_PLUGIN_ACTION_FILE_TO_APP) + return "file-to-app"; + if (action == GS_PLUGIN_ACTION_URL_TO_APP) + return "url-to-app"; + if (action == GS_PLUGIN_ACTION_GET_UPDATES_HISTORICAL) + return "get-updates-historical"; + if (action == GS_PLUGIN_ACTION_GET_LANGPACKS) + return "get-langpacks"; + if (action == GS_PLUGIN_ACTION_INSTALL_REPO) + return "repo-install"; + if (action == GS_PLUGIN_ACTION_REMOVE_REPO) + return "repo-remove"; + if (action == GS_PLUGIN_ACTION_ENABLE_REPO) + return "repo-enable"; + if (action == GS_PLUGIN_ACTION_DISABLE_REPO) + return "repo-disable"; + return NULL; +} + +/** + * gs_plugin_action_from_string: + * @action: a #GsPluginAction, e.g. "install" + * + * Converts the string to an enumerated action. + * + * Returns: a GsPluginAction, e.g. %GS_PLUGIN_ACTION_INSTALL + * + * Since: 3.26 + **/ +GsPluginAction +gs_plugin_action_from_string (const gchar *action) +{ + if (g_strcmp0 (action, "install") == 0) + return GS_PLUGIN_ACTION_INSTALL; + if (g_strcmp0 (action, "download") == 0) + return GS_PLUGIN_ACTION_DOWNLOAD; + if (g_strcmp0 (action, "remove") == 0) + return GS_PLUGIN_ACTION_REMOVE; + if (g_strcmp0 (action, "update") == 0) + return GS_PLUGIN_ACTION_UPDATE; + if (g_strcmp0 (action, "upgrade-download") == 0) + return GS_PLUGIN_ACTION_UPGRADE_DOWNLOAD; + if (g_strcmp0 (action, "upgrade-trigger") == 0) + return GS_PLUGIN_ACTION_UPGRADE_TRIGGER; + if (g_strcmp0 (action, "launch") == 0) + return GS_PLUGIN_ACTION_LAUNCH; + if (g_strcmp0 (action, "update-cancel") == 0) + return GS_PLUGIN_ACTION_UPDATE_CANCEL; + if (g_strcmp0 (action, "get-updates") == 0) + return GS_PLUGIN_ACTION_GET_UPDATES; + if (g_strcmp0 (action, "get-sources") == 0) + return GS_PLUGIN_ACTION_GET_SOURCES; + if (g_strcmp0 (action, "file-to-app") == 0) + return GS_PLUGIN_ACTION_FILE_TO_APP; + if (g_strcmp0 (action, "url-to-app") == 0) + return GS_PLUGIN_ACTION_URL_TO_APP; + if (g_strcmp0 (action, "get-updates-historical") == 0) + return GS_PLUGIN_ACTION_GET_UPDATES_HISTORICAL; + if (g_strcmp0 (action, "get-langpacks") == 0) + return GS_PLUGIN_ACTION_GET_LANGPACKS; + if (g_strcmp0 (action, "repo-install") == 0) + return GS_PLUGIN_ACTION_INSTALL_REPO; + if (g_strcmp0 (action, "repo-remove") == 0) + return GS_PLUGIN_ACTION_REMOVE_REPO; + if (g_strcmp0 (action, "repo-enable") == 0) + return GS_PLUGIN_ACTION_ENABLE_REPO; + if (g_strcmp0 (action, "repo-disable") == 0) + return GS_PLUGIN_ACTION_DISABLE_REPO; + return GS_PLUGIN_ACTION_UNKNOWN; +} + +/** + * gs_plugin_refine_flags_to_string: + * @refine_flags: some #GsPluginRefineFlags, e.g. %GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE + * + * Converts the flags to a string. + * + * Returns: a string + **/ +gchar * +gs_plugin_refine_flags_to_string (GsPluginRefineFlags refine_flags) +{ + g_autoptr(GPtrArray) cstrs = g_ptr_array_new (); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdiscarded-qualifiers" + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ID) + g_ptr_array_add (cstrs, "require-id"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE) + g_ptr_array_add (cstrs, "require-license"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_URL) + g_ptr_array_add (cstrs, "require-url"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_DESCRIPTION) + g_ptr_array_add (cstrs, "require-description"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE) + g_ptr_array_add (cstrs, "require-size"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_RATING) + g_ptr_array_add (cstrs, "require-rating"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_VERSION) + g_ptr_array_add (cstrs, "require-version"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_HISTORY) + g_ptr_array_add (cstrs, "require-history"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SETUP_ACTION) + g_ptr_array_add (cstrs, "require-setup-action"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_DETAILS) + g_ptr_array_add (cstrs, "require-update-details"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN) + g_ptr_array_add (cstrs, "require-origin"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_RELATED) + g_ptr_array_add (cstrs, "require-related"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS) + g_ptr_array_add (cstrs, "require-addons"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_ALLOW_PACKAGES) + g_ptr_array_add (cstrs, "require-allow-packages"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_SEVERITY) + g_ptr_array_add (cstrs, "require-update-severity"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPGRADE_REMOVED) + g_ptr_array_add (cstrs, "require-upgrade-removed"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_PROVENANCE) + g_ptr_array_add (cstrs, "require-provenance"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS) + g_ptr_array_add (cstrs, "require-reviews"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEW_RATINGS) + g_ptr_array_add (cstrs, "require-review-ratings"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON) + g_ptr_array_add (cstrs, "require-icon"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_PERMISSIONS) + g_ptr_array_add (cstrs, "require-permissions"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_HOSTNAME) + g_ptr_array_add (cstrs, "require-origin-hostname"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_UI) + g_ptr_array_add (cstrs, "require-origin-ui"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_RUNTIME) + g_ptr_array_add (cstrs, "require-runtime"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SCREENSHOTS) + g_ptr_array_add (cstrs, "require-screenshots"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_CATEGORIES) + g_ptr_array_add (cstrs, "require-categories"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_PROJECT_GROUP) + g_ptr_array_add (cstrs, "require-project-group"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_DEVELOPER_NAME) + g_ptr_array_add (cstrs, "require-developer-name"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_KUDOS) + g_ptr_array_add (cstrs, "require-kudos"); + if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_CONTENT_RATING) + g_ptr_array_add (cstrs, "content-rating"); +#pragma GCC diagnostic pop + if (cstrs->len == 0) + return g_strdup ("none"); + g_ptr_array_add (cstrs, NULL); + return g_strjoinv (",", (gchar**) cstrs->pdata); +} + +static void +gs_plugin_constructed (GObject *object) +{ + GsPlugin *plugin = GS_PLUGIN (object); + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + + G_OBJECT_CLASS (gs_plugin_parent_class)->constructed (object); + + /* Check all required properties have been set. */ + g_assert (priv->session_bus_connection != NULL); + g_assert (priv->system_bus_connection != NULL); +} + +static void +gs_plugin_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +{ + GsPlugin *plugin = GS_PLUGIN (object); + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + + switch ((GsPluginProperty) prop_id) { + case PROP_FLAGS: + priv->flags = g_value_get_flags (value); + g_object_notify_by_pspec (G_OBJECT (plugin), obj_props[PROP_FLAGS]); + break; + case PROP_SESSION_BUS_CONNECTION: + /* Construct only */ + g_assert (priv->session_bus_connection == NULL); + priv->session_bus_connection = g_value_dup_object (value); + break; + case PROP_SYSTEM_BUS_CONNECTION: + /* Construct only */ + g_assert (priv->system_bus_connection == NULL); + priv->system_bus_connection = g_value_dup_object (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_plugin_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +{ + GsPlugin *plugin = GS_PLUGIN (object); + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + + switch ((GsPluginProperty) prop_id) { + case PROP_FLAGS: + g_value_set_flags (value, priv->flags); + break; + case PROP_SESSION_BUS_CONNECTION: + g_value_set_object (value, priv->session_bus_connection); + break; + case PROP_SYSTEM_BUS_CONNECTION: + g_value_set_object (value, priv->system_bus_connection); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_plugin_class_init (GsPluginClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->constructed = gs_plugin_constructed; + object_class->set_property = gs_plugin_set_property; + object_class->get_property = gs_plugin_get_property; + object_class->dispose = gs_plugin_dispose; + object_class->finalize = gs_plugin_finalize; + + /** + * GsPlugin:flags: + * + * Flags which indicate various boolean properties of the plugin. + * + * These may change during the plugin’s lifetime. + */ + obj_props[PROP_FLAGS] = + g_param_spec_flags ("flags", NULL, NULL, + GS_TYPE_PLUGIN_FLAGS, GS_PLUGIN_FLAGS_NONE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); + + /** + * GsPlugin:session-bus-connection: (not nullable) + * + * A connection to the D-Bus session bus. + * + * This must be set at construction time and will not be %NULL + * afterwards. + * + * Since: 43 + */ + obj_props[PROP_SESSION_BUS_CONNECTION] = + g_param_spec_object ("session-bus-connection", NULL, NULL, + G_TYPE_DBUS_CONNECTION, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); + + /** + * GsPlugin:system-bus-connection: (not nullable) + * + * A connection to the D-Bus system bus. + * + * This must be set at construction time and will not be %NULL + * afterwards. + * + * Since: 43 + */ + obj_props[PROP_SYSTEM_BUS_CONNECTION] = + g_param_spec_object ("system-bus-connection", NULL, NULL, + G_TYPE_DBUS_CONNECTION, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY); + + g_object_class_install_properties (object_class, G_N_ELEMENTS (obj_props), obj_props); + + signals [SIGNAL_UPDATES_CHANGED] = + g_signal_new ("updates-changed", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, updates_changed), + NULL, NULL, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + signals [SIGNAL_STATUS_CHANGED] = + g_signal_new ("status-changed", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, status_changed), + NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_NONE, 2, GS_TYPE_APP, G_TYPE_UINT); + + signals [SIGNAL_RELOAD] = + g_signal_new ("reload", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, reload), + NULL, NULL, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + signals [SIGNAL_REPORT_EVENT] = + g_signal_new ("report-event", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, report_event), + NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_NONE, 1, GS_TYPE_PLUGIN_EVENT); + + signals [SIGNAL_ALLOW_UPDATES] = + g_signal_new ("allow-updates", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, allow_updates), + NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, + G_TYPE_NONE, 1, G_TYPE_BOOLEAN); + + signals [SIGNAL_BASIC_AUTH_START] = + g_signal_new ("basic-auth-start", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, basic_auth_start), + NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER); + + signals [SIGNAL_REPOSITORY_CHANGED] = + g_signal_new ("repository-changed", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, repository_changed), + NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_NONE, 1, GS_TYPE_APP); + + signals [SIGNAL_ASK_UNTRUSTED] = + g_signal_new ("ask-untrusted", + G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsPluginClass, ask_untrusted), + NULL, NULL, g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); +} + +static void +gs_plugin_init (GsPlugin *plugin) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (plugin); + guint i; + + for (i = 0; i < GS_PLUGIN_RULE_LAST; i++) + priv->rules[i] = g_ptr_array_new_with_free_func (g_free); + + priv->enabled = TRUE; + priv->scale = 1; + priv->cache = g_hash_table_new_full ((GHashFunc) as_utils_data_id_hash, + (GEqualFunc) as_utils_data_id_equal, + g_free, + (GDestroyNotify) g_object_unref); + priv->vfuncs = g_hash_table_new_full (g_str_hash, g_str_equal, + g_free, NULL); + g_mutex_init (&priv->cache_mutex); + g_mutex_init (&priv->interactive_mutex); + g_mutex_init (&priv->timer_mutex); + g_mutex_init (&priv->vfuncs_mutex); +} + +/** + * gs_plugin_new: + * @session_bus_connection: (not nullable) (transfer none): a session bus + * connection to use + * @system_bus_connection: (not nullable) (transfer none): a system bus + * connection to use + * + * Creates a new plugin. + * + * Returns: a #GsPlugin + * + * Since: 43 + **/ +GsPlugin * +gs_plugin_new (GDBusConnection *session_bus_connection, + GDBusConnection *system_bus_connection) +{ + g_return_val_if_fail (G_IS_DBUS_CONNECTION (session_bus_connection), NULL); + g_return_val_if_fail (G_IS_DBUS_CONNECTION (system_bus_connection), NULL); + + return g_object_new (GS_TYPE_PLUGIN, + "session-bus-connection", session_bus_connection, + "system-bus-connection", system_bus_connection, + NULL); +} + +typedef struct { + GWeakRef plugin_weak; /* (owned) (element-type GsPlugin) */ + GsApp *repository; /* (owned) */ +} GsPluginRepositoryChangedHelper; + +static void +gs_plugin_repository_changed_helper_free (GsPluginRepositoryChangedHelper *helper) +{ + g_clear_object (&helper->repository); + g_weak_ref_clear (&helper->plugin_weak); + g_slice_free (GsPluginRepositoryChangedHelper, helper); +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GsPluginRepositoryChangedHelper, gs_plugin_repository_changed_helper_free) + +static gboolean +gs_plugin_repository_changed_cb (gpointer user_data) +{ + GsPluginRepositoryChangedHelper *helper = user_data; + g_autoptr(GsPlugin) plugin = NULL; + + plugin = g_weak_ref_get (&helper->plugin_weak); + if (plugin != NULL) + g_signal_emit (plugin, + signals[SIGNAL_REPOSITORY_CHANGED], 0, + helper->repository); + + return G_SOURCE_REMOVE; +} + +/** + * gs_plugin_repository_changed: + * @plugin: a #GsPlugin + * @repository: a #GsApp representing the repository + * + * Emit the "repository-changed" signal in the main thread. + * + * Since: 40 + **/ +void +gs_plugin_repository_changed (GsPlugin *plugin, + GsApp *repository) +{ + g_autoptr(GsPluginRepositoryChangedHelper) helper = NULL; + g_autoptr(GSource) idle_source = NULL; + + g_return_if_fail (GS_IS_PLUGIN (plugin)); + g_return_if_fail (GS_IS_APP (repository)); + + helper = g_slice_new0 (GsPluginRepositoryChangedHelper); + g_weak_ref_init (&helper->plugin_weak, plugin); + helper->repository = g_object_ref (repository); + + idle_source = g_idle_source_new (); + g_source_set_callback (idle_source, gs_plugin_repository_changed_cb, g_steal_pointer (&helper), (GDestroyNotify) gs_plugin_repository_changed_helper_free); + g_source_attach (idle_source, NULL); +} + +/** + * gs_plugin_update_cache_state_for_repository: + * @plugin: a #GsPlugin + * @repository: a #GsApp representing a repository, which changed + * + * Update state of the all cached #GsApp instances related + * to the @repository. + * + * Since: 40 + **/ +void +gs_plugin_update_cache_state_for_repository (GsPlugin *plugin, + GsApp *repository) +{ + GsPluginPrivate *priv; + GHashTableIter iter; + g_autoptr(GMutexLocker) locker = NULL; + g_autoptr(GsPlugin) repo_plugin = NULL; + gpointer value; + const gchar *repo_id; + GsAppState repo_state; + + g_return_if_fail (GS_IS_PLUGIN (plugin)); + g_return_if_fail (GS_IS_APP (repository)); + + priv = gs_plugin_get_instance_private (plugin); + repo_id = gs_app_get_id (repository); + repo_state = gs_app_get_state (repository); + repo_plugin = gs_app_dup_management_plugin (repository); + + locker = g_mutex_locker_new (&priv->cache_mutex); + + g_hash_table_iter_init (&iter, priv->cache); + while (g_hash_table_iter_next (&iter, NULL, &value)) { + GsApp *app = value; + GsAppState app_state = gs_app_get_state (app); + g_autoptr(GsPlugin) app_plugin = gs_app_dup_management_plugin (app); + + if (app_plugin != repo_plugin || + gs_app_get_scope (app) != gs_app_get_scope (repository) || + gs_app_get_bundle_kind (app) != gs_app_get_bundle_kind (repository)) + continue; + + if (((app_state == GS_APP_STATE_AVAILABLE && + repo_state != GS_APP_STATE_INSTALLED) || + (app_state == GS_APP_STATE_UNAVAILABLE && + repo_state == GS_APP_STATE_INSTALLED)) && + g_strcmp0 (gs_app_get_origin (app), repo_id) == 0) { + /* First reset the state, because move from 'available' to 'unavailable' is not correct */ + gs_app_set_state (app, GS_APP_STATE_UNKNOWN); + gs_app_set_state (app, repo_state == GS_APP_STATE_INSTALLED ? GS_APP_STATE_AVAILABLE : GS_APP_STATE_UNAVAILABLE); + } + } +} + +/** + * gs_plugin_ask_untrusted: + * @plugin: a #GsPlugin + * @title: the title for the question + * @msg: the message for the question + * @details: (nullable): the detailed error message, or %NULL for none + * @accept_label: (nullable): a label of the 'accept' button, or %NULL to use 'Accept' + * + * Asks the user whether he/she accepts an untrusted package install/download/update, + * as described by @title and @msg, eventually with the @details. + * + * Note: This is a blocking call and can be called only from the main/GUI thread. + * + * Returns: whether the user accepted the question + * + * Since: 42 + **/ +gboolean +gs_plugin_ask_untrusted (GsPlugin *plugin, + const gchar *title, + const gchar *msg, + const gchar *details, + const gchar *accept_label) +{ + gboolean accepts = FALSE; + g_signal_emit (plugin, + signals[SIGNAL_ASK_UNTRUSTED], 0, + title, + msg, + details, + accept_label, + &accepts); + return accepts; +} + +/** + * gs_plugin_get_session_bus_connection: + * @self: a #GsPlugin + * + * Get the D-Bus session bus connection in use by the plugin. + * + * Returns: (transfer none) (not nullable): a D-Bus connection + * Since: 43 + */ +GDBusConnection * +gs_plugin_get_session_bus_connection (GsPlugin *self) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (self); + + g_return_val_if_fail (GS_IS_PLUGIN (self), NULL); + + return priv->session_bus_connection; +} + +/** + * gs_plugin_get_system_bus_connection: + * @self: a #GsPlugin + * + * Get the D-Bus system bus connection in use by the plugin. + * + * Returns: (transfer none) (not nullable): a D-Bus connection + * Since: 43 + */ +GDBusConnection * +gs_plugin_get_system_bus_connection (GsPlugin *self) +{ + GsPluginPrivate *priv = gs_plugin_get_instance_private (self); + + g_return_val_if_fail (GS_IS_PLUGIN (self), NULL); + + return priv->system_bus_connection; +} -- cgit v1.2.3