gboolean
gs_plugin_setup (GsPlugin *plugin, GCancellable *cancellable, GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
/* add source */
priv->cached_origin = gs_app_new (gs_plugin_get_name (plugin));
gs_app_set_kind (priv->cached_origin, AS_APP_KIND_SOURCE);
gs_app_set_bundle_kind (priv->cached_origin, AS_BUNDLE_KIND_CABINET);
/* add the source to the plugin cache which allows us to match the
* unique ID to a GsApp when creating an event */
gs_plugin_cache_add (plugin,
gs_app_get_unique_id (priv->cached_origin),
priv->cached_origin);
/* register D-Bus errors */
fwupd_error_quark ();
g_signal_connect (priv->client, "changed",
G_CALLBACK (gs_plugin_fwupd_changed_cb), plugin);
g_signal_connect (priv->client, "device-added",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "device-removed",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "device-changed",
G_CALLBACK (gs_plugin_fwupd_device_changed_cb), plugin);
g_signal_connect (priv->client, "notify::percentage",
G_CALLBACK (gs_plugin_fwupd_notify_percentage_cb), plugin);
g_signal_connect (priv->client, "notify::status",
G_CALLBACK (gs_plugin_fwupd_notify_status_cb), plugin);
return TRUE;
}
static GsApp*
gs_plugin_app_from_pki (LiPkgInfo *pki)
{
const gchar *cptkind_str;
GsApp *app;
cptkind_str = li_pkg_info_get_component_kind (pki);
if ((cptkind_str != NULL) && (g_strcmp0 (cptkind_str, "desktop") == 0)) {
g_autofree gchar *tmp = NULL;
/* type=desktop AppStream components result in a Limba bundle name which has the .desktop stripped away.
* We need to re-add it for GNOME Software.
* In any other case, the Limba bundle name equals the AppStream ID of the component it contains */
tmp = g_strdup_printf ("%s.desktop", li_pkg_info_get_name (pki));
app = gs_app_new (tmp);
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
} else {
app = gs_app_new (li_pkg_info_get_name (pki));
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
}
/* TODO: scope?, branch? */
gs_app_set_management_plugin (app, "limba");
gs_app_set_state (app, AS_APP_STATE_UPDATABLE_LIVE);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_LIMBA);
gs_app_set_name (app,
GS_APP_QUALITY_LOWEST,
li_pkg_info_get_name (pki));
gs_app_set_summary (app,
GS_APP_QUALITY_LOWEST,
li_pkg_info_get_name (pki));
gs_app_set_version (app, li_pkg_info_get_version (pki));
gs_app_add_source (app, li_pkg_info_get_id (pki));
return app;
}
static GsApp *
snap_to_app (GsPlugin *plugin, SnapdSnap *snap)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GStrv common_ids;
g_autofree gchar *appstream_id = NULL;
g_autofree gchar *unique_id = NULL;
g_autoptr(GsApp) app = NULL;
SnapdConfinement confinement;
/* Get the AppStream ID from the snap, or generate a fallback one */
common_ids = snapd_snap_get_common_ids (snap);
if (g_strv_length (common_ids) == 1)
appstream_id = g_strdup (common_ids[0]);
else
appstream_id = g_strdup_printf ("io.snapcraft.%s-%s", snapd_snap_get_name (snap), snapd_snap_get_id (snap));
switch (snapd_snap_get_snap_type (snap)) {
case SNAPD_SNAP_TYPE_APP:
unique_id = g_strdup_printf ("system/snap/*/desktop/%s/*", appstream_id);
break;
case SNAPD_SNAP_TYPE_KERNEL:
case SNAPD_SNAP_TYPE_GADGET:
case SNAPD_SNAP_TYPE_OS:
unique_id = g_strdup_printf ("system/snap/*/runtime/%s/*", appstream_id);
break;
default:
case SNAPD_SNAP_TYPE_UNKNOWN:
unique_id = g_strdup_printf ("system/snap/*/*/%s/*", appstream_id);
break;
}
app = gs_plugin_cache_lookup (plugin, unique_id);
if (app == NULL) {
app = gs_app_new (NULL);
gs_app_set_from_unique_id (app, unique_id);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_metadata (app, "snap::name", snapd_snap_get_name (snap));
gs_plugin_cache_add (plugin, unique_id, app);
}
gs_app_set_management_plugin (app, "snap");
if (gs_app_get_kind (app) != AS_APP_KIND_DESKTOP)
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
if (gs_plugin_check_distro_id (plugin, "ubuntu"))
gs_app_add_quirk (app, GS_APP_QUIRK_PROVENANCE);
confinement = snapd_snap_get_confinement (snap);
if (confinement != SNAPD_CONFINEMENT_UNKNOWN) {
GEnumClass *enum_class = g_type_class_ref (SNAPD_TYPE_CONFINEMENT);
gs_app_set_metadata (app, "snap::confinement", g_enum_get_value (enum_class, confinement)->value_nick);
g_type_class_unref (enum_class);
}
if (priv->system_confinement == SNAPD_SYSTEM_CONFINEMENT_STRICT && confinement == SNAPD_CONFINEMENT_STRICT)
gs_app_add_kudo (app, GS_APP_KUDO_SANDBOXED);
return g_steal_pointer (&app);
}
static GsApp *
gs_plugin_fwupd_new_app_from_device (GsPlugin *plugin, FwupdDevice *dev)
{
FwupdRelease *rel = fwupd_device_get_release_default (dev);
GsApp *app;
g_autofree gchar *id = NULL;
g_autoptr(AsIcon) icon = NULL;
/* older versions of fwups didn't record this for historical devices */
if (fwupd_release_get_appstream_id (rel) == NULL)
return NULL;
/* get from cache */
id = as_utils_unique_id_build (AS_APP_SCOPE_SYSTEM,
AS_BUNDLE_KIND_UNKNOWN,
NULL, /* origin */
AS_APP_KIND_FIRMWARE,
fwupd_release_get_appstream_id (rel),
NULL);
app = gs_plugin_cache_lookup (plugin, id);
if (app == NULL) {
app = gs_app_new (id);
gs_plugin_cache_add (plugin, id, app);
}
/* default stuff */
gs_app_set_kind (app, AS_APP_KIND_FIRMWARE);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_CABINET);
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
gs_app_set_management_plugin (app, "fwupd");
gs_app_add_category (app, "System");
gs_fwupd_app_set_device_id (app, fwupd_device_get_id (dev));
/* create icon */
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "application-x-firmware");
gs_app_add_icon (app, icon);
gs_fwupd_app_set_from_release (app, rel);
gs_fwupd_app_set_from_device (app, dev);
if (fwupd_release_get_appstream_id (rel) != NULL)
gs_app_set_id (app, fwupd_release_get_appstream_id (rel));
/* the same as we have already */
if (g_strcmp0 (fwupd_device_get_version (dev),
fwupd_release_get_version (rel)) == 0) {
g_warning ("same firmware version as installed");
}
return app;
}
gboolean
gs_plugin_add_installed (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *macaroon = NULL;
g_auto(GStrv) discharges = NULL;
g_autoptr(JsonArray) result = NULL;
guint i;
get_macaroon (plugin, &macaroon, &discharges);
result = gs_snapd_list (macaroon, discharges, cancellable, error);
if (result == NULL)
return FALSE;
for (i = 0; i < json_array_get_length (result); i++) {
JsonObject *package = json_array_get_object_element (result, i);
g_autoptr(GsApp) app = NULL;
const gchar *status, *name;
status = json_object_get_string_member (package, "status");
if (g_strcmp0 (status, "active") != 0)
continue;
/* create a unique ID for deduplication, TODO: branch? */
name = json_object_get_string_member (package, "name");
app = gs_app_new (name);
gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_management_plugin (app, "snap");
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
gs_app_add_quirk (app, AS_APP_QUIRK_NOT_REVIEWABLE);
refine_app (plugin, app, package, TRUE, cancellable);
gs_app_list_add (list, app);
}
return TRUE;
}
void
gs_plugin_adopt_app (GsPlugin *plugin, GsApp *app)
{
if (gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_SNAP)
gs_app_set_management_plugin (app, "snap");
if (g_str_has_prefix (gs_app_get_id (app), "io.snapcraft.")) {
g_autofree gchar *name_and_id = NULL;
gchar *divider, *snap_name;/*, *id;*/
name_and_id = g_strdup (gs_app_get_id (app) + strlen ("io.snapcraft."));
divider = strrchr (name_and_id, '-');
if (divider != NULL) {
*divider = '\0';
snap_name = name_and_id;
/*id = divider + 1;*/ /* NOTE: Should probably validate ID */
gs_app_set_management_plugin (app, "snap");
gs_app_set_metadata (app, "snap::name", snap_name);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
}
}
}
gboolean
gs_plugin_url_to_app (GsPlugin *plugin,
GsAppList *list,
const gchar *url,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autofree gchar *scheme = NULL;
g_autofree gchar *path = NULL;
const gchar *id = NULL;
const gchar * const *id_like = NULL;
g_auto(GStrv) package_ids = NULL;
g_autoptr(PkResults) results = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(GsOsRelease) os_release = NULL;
g_autoptr(GPtrArray) packages = NULL;
g_autoptr(GPtrArray) details = NULL;
g_autoptr(GsPackagekitHelper) helper = gs_packagekit_helper_new (plugin);
path = gs_utils_get_url_path (url);
/* only do this for apt:// on debian or debian-like distros */
os_release = gs_os_release_new (error);
if (os_release == NULL) {
g_prefix_error (error, "failed to determine OS information:");
return FALSE;
} else {
id = gs_os_release_get_id (os_release);
id_like = gs_os_release_get_id_like (os_release);
scheme = gs_utils_get_url_scheme (url);
if (!(g_strcmp0 (scheme, "apt") == 0 &&
(g_strcmp0 (id, "debian") == 0 ||
g_strv_contains (id_like, "debian")))) {
return TRUE;
}
}
app = gs_app_new (NULL);
gs_plugin_packagekit_set_packaging_format (plugin, app);
gs_app_add_source (app, path);
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE);
package_ids = g_new0 (gchar *, 2);
package_ids[0] = g_strdup (path);
g_mutex_lock (&priv->client_mutex);
results = pk_client_resolve (priv->client,
pk_bitfield_from_enums (PK_FILTER_ENUM_NEWEST, PK_FILTER_ENUM_ARCH, -1),
package_ids,
cancellable,
gs_packagekit_helper_cb, helper,
error);
g_mutex_unlock (&priv->client_mutex);
if (!gs_plugin_packagekit_results_valid (results, error)) {
g_prefix_error (error, "failed to resolve package_ids: ");
return FALSE;
}
/* get results */
packages = pk_results_get_package_array (results);
details = pk_results_get_details_array (results);
if (packages->len >= 1) {
if (gs_app_get_local_file (app) != NULL)
return TRUE;
gs_plugin_packagekit_resolve_packages_app (plugin, packages, app);
gs_plugin_packagekit_refine_details_app (plugin, details, app);
gs_app_list_add (list, app);
} else {
g_warning ("no results returned");
}
return TRUE;
}
