Adding upstream version 3.38.1.upstream/3.38.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

11 files changed, 1627 insertions, 0 deletions

diff --git a/plugins/fwupd/gs-fwupd-app.c b/plugins/fwupd/gs-fwupd-app.c
new file mode 100644
index 0000000..df6505b
--- /dev/null
+++ b/plugins/fwupd/gs-fwupd-app.c
@@ -0,0 +1,242 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * vi:set noexpandtab tabstop=8 shiftwidth=8:
+ *
+ * Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <glib/gi18n.h>
+
+#include "gs-fwupd-app.h"
+
+const gchar *
+gs_fwupd_app_get_device_id (GsApp *app)
+{
+	return gs_app_get_metadata_item (app, "fwupd::DeviceID");
+}
+
+const gchar *
+gs_fwupd_app_get_update_uri (GsApp *app)
+{
+	return gs_app_get_metadata_item (app, "fwupd::UpdateID");
+}
+
+gboolean
+gs_fwupd_app_get_is_locked (GsApp *app)
+{
+	GVariant *tmp = gs_app_get_metadata_variant (app, "fwupd::IsLocked");
+	if (tmp == NULL)
+		return FALSE;
+	return g_variant_get_boolean (tmp);
+}
+
+void
+gs_fwupd_app_set_device_id (GsApp *app, const gchar *device_id)
+{
+	gs_app_set_metadata (app, "fwupd::DeviceID", device_id);
+}
+
+void
+gs_fwupd_app_set_update_uri (GsApp *app, const gchar *update_uri)
+{
+	gs_app_set_metadata (app, "fwupd::UpdateID", update_uri);
+}
+
+void
+gs_fwupd_app_set_is_locked (GsApp *app, gboolean is_locked)
+{
+	g_autoptr(GVariant) tmp = g_variant_new_boolean (is_locked);
+	gs_app_set_metadata_variant (app, "fwupd::IsLocked", tmp);
+}
+
+void
+gs_fwupd_app_set_from_device (GsApp *app, FwupdDevice *dev)
+{
+	GPtrArray *guids;
+
+	/* something can be done */
+	if (fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_UPDATABLE))
+		gs_app_set_state (app, AS_APP_STATE_UPDATABLE_LIVE);
+
+	/* only can be applied in systemd-offline */
+	if (fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_ONLY_OFFLINE))
+		gs_app_set_metadata (app, "fwupd::OnlyOffline", "");
+
+
+	/* reboot required to apply update */
+	if (fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_NEEDS_REBOOT))
+		gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_REBOOT);
+
+	/* is removable */
+	if (!fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_INTERNAL))
+		gs_app_add_quirk (app, GS_APP_QUIRK_REMOVABLE_HARDWARE);
+
+	guids = fwupd_device_get_guids (dev);
+	if (guids->len > 0) {
+		g_autofree gchar *guid_str = NULL;
+		g_auto(GStrv) tmp = g_new0 (gchar *, guids->len + 1);
+		for (guint i = 0; i < guids->len; i++)
+			tmp[i] = g_strdup (g_ptr_array_index (guids, i));
+		guid_str = g_strjoinv (",", tmp);
+		gs_app_set_metadata (app, "fwupd::Guid", guid_str);
+	}
+	if (fwupd_device_get_name (dev) != NULL) {
+		g_autofree gchar *vendor_name = NULL;
+		if (fwupd_device_get_vendor (dev) == NULL ||
+		    g_str_has_prefix (fwupd_device_get_name (dev),
+				      fwupd_device_get_vendor (dev))) {
+			vendor_name = g_strdup (fwupd_device_get_name (dev));
+		} else {
+			vendor_name = g_strdup_printf ("%s %s",
+						       fwupd_device_get_vendor (dev),
+						       fwupd_device_get_name (dev));
+		}
+		gs_app_set_name (app, GS_APP_QUALITY_NORMAL, vendor_name);
+	}
+	if (fwupd_device_get_summary (dev) != NULL) {
+		gs_app_set_summary (app, GS_APP_QUALITY_NORMAL,
+				    fwupd_device_get_summary (dev));
+	}
+	if (fwupd_device_get_version (dev) != NULL) {
+		gs_app_set_version (app, fwupd_device_get_version (dev));
+	}
+	if (fwupd_device_get_created (dev) != 0)
+		gs_app_set_install_date (app, fwupd_device_get_created (dev));
+	if (fwupd_device_get_description (dev) != NULL) {
+		g_autofree gchar *tmp = NULL;
+		tmp = as_markup_convert (fwupd_device_get_description (dev),
+					 AS_MARKUP_CONVERT_FORMAT_SIMPLE, NULL);
+		if (tmp != NULL)
+			gs_app_set_description (app, GS_APP_QUALITY_NORMAL, tmp);
+	}
+
+	/* needs action */
+	if (fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_NEEDS_BOOTLOADER))
+		gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_USER_ACTION);
+	else
+		gs_app_remove_quirk (app, GS_APP_QUIRK_NEEDS_USER_ACTION);
+}
+
+static gchar *
+gs_fwupd_release_get_name (FwupdRelease *release)
+{
+	const gchar *name = fwupd_release_get_name (release);
+#if FWUPD_CHECK_VERSION(1,2,7)
+	GPtrArray *cats = fwupd_release_get_categories (release);
+
+	for (guint i = 0; i < cats->len; i++) {
+		const gchar *cat = g_ptr_array_index (cats, i);
+		if (g_strcmp0 (cat, "X-Device") == 0) {
+			/* TRANSLATORS: a specific part of hardware,
+			 * the first %s is the device name, e.g. 'Unifying Receiver` */
+			return g_strdup_printf (_("%s Device Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-System") == 0) {
+			/* TRANSLATORS: the entire system, e.g. all internal devices,
+			 * the first %s is the device name, e.g. 'ThinkPad P50` */
+			return g_strdup_printf (_("%s System Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-EmbeddedController") == 0) {
+			/* TRANSLATORS: the EC is typically the keyboard controller chip,
+			 * the first %s is the device name, e.g. 'ThinkPad P50` */
+			return g_strdup_printf (_("%s Embedded Controller Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-ManagementEngine") == 0) {
+			/* TRANSLATORS: ME stands for Management Engine, the Intel AMT thing,
+			 * the first %s is the device name, e.g. 'ThinkPad P50` */
+			return g_strdup_printf (_("%s ME Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-CorporateManagementEngine") == 0) {
+			/* TRANSLATORS: ME stands for Management Engine (with Intel AMT),
+			 * where the first %s is the device name, e.g. 'ThinkPad P50` */
+			return g_strdup_printf (_("%s Corporate ME Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-ConsumerManagementEngine") == 0) {
+			/* TRANSLATORS: ME stands for Management Engine, where
+			 * the first %s is the device name, e.g. 'ThinkPad P50` */
+			return g_strdup_printf (_("%s Consumer ME Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-Controller") == 0) {
+			/* TRANSLATORS: the controller is a device that has other devices
+			 * plugged into it, for example ThunderBolt, FireWire or USB,
+			 * the first %s is the device name, e.g. 'Intel ThunderBolt` */
+			return g_strdup_printf (_("%s Controller Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-ThunderboltController") == 0) {
+			/* TRANSLATORS: the Thunderbolt controller is a device that
+			 * has other high speed Thunderbolt devices plugged into it;
+			 * the first %s is the system name, e.g. 'ThinkPad P50` */
+			return g_strdup_printf (_("%s Thunderbolt Controller Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-CpuMicrocode") == 0) {
+			/* TRANSLATORS: the CPU microcode is firmware loaded onto the CPU
+			 * at system bootup */
+			return g_strdup_printf (_("%s CPU Microcode Update"), name);
+		}
+		if (g_strcmp0 (cat, "X-Configuration") == 0) {
+			/* TRANSLATORS: configuration refers to hardware state,
+			 * e.g. a security database or a default power value */
+			return g_strdup_printf (_("%s Configuration Update"), name);
+		}
+	}
+#endif
+
+	/* default fallback */
+	return g_strdup (name);
+}
+
+void
+gs_fwupd_app_set_from_release (GsApp *app, FwupdRelease *rel)
+{
+	if (fwupd_release_get_name (rel) != NULL) {
+		g_autofree gchar *tmp = gs_fwupd_release_get_name (rel);
+		gs_app_set_name (app, GS_APP_QUALITY_NORMAL, tmp);
+	}
+	if (fwupd_release_get_summary (rel) != NULL) {
+		gs_app_set_summary (app, GS_APP_QUALITY_NORMAL,
+				    fwupd_release_get_summary (rel));
+	}
+	if (fwupd_release_get_homepage (rel) != NULL) {
+		gs_app_set_url (app, AS_URL_KIND_HOMEPAGE,
+				fwupd_release_get_homepage (rel));
+	}
+	if (fwupd_release_get_size (rel) != 0) {
+		gs_app_set_size_installed (app, 0);
+		gs_app_set_size_download (app, fwupd_release_get_size (rel));
+	}
+	if (fwupd_release_get_version (rel) != NULL)
+		gs_app_set_update_version (app, fwupd_release_get_version (rel));
+	if (fwupd_release_get_license (rel) != NULL) {
+		gs_app_set_license (app, GS_APP_QUALITY_NORMAL,
+				    fwupd_release_get_license (rel));
+	}
+	if (fwupd_release_get_uri (rel) != NULL) {
+		gs_app_set_origin_hostname (app,
+					    fwupd_release_get_uri (rel));
+		gs_fwupd_app_set_update_uri (app, fwupd_release_get_uri (rel));
+	}
+	if (fwupd_release_get_description (rel) != NULL) {
+		g_autofree gchar *tmp = NULL;
+		tmp = as_markup_convert (fwupd_release_get_description (rel),
+					 AS_MARKUP_CONVERT_FORMAT_SIMPLE, NULL);
+		if (tmp != NULL)
+			gs_app_set_update_details (app, tmp);
+	}
+#if FWUPD_CHECK_VERSION(1,3,3)
+	if (fwupd_release_get_detach_image (rel) != NULL) {
+		g_autoptr(AsScreenshot) ss = as_screenshot_new ();
+		g_autoptr(AsImage) im = as_image_new ();
+		as_image_set_kind (im, AS_IMAGE_KIND_SOURCE);
+		as_image_set_url (im, fwupd_release_get_detach_image (rel));
+		as_screenshot_set_kind (ss, AS_SCREENSHOT_KIND_DEFAULT);
+		as_screenshot_add_image (ss, im);
+		if (fwupd_release_get_detach_caption (rel) != NULL)
+			as_screenshot_set_caption (ss, NULL, fwupd_release_get_detach_caption (rel));
+		gs_app_set_action_screenshot (app, ss);
+	}
+#endif
+}
diff --git a/plugins/fwupd/gs-fwupd-app.h b/plugins/fwupd/gs-fwupd-app.h
new file mode 100644
index 0000000..5a3e9f2
--- /dev/null
+++ b/plugins/fwupd/gs-fwupd-app.h
@@ -0,0 +1,31 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * vi:set noexpandtab tabstop=8 shiftwidth=8:
+ *
+ * Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#pragma once
+
+#include <gnome-software.h>
+#include <fwupd.h>
+
+G_BEGIN_DECLS
+
+const gchar		*gs_fwupd_app_get_device_id		(GsApp		*app);
+const gchar		*gs_fwupd_app_get_update_uri		(GsApp		*app);
+gboolean		 gs_fwupd_app_get_is_locked		(GsApp		*app);
+
+void			 gs_fwupd_app_set_device_id		(GsApp		*app,
+								 const gchar	*device_id);
+void			 gs_fwupd_app_set_update_uri		(GsApp		*app,
+								 const gchar	*update_uri);
+void			 gs_fwupd_app_set_is_locked		(GsApp		*app,
+								 gboolean	 is_locked);
+void			 gs_fwupd_app_set_from_device		(GsApp		*app,
+								 FwupdDevice	*dev);
+void			 gs_fwupd_app_set_from_release		(GsApp		*app,
+								 FwupdRelease	*rel);
+
+G_END_DECLS
diff --git a/plugins/fwupd/gs-plugin-fwupd.c b/plugins/fwupd/gs-plugin-fwupd.c
new file mode 100644
index 0000000..d032640
--- /dev/null
+++ b/plugins/fwupd/gs-plugin-fwupd.c
@@ -0,0 +1,1132 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * vi:set noexpandtab tabstop=8 shiftwidth=8:
+ *
+ * Copyright (C) 2013-2018 Richard Hughes <richard@hughsie.com>
+ * Copyright (C) 2015-2018 Kalev Lember <klember@redhat.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include <config.h>
+
+#include <fwupd.h>
+#include <fcntl.h>
+#include <gio/gio.h>
+#include <gio/gunixfdlist.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+
+#include <gnome-software.h>
+
+#include "gs-fwupd-app.h"
+#include "gs-metered.h"
+
+/*
+ * SECTION:
+ * Queries for new firmware and schedules it to be installed as required.
+ *
+ * This plugin calls UpdatesChanged() if any updatable devices are
+ * added or removed or if a device has been updated live.
+ */
+
+struct GsPluginData {
+	FwupdClient		*client;
+	GsApp			*app_current;
+	GsApp			*cached_origin;
+};
+
+static void
+gs_plugin_fwupd_error_convert (GError **perror)
+{
+	GError *error = perror != NULL ? *perror : NULL;
+
+	/* not set */
+	if (error == NULL)
+		return;
+
+	/* already correct */
+	if (error->domain == GS_PLUGIN_ERROR)
+		return;
+
+	/* this are allowed for low-level errors */
+	if (gs_utils_error_convert_gio (perror))
+		return;
+
+	/* this are allowed for low-level errors */
+	if (gs_utils_error_convert_gdbus (perror))
+		return;
+
+	/* custom to this plugin */
+	if (error->domain == FWUPD_ERROR) {
+		switch (error->code) {
+		case FWUPD_ERROR_ALREADY_PENDING:
+		case FWUPD_ERROR_INVALID_FILE:
+		case FWUPD_ERROR_NOT_SUPPORTED:
+			error->code = GS_PLUGIN_ERROR_NOT_SUPPORTED;
+			break;
+		case FWUPD_ERROR_AUTH_FAILED:
+			error->code = GS_PLUGIN_ERROR_AUTH_INVALID;
+			break;
+		case FWUPD_ERROR_SIGNATURE_INVALID:
+			error->code = GS_PLUGIN_ERROR_NO_SECURITY;
+			break;
+		case FWUPD_ERROR_AC_POWER_REQUIRED:
+			error->code = GS_PLUGIN_ERROR_AC_POWER_REQUIRED;
+			break;
+#if FWUPD_CHECK_VERSION(1,2,10)
+		case FWUPD_ERROR_BATTERY_LEVEL_TOO_LOW:
+			error->code = GS_PLUGIN_ERROR_BATTERY_LEVEL_TOO_LOW;
+			break;
+#endif
+		default:
+			error->code = GS_PLUGIN_ERROR_FAILED;
+			break;
+		}
+	} else {
+		g_warning ("can't reliably fixup error from domain %s",
+			   g_quark_to_string (error->domain));
+		error->code = GS_PLUGIN_ERROR_FAILED;
+	}
+	error->domain = GS_PLUGIN_ERROR;
+}
+
+void
+gs_plugin_initialize (GsPlugin *plugin)
+{
+	GsPluginData *priv = gs_plugin_alloc_data (plugin, sizeof(GsPluginData));
+	priv->client = fwupd_client_new ();
+
+	/* set name of MetaInfo file */
+	gs_plugin_set_appstream_id (plugin, "org.gnome.Software.Plugin.Fwupd");
+}
+
+void
+gs_plugin_destroy (GsPlugin *plugin)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	if (priv->cached_origin != NULL)
+		g_object_unref (priv->cached_origin);
+	g_object_unref (priv->client);
+}
+
+void
+gs_plugin_adopt_app (GsPlugin *plugin, GsApp *app)
+{
+	if (gs_app_get_kind (app) == AS_APP_KIND_FIRMWARE)
+		gs_app_set_management_plugin (app, gs_plugin_get_name (plugin));
+}
+
+static void
+gs_plugin_fwupd_changed_cb (FwupdClient *client, GsPlugin *plugin)
+{
+}
+
+static void
+gs_plugin_fwupd_device_changed_cb (FwupdClient *client,
+				   FwupdDevice *dev,
+				   GsPlugin *plugin)
+{
+	/* limit number of UI refreshes */
+	if (!fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_SUPPORTED)) {
+		g_debug ("%s changed (not supported) so ignoring",
+			 fwupd_device_get_id (dev));
+		return;
+	}
+
+	/* If the flag is set the device matches something in the
+	 * metadata as therefor is worth refreshing the update list */
+	g_debug ("%s changed (supported) so reloading",
+		 fwupd_device_get_id (dev));
+	gs_plugin_updates_changed (plugin);
+}
+
+static void
+gs_plugin_fwupd_notify_percentage_cb (GObject *object,
+				      GParamSpec *pspec,
+				      GsPlugin *plugin)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+
+	/* nothing in progress */
+	if (priv->app_current == NULL) {
+		g_debug ("fwupd percentage: %u%%",
+			 fwupd_client_get_percentage (priv->client));
+		return;
+	}
+	g_debug ("fwupd percentage for %s: %u%%",
+		 gs_app_get_unique_id (priv->app_current),
+		 fwupd_client_get_percentage (priv->client));
+	gs_app_set_progress (priv->app_current,
+			     fwupd_client_get_percentage (priv->client));
+}
+
+static void
+gs_plugin_fwupd_notify_status_cb (GObject *object,
+				  GParamSpec *pspec,
+				  GsPlugin *plugin)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+
+	/* nothing in progress */
+	if (priv->app_current == NULL) {
+		g_debug ("fwupd status: %s",
+			 fwupd_status_to_string (fwupd_client_get_status (priv->client)));
+		return;
+	}
+
+	g_debug ("fwupd status for %s: %s",
+		 gs_app_get_unique_id (priv->app_current),
+		 fwupd_status_to_string (fwupd_client_get_status (priv->client)));
+	switch (fwupd_client_get_status (priv->client)) {
+	case FWUPD_STATUS_DECOMPRESSING:
+	case FWUPD_STATUS_DEVICE_RESTART:
+	case FWUPD_STATUS_DEVICE_WRITE:
+	case FWUPD_STATUS_DEVICE_VERIFY:
+		gs_app_set_state (priv->app_current, AS_APP_STATE_INSTALLING);
+		break;
+	case FWUPD_STATUS_IDLE:
+		g_clear_object (&priv->app_current);
+		break;
+	default:
+		break;
+	}
+}
+
+static gchar *
+gs_plugin_fwupd_get_file_checksum (const gchar *filename,
+				   GChecksumType checksum_type,
+				   GError **error)
+{
+	gsize len;
+	g_autofree gchar *data = NULL;
+
+	if (!g_file_get_contents (filename, &data, &len, error)) {
+		gs_utils_error_convert_gio (error);
+		return NULL;
+	}
+	return g_compute_checksum_for_data (checksum_type, (const guchar *)data, len);
+}
+
+gboolean
+gs_plugin_setup (GsPlugin *plugin, GCancellable *cancellable, GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	g_autoptr(SoupSession) soup_session = NULL;
+
+#if FWUPD_CHECK_VERSION(1,4,5)
+	g_autoptr(GError) error_local = NULL;
+	/* send our implemented feature set */
+	if (!fwupd_client_set_feature_flags (priv->client,
+					     FWUPD_FEATURE_FLAG_UPDATE_ACTION |
+					     FWUPD_FEATURE_FLAG_DETACH_ACTION,
+					     cancellable, &error_local))
+		g_debug ("Failed to set front-end features: %s", error_local->message);
+
+	/* we know the runtime daemon version now */
+	fwupd_client_set_user_agent_for_package (priv->client, PACKAGE_NAME, PACKAGE_VERSION);
+	if (!fwupd_client_ensure_networking (priv->client, error)) {
+		gs_plugin_fwupd_error_convert (error);
+		g_prefix_error (error, "Failed to setup networking: ");
+		return FALSE;
+	}
+	g_object_get (priv->client, "soup-session", &soup_session, NULL);
+#else
+	g_autofree gchar *user_agent = NULL;
+	/* use a custom user agent to provide the fwupd version */
+	user_agent = fwupd_build_user_agent (PACKAGE_NAME, PACKAGE_VERSION);
+	soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, user_agent,
+						      SOUP_SESSION_TIMEOUT, 10,
+						      NULL);
+	soup_session_remove_feature_by_type (soup_session, SOUP_TYPE_CONTENT_DECODER);
+#endif
+
+	/* use for gnome-software downloads */
+	gs_plugin_set_soup_session (plugin, soup_session);
+
+	/* 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_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_add_quirk (app, GS_APP_QUIRK_DO_NOT_AUTO_UPDATE);
+	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_device (app, dev);
+	gs_fwupd_app_set_from_release (app, rel);
+
+	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;
+}
+
+static gchar *
+gs_plugin_fwupd_build_device_id (FwupdDevice *dev)
+{
+	g_autofree gchar *tmp = g_strdup (fwupd_device_get_id (dev));
+	g_strdelimit (tmp, "/", '_');
+	return g_strdup_printf ("org.fwupd.%s.device", tmp);
+}
+
+static GsApp *
+gs_plugin_fwupd_new_app_from_device_raw (GsPlugin *plugin, FwupdDevice *device)
+{
+	GPtrArray *icons;
+	g_autofree gchar *id = NULL;
+	g_autoptr(GsApp) app = NULL;
+
+	/* create a GsApp based on the device, not the release */
+	id = gs_plugin_fwupd_build_device_id (device);
+	app = gs_app_new (id);
+	gs_app_set_kind (app, AS_APP_KIND_FIRMWARE);
+	gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
+	gs_app_set_state (app, AS_APP_STATE_INSTALLED);
+	gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
+	gs_app_add_quirk (app, GS_APP_QUIRK_DO_NOT_AUTO_UPDATE);
+	gs_app_set_version (app, fwupd_device_get_version (device));
+	gs_app_set_name (app, GS_APP_QUALITY_LOWEST, fwupd_device_get_name (device));
+	gs_app_set_summary (app, GS_APP_QUALITY_LOWEST, fwupd_device_get_summary (device));
+	gs_app_set_description (app, GS_APP_QUALITY_LOWEST, fwupd_device_get_description (device));
+	gs_app_set_origin (app, fwupd_device_get_vendor (device));
+	gs_fwupd_app_set_device_id (app, fwupd_device_get_id (device));
+	gs_app_set_management_plugin (app, "fwupd");
+
+	/* create icon */
+	icons = fwupd_device_get_icons (device);
+	for (guint j = 0; j < icons->len; j++) {
+		const gchar *icon = g_ptr_array_index (icons, j);
+		g_autoptr(AsIcon) icon_tmp = as_icon_new ();
+		if (g_str_has_prefix (icon, "/")) {
+			as_icon_set_kind (icon_tmp, AS_ICON_KIND_LOCAL);
+			as_icon_set_filename (icon_tmp, icon);
+		} else {
+			as_icon_set_kind (icon_tmp, AS_ICON_KIND_STOCK);
+			as_icon_set_name (icon_tmp, icon);
+		}
+		gs_app_add_icon (app, icon_tmp);
+	}
+	return g_steal_pointer (&app);
+}
+
+static GsApp *
+gs_plugin_fwupd_new_app (GsPlugin *plugin, FwupdDevice *dev, GError **error)
+{
+	FwupdRelease *rel = fwupd_device_get_release_default (dev);
+	GPtrArray *checksums;
+	const gchar *update_uri;
+	g_autofree gchar *basename = NULL;
+	g_autofree gchar *filename_cache = NULL;
+	g_autoptr(GFile) file = NULL;
+	g_autoptr(GsApp) app = NULL;
+
+	/* update unsupported */
+	app = gs_plugin_fwupd_new_app_from_device (plugin, dev);
+	if (gs_app_get_state (app) != AS_APP_STATE_UPDATABLE_LIVE) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_NOT_SUPPORTED,
+			     "%s [%s] cannot be updated",
+			     gs_app_get_name (app), gs_app_get_id (app));
+		return NULL;
+	}
+
+	/* some missing */
+	if (gs_app_get_id (app) == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_NOT_SUPPORTED,
+			     "fwupd: No id for firmware");
+		return NULL;
+	}
+	if (gs_app_get_version (app) == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_NOT_SUPPORTED,
+			     "fwupd: No version! for %s!", gs_app_get_id (app));
+		return NULL;
+	}
+	if (gs_app_get_update_version (app) == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_NOT_SUPPORTED,
+			     "fwupd: No update-version! for %s!", gs_app_get_id (app));
+		return NULL;
+	}
+	checksums = fwupd_release_get_checksums (rel);
+	if (checksums->len == 0) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_NO_SECURITY,
+			     "%s [%s] (%s) has no checksums, ignoring as unsafe",
+			     gs_app_get_name (app),
+			     gs_app_get_id (app),
+			     gs_app_get_update_version (app));
+		return NULL;
+	}
+	update_uri = fwupd_release_get_uri (rel);
+	if (update_uri == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_INVALID_FORMAT,
+			     "no location available for %s [%s]",
+			     gs_app_get_name (app), gs_app_get_id (app));
+		return NULL;
+	}
+
+	/* does the firmware already exist in the cache? */
+	basename = g_path_get_basename (update_uri);
+	filename_cache = gs_utils_get_cache_filename ("fwupd",
+						      basename,
+						      GS_UTILS_CACHE_FLAG_NONE,
+						      error);
+	if (filename_cache == NULL)
+		return NULL;
+
+	/* delete the file if the checksum does not match */
+	if (g_file_test (filename_cache, G_FILE_TEST_EXISTS)) {
+		const gchar *checksum_tmp = NULL;
+		g_autofree gchar *checksum = NULL;
+
+		/* we can migrate to something better than SHA1 when the LVFS
+		 * starts producing metadata with multiple hash types */
+		checksum_tmp = fwupd_checksum_get_by_kind (checksums,
+							   G_CHECKSUM_SHA1);
+		if (checksum_tmp == NULL) {
+			g_set_error (error,
+				     GS_PLUGIN_ERROR,
+				     GS_PLUGIN_ERROR_INVALID_FORMAT,
+				     "No valid checksum for %s",
+				     filename_cache);
+		}
+		checksum = gs_plugin_fwupd_get_file_checksum (filename_cache,
+							      G_CHECKSUM_SHA1,
+							      error);
+		if (checksum == NULL)
+			return NULL;
+		if (g_strcmp0 (checksum_tmp, checksum) != 0) {
+			g_set_error (error,
+				     GS_PLUGIN_ERROR,
+				     GS_PLUGIN_ERROR_INVALID_FORMAT,
+				     "%s does not match checksum, expected %s got %s",
+				     filename_cache, checksum_tmp, checksum);
+			g_unlink (filename_cache);
+			return NULL;
+		}
+	}
+
+	/* already downloaded, so overwrite */
+	if (g_file_test (filename_cache, G_FILE_TEST_EXISTS))
+		gs_app_set_size_download (app, 0);
+
+	/* actually add the application */
+	file = g_file_new_for_path (filename_cache);
+	gs_app_set_local_file (app, file);
+	return g_steal_pointer (&app);
+}
+
+gboolean
+gs_plugin_add_updates_historical (GsPlugin *plugin,
+				  GsAppList *list,
+				  GCancellable *cancellable,
+				  GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	g_autoptr(GError) error_local = NULL;
+	g_autoptr(GsApp) app = NULL;
+	g_autoptr(FwupdDevice) dev = NULL;
+
+	/* get historical updates */
+	dev = fwupd_client_get_results (priv->client,
+					FWUPD_DEVICE_ID_ANY,
+					cancellable,
+					&error_local);
+	if (dev == NULL) {
+		if (g_error_matches (error_local,
+				     FWUPD_ERROR,
+				     FWUPD_ERROR_NOTHING_TO_DO))
+			return TRUE;
+		if (g_error_matches (error_local,
+				     FWUPD_ERROR,
+				     FWUPD_ERROR_NOT_FOUND))
+			return TRUE;
+		g_propagate_error (error, g_steal_pointer (&error_local));
+		gs_plugin_fwupd_error_convert (error);
+		return FALSE;
+	}
+
+	/* parse */
+	app = gs_plugin_fwupd_new_app_from_device (plugin, dev);
+	if (app == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_FAILED,
+			     "failed to build result for %s",
+			     fwupd_device_get_id (dev));
+		return FALSE;
+	}
+	gs_app_list_add (list, app);
+	return TRUE;
+}
+
+gboolean
+gs_plugin_add_updates (GsPlugin *plugin,
+		       GsAppList *list,
+		       GCancellable *cancellable,
+		       GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	g_autoptr(GError) error_local = NULL;
+	g_autoptr(GPtrArray) devices = NULL;
+
+	/* get current list of updates */
+	devices = fwupd_client_get_devices (priv->client, cancellable, &error_local);
+	if (devices == NULL) {
+		if (g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO) ||
+		    g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED) ||
+		    g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND)) {
+			g_debug ("no devices (%s)", error_local->message);
+			return TRUE;
+		}
+		g_propagate_error (error, g_steal_pointer (&error_local));
+		gs_plugin_fwupd_error_convert (error);
+		return FALSE;
+	}
+	for (guint i = 0; i < devices->len; i++) {
+		FwupdDevice *dev = g_ptr_array_index (devices, i);
+		FwupdRelease *rel_newest;
+		g_autoptr(GError) error_local2 = NULL;
+		g_autoptr(GPtrArray) rels = NULL;
+		g_autoptr(GsApp) app = NULL;
+
+		/* locked device that needs unlocking */
+		if (fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_LOCKED)) {
+			app = gs_plugin_fwupd_new_app_from_device_raw (plugin, dev);
+			gs_fwupd_app_set_is_locked (app, TRUE);
+			gs_app_list_add (list, app);
+			continue;
+		}
+
+		/* not going to have results, so save a D-Bus round-trip */
+		if (!fwupd_device_has_flag (dev, FWUPD_DEVICE_FLAG_SUPPORTED))
+			continue;
+
+		/* get the releases for this device and filter for validity */
+		rels = fwupd_client_get_upgrades (priv->client,
+						  fwupd_device_get_id (dev),
+						  cancellable, &error_local2);
+		if (rels == NULL) {
+			if (g_error_matches (error_local2,
+					     FWUPD_ERROR,
+					     FWUPD_ERROR_NOTHING_TO_DO)) {
+				g_debug ("no updates for %s", fwupd_device_get_id (dev));
+				continue;
+			}
+			if (g_error_matches (error_local2,
+					     FWUPD_ERROR,
+					     FWUPD_ERROR_NOT_SUPPORTED)) {
+				g_debug ("not supported for %s", fwupd_device_get_id (dev));
+				continue;
+			}
+			g_warning ("failed to get upgrades for %s: %s]",
+				   fwupd_device_get_id (dev),
+				   error_local2->message);
+			continue;
+		}
+
+		/* normal device update */
+		rel_newest = g_ptr_array_index (rels, 0);
+		fwupd_device_add_release (dev, rel_newest);
+		app = gs_plugin_fwupd_new_app (plugin, dev, &error_local2);
+		if (app == NULL) {
+			g_debug ("%s", error_local2->message);
+			continue;
+		}
+
+		/* add update descriptions for all releases inbetween */
+		if (rels->len > 1) {
+			g_autoptr(GString) update_desc = g_string_new (NULL);
+			for (guint j = 0; j < rels->len; j++) {
+				FwupdRelease *rel = g_ptr_array_index (rels, j);
+				g_autofree gchar *desc = NULL;
+				if (fwupd_release_get_description (rel) == NULL)
+					continue;
+				desc = as_markup_convert (fwupd_release_get_description (rel),
+							  AS_MARKUP_CONVERT_FORMAT_SIMPLE,
+							  NULL);
+				if (desc == NULL)
+					continue;
+				g_string_append_printf (update_desc,
+							"Version %s:\n%s\n\n",
+							fwupd_release_get_version (rel),
+							desc);
+			}
+			if (update_desc->len > 2) {
+				g_string_truncate (update_desc, update_desc->len - 2);
+				gs_app_set_update_details (app, update_desc->str);
+			}
+		}
+		gs_app_list_add (list, app);
+	}
+	return TRUE;
+}
+
+static gboolean
+gs_plugin_fwupd_refresh_remote (GsPlugin *plugin,
+				FwupdRemote *remote,
+				guint cache_age,
+				GCancellable *cancellable,
+				GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	GChecksumType checksum_kind;
+	const gchar *url_sig = NULL;
+	const gchar *url = NULL;
+	g_autoptr(GError) error_local = NULL;
+	g_autofree gchar *basename = NULL;
+	g_autofree gchar *basename_sig = NULL;
+	g_autofree gchar *cache_id = NULL;
+	g_autofree gchar *checksum = NULL;
+	g_autofree gchar *filename = NULL;
+	g_autofree gchar *filename_sig = NULL;
+	g_autoptr(GBytes) data = NULL;
+	g_autoptr(GsApp) app_dl = gs_app_new (gs_plugin_get_name (plugin));
+
+	/* sanity check */
+	if (fwupd_remote_get_filename_cache_sig (remote) == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_FAILED,
+			     "remote %s has no cache signature",
+			     fwupd_remote_get_id (remote));
+		return FALSE;
+	}
+
+	/* check cache age */
+	if (cache_age > 0) {
+		guint64 age = fwupd_remote_get_age (remote);
+		guint tmp = age < G_MAXUINT ? (guint) age : G_MAXUINT;
+		if (tmp < cache_age) {
+			g_debug ("fwupd remote is only %u seconds old, so ignoring refresh",
+				 tmp);
+			return TRUE;
+		}
+	}
+
+	/* download the signature first, it's smaller */
+	cache_id = g_strdup_printf ("fwupd/remotes.d/%s", fwupd_remote_get_id (remote));
+	basename_sig = g_path_get_basename (fwupd_remote_get_filename_cache_sig (remote));
+	filename_sig = gs_utils_get_cache_filename (cache_id, basename_sig,
+						    GS_UTILS_CACHE_FLAG_WRITEABLE,
+						    error);
+
+	/* download the signature first, it's smaller */
+	url_sig = fwupd_remote_get_metadata_uri_sig (remote);
+	gs_app_set_summary_missing (app_dl,
+				    /* TRANSLATORS: status text when downloading */
+				    _("Downloading firmware update signature…"));
+	data = gs_plugin_download_data (plugin, app_dl, url_sig, cancellable, error);
+	if (data == NULL) {
+		gs_utils_error_add_origin_id (error, priv->cached_origin);
+		return FALSE;
+	}
+
+	/* is the signature hash the same as we had before? */
+	checksum_kind = fwupd_checksum_guess_kind (fwupd_remote_get_checksum (remote));
+	checksum = g_compute_checksum_for_data (checksum_kind,
+						(const guchar *) g_bytes_get_data (data, NULL),
+						g_bytes_get_size (data));
+	if (g_strcmp0 (checksum, fwupd_remote_get_checksum (remote)) == 0) {
+		g_debug ("signature of %s is unchanged", url_sig);
+		return TRUE;
+	}
+
+	/* save to a file */
+	g_debug ("saving new remote signature to %s:", filename_sig);
+	if (!g_file_set_contents (filename_sig,
+				  g_bytes_get_data (data, NULL),
+				  (guint) g_bytes_get_size (data),
+				  &error_local)) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_WRITE_FAILED,
+			     "Failed to save firmware signature: %s",
+			     error_local->message);
+		return FALSE;
+	}
+
+	/* download the payload and save to file */
+	basename = g_path_get_basename (fwupd_remote_get_filename_cache (remote));
+	filename = gs_utils_get_cache_filename (cache_id, basename,
+						GS_UTILS_CACHE_FLAG_WRITEABLE,
+						error);
+	if (filename == NULL)
+		return FALSE;
+	g_debug ("saving new firmware metadata to %s:", filename);
+	gs_app_set_summary_missing (app_dl,
+				    /* TRANSLATORS: status text when downloading */
+				    _("Downloading firmware update metadata…"));
+	url = fwupd_remote_get_metadata_uri (remote);
+	if (!gs_plugin_download_file (plugin, app_dl, url, filename,
+				      cancellable, error)) {
+		gs_utils_error_add_origin_id (error, priv->cached_origin);
+		return FALSE;
+	}
+
+	/* phew, lets send all this to fwupd */
+	if (!fwupd_client_update_metadata (priv->client,
+					   fwupd_remote_get_id (remote),
+					   filename,
+					   filename_sig,
+					   cancellable,
+					   error)) {
+		gs_plugin_fwupd_error_convert (error);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+gboolean
+gs_plugin_refresh (GsPlugin *plugin,
+		   guint cache_age,
+		   GCancellable *cancellable,
+		   GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	g_autoptr(GError) error_local = NULL;
+	g_autoptr(GPtrArray) remotes = NULL;
+
+	/* get the list of enabled remotes */
+	remotes = fwupd_client_get_remotes (priv->client, cancellable, &error_local);
+	if (remotes == NULL) {
+		g_debug ("No remotes found: %s", error_local ? error_local->message : "Unknown error");
+		if (g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO) ||
+		    g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED) ||
+		    g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND))
+			return TRUE;
+		g_propagate_error (error, g_steal_pointer (&error_local));
+		gs_plugin_fwupd_error_convert (error);
+		return FALSE;
+	}
+	for (guint i = 0; i < remotes->len; i++) {
+		FwupdRemote *remote = g_ptr_array_index (remotes, i);
+		if (!fwupd_remote_get_enabled (remote))
+			continue;
+		if (fwupd_remote_get_kind (remote) == FWUPD_REMOTE_KIND_LOCAL)
+			continue;
+		if (!gs_plugin_fwupd_refresh_remote (plugin, remote, cache_age,
+						     cancellable, error))
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static gboolean
+gs_plugin_fwupd_install (GsPlugin *plugin,
+			 GsApp *app,
+			 GCancellable *cancellable,
+			 GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	const gchar *device_id;
+	FwupdInstallFlags install_flags = 0;
+	GFile *local_file;
+	g_autofree gchar *filename = NULL;
+	gboolean downloaded_to_cache = FALSE;
+	g_autoptr(FwupdDevice) dev = NULL;
+	g_autoptr(GError) error_local = NULL;
+
+	/* not set */
+	local_file = gs_app_get_local_file (app);
+	if (local_file == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_FAILED,
+			     "not enough data for fwupd %s",
+			     filename);
+		return FALSE;
+	}
+
+	/* file does not yet exist */
+	filename = g_file_get_path (local_file);
+	if (!g_file_query_exists (local_file, cancellable)) {
+		const gchar *uri = gs_fwupd_app_get_update_uri (app);
+		gs_app_set_state (app, AS_APP_STATE_INSTALLING);
+		if (!gs_plugin_download_file (plugin, app, uri, filename,
+					      cancellable, error))
+			return FALSE;
+		downloaded_to_cache = TRUE;
+	}
+
+	/* limit to single device? */
+	device_id = gs_fwupd_app_get_device_id (app);
+	if (device_id == NULL)
+		device_id = FWUPD_DEVICE_ID_ANY;
+
+	/* set the last object */
+	g_set_object (&priv->app_current, app);
+
+	/* only offline supported */
+	if (gs_app_get_metadata_item (app, "fwupd::OnlyOffline") != NULL)
+		install_flags |= FWUPD_INSTALL_FLAG_OFFLINE;
+
+	gs_app_set_state (app, AS_APP_STATE_INSTALLING);
+	if (!fwupd_client_install (priv->client, device_id,
+				   filename, install_flags,
+				   cancellable, error)) {
+		gs_plugin_fwupd_error_convert (error);
+		gs_app_set_state_recover (app);
+		return FALSE;
+	}
+
+	/* delete the file from the cache */
+	gs_app_set_state (app, AS_APP_STATE_INSTALLED);
+	if (downloaded_to_cache) {
+		if (!g_file_delete (local_file, cancellable, error))
+			return FALSE;
+	}
+
+	/* does the device have an update message */
+	dev = fwupd_client_get_device_by_id (priv->client, device_id,
+					     cancellable, &error_local);
+	if (dev == NULL) {
+		/* NOTE: this is probably entirely fine; some devices do not
+		 * re-enumerate until replugged manually or the machine is
+		 * rebooted -- and the metadata to know that is only available
+		 * in a too-new-to-depend-on fwupd version */
+		g_debug ("failed to find device after install: %s", error_local->message);
+	} else {
+		if (fwupd_device_get_update_message (dev) != NULL) {
+			g_autoptr(AsScreenshot) ss = as_screenshot_new ();
+
+#if FWUPD_CHECK_VERSION(1,4,5)
+			/* image is optional */
+			if (fwupd_device_get_update_image (dev) != NULL) {
+				g_autoptr(AsImage) im = as_image_new ();
+				as_image_set_kind (im, AS_IMAGE_KIND_SOURCE);
+				as_image_set_url (im, fwupd_device_get_update_image (dev));
+				as_screenshot_add_image (ss, im);
+			}
+#endif
+
+			/* caption is required */
+			as_screenshot_set_kind (ss, AS_SCREENSHOT_KIND_DEFAULT);
+			as_screenshot_set_caption (ss, NULL, fwupd_device_get_update_message (dev));
+			gs_app_set_action_screenshot (app, ss);
+
+			/* require the dialog */
+			gs_app_add_quirk (app, GS_APP_QUIRK_NEEDS_USER_ACTION);
+		}
+	}
+
+	/* success */
+	return TRUE;
+}
+
+static gboolean
+gs_plugin_fwupd_modify_source (GsPlugin *plugin, GsApp *app, gboolean enabled,
+			       GCancellable *cancellable, GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	const gchar *remote_id = gs_app_get_metadata_item (app, "fwupd::remote-id");
+	if (remote_id == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_FAILED,
+			     "not enough data for fwupd %s",
+			     gs_app_get_unique_id (app));
+		return FALSE;
+	}
+	gs_app_set_state (app, enabled ?
+	                  AS_APP_STATE_INSTALLING : AS_APP_STATE_REMOVING);
+	if (!fwupd_client_modify_remote (priv->client,
+	                                 remote_id,
+	                                 "Enabled",
+	                                 enabled ? "true" : "false",
+	                                 cancellable,
+	                                 error)) {
+		gs_app_set_state_recover (app);
+		return FALSE;
+	}
+	gs_app_set_state (app, enabled ?
+	                  AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
+	return TRUE;
+}
+
+gboolean
+gs_plugin_app_install (GsPlugin *plugin,
+		       GsApp *app,
+		       GCancellable *cancellable,
+		       GError **error)
+{
+	/* only process this app if was created by this plugin */
+	if (g_strcmp0 (gs_app_get_management_plugin (app),
+		       gs_plugin_get_name (plugin)) != 0)
+		return TRUE;
+
+	/* source -> remote */
+	if (gs_app_get_kind (app) == AS_APP_KIND_SOURCE) {
+		return gs_plugin_fwupd_modify_source (plugin, app, TRUE,
+						      cancellable, error);
+	}
+
+	/* firmware */
+	return gs_plugin_fwupd_install (plugin, app, cancellable, error);
+}
+
+gboolean
+gs_plugin_app_remove (GsPlugin *plugin, GsApp *app,
+		      GCancellable *cancellable, GError **error)
+{
+	/* only process this app if was created by this plugin */
+	if (g_strcmp0 (gs_app_get_management_plugin (app),
+		       gs_plugin_get_name (plugin)) != 0)
+		return TRUE;
+
+	/* source -> remote */
+	return gs_plugin_fwupd_modify_source (plugin, app, FALSE, cancellable, error);
+}
+
+gboolean
+gs_plugin_download_app (GsPlugin *plugin,
+			GsApp *app,
+			GCancellable *cancellable,
+			GError **error)
+{
+	GFile *local_file;
+	g_autofree gchar *filename = NULL;
+
+	/* only process this app if was created by this plugin */
+	if (g_strcmp0 (gs_app_get_management_plugin (app),
+		       gs_plugin_get_name (plugin)) != 0)
+		return TRUE;
+
+	/* not set */
+	local_file = gs_app_get_local_file (app);
+	if (local_file == NULL) {
+		g_set_error (error,
+			     GS_PLUGIN_ERROR,
+			     GS_PLUGIN_ERROR_FAILED,
+			     "not enough data for fwupd %s",
+			     filename);
+		return FALSE;
+	}
+
+	/* file does not yet exist */
+	filename = g_file_get_path (local_file);
+	if (!g_file_query_exists (local_file, cancellable)) {
+		const gchar *uri = gs_fwupd_app_get_update_uri (app);
+
+		if (!gs_plugin_has_flags (plugin, GS_PLUGIN_FLAGS_INTERACTIVE)) {
+			g_autoptr(GError) error_local = NULL;
+
+			if (!gs_metered_block_app_on_download_scheduler (app, cancellable, &error_local)) {
+				g_warning ("Failed to block on download scheduler: %s",
+					   error_local->message);
+				g_clear_error (&error_local);
+			}
+		}
+
+		if (!gs_plugin_download_file (plugin, app, uri, filename,
+					      cancellable, error))
+			return FALSE;
+	}
+	gs_app_set_size_download (app, 0);
+	return TRUE;
+}
+
+gboolean
+gs_plugin_update_app (GsPlugin *plugin,
+		      GsApp *app,
+		      GCancellable *cancellable,
+		      GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	/* only process this app if was created by this plugin */
+	if (g_strcmp0 (gs_app_get_management_plugin (app),
+		       gs_plugin_get_name (plugin)) != 0)
+		return TRUE;
+
+	/* locked devices need unlocking, rather than installing */
+	if (gs_fwupd_app_get_is_locked (app)) {
+		const gchar *device_id;
+		device_id = gs_fwupd_app_get_device_id (app);
+		if (device_id == NULL) {
+			g_set_error_literal (error,
+					     GS_PLUGIN_ERROR,
+					     GS_PLUGIN_ERROR_INVALID_FORMAT,
+					     "not enough data for fwupd unlock");
+			return FALSE;
+		}
+		if (!fwupd_client_unlock (priv->client, device_id,
+					  cancellable, error)) {
+			gs_plugin_fwupd_error_convert (error);
+			return FALSE;
+		}
+		return TRUE;
+	}
+
+	/* update means install */
+	if (!gs_plugin_fwupd_install (plugin, app, cancellable, error)) {
+		gs_plugin_fwupd_error_convert (error);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+gboolean
+gs_plugin_file_to_app (GsPlugin *plugin,
+		       GsAppList *list,
+		       GFile *file,
+		       GCancellable *cancellable,
+		       GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	g_autofree gchar *content_type = NULL;
+	g_autofree gchar *filename = NULL;
+	g_autoptr(GPtrArray) devices = NULL;
+	const gchar *mimetypes[] = {
+		"application/vnd.ms-cab-compressed",
+		NULL };
+
+	/* does this match any of the mimetypes we support */
+	content_type = gs_utils_get_content_type (file, cancellable, error);
+	if (content_type == NULL)
+		return FALSE;
+	if (!g_strv_contains (mimetypes, content_type))
+		return TRUE;
+
+	/* get results */
+	filename = g_file_get_path (file);
+	devices = fwupd_client_get_details (priv->client,
+					    filename,
+					    cancellable,
+					    error);
+	if (devices == NULL) {
+		gs_plugin_fwupd_error_convert (error);
+		return FALSE;
+	}
+	for (guint i = 0; i < devices->len; i++) {
+		FwupdDevice *dev = g_ptr_array_index (devices, i);
+		g_autoptr(GsApp) app = NULL;
+
+		/* create each app */
+		app = gs_plugin_fwupd_new_app_from_device (plugin, dev);
+
+		/* we *might* have no update view for local files */
+		gs_app_set_version (app, gs_app_get_update_version (app));
+		gs_app_set_description (app, GS_APP_QUALITY_LOWEST,
+					gs_app_get_update_details (app));
+		gs_app_list_add (list, app);
+	}
+	return TRUE;
+}
+
+gboolean
+gs_plugin_add_sources (GsPlugin *plugin,
+		       GsAppList *list,
+		       GCancellable *cancellable,
+		       GError **error)
+{
+	GsPluginData *priv = gs_plugin_get_data (plugin);
+	g_autoptr(GPtrArray) remotes = NULL;
+
+	/* find all remotes */
+	remotes = fwupd_client_get_remotes (priv->client, cancellable, error);
+	if (remotes == NULL)
+		return FALSE;
+	for (guint i = 0; i < remotes->len; i++) {
+		FwupdRemote *remote = g_ptr_array_index (remotes, i);
+		g_autofree gchar *id = NULL;
+		g_autoptr(GsApp) app = NULL;
+
+		/* ignore these, they're built in */
+		if (fwupd_remote_get_kind (remote) != FWUPD_REMOTE_KIND_DOWNLOAD)
+			continue;
+
+		/* create something that we can use to enable/disable */
+		id = g_strdup_printf ("org.fwupd.%s.remote", fwupd_remote_get_id (remote));
+		app = gs_app_new (id);
+		gs_app_set_kind (app, AS_APP_KIND_SOURCE);
+		gs_app_set_scope (app, AS_APP_SCOPE_SYSTEM);
+		gs_app_set_state (app, fwupd_remote_get_enabled (remote) ?
+				  AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
+		gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
+		gs_app_set_name (app, GS_APP_QUALITY_LOWEST,
+				 fwupd_remote_get_title (remote));
+#if FWUPD_CHECK_VERSION(1,0,7)
+		gs_app_set_agreement (app, fwupd_remote_get_agreement (remote));
+#endif
+		gs_app_set_url (app, AS_URL_KIND_HOMEPAGE,
+				fwupd_remote_get_metadata_uri (remote));
+		gs_app_set_metadata (app, "fwupd::remote-id",
+				     fwupd_remote_get_id (remote));
+		gs_app_set_management_plugin (app, "fwupd");
+		gs_app_list_add (list, app);
+	}
+	return TRUE;
+}
diff --git a/plugins/fwupd/gs-self-test.c b/plugins/fwupd/gs-self-test.c
new file mode 100644
index 0000000..ca5fcb8
--- /dev/null
+++ b/plugins/fwupd/gs-self-test.c
@@ -0,0 +1,105 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * vi:set noexpandtab tabstop=8 shiftwidth=8:
+ *
+ * Copyright (C) 2013-2017 Richard Hughes <richard@hughsie.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include "config.h"
+
+#include "gnome-software-private.h"
+
+#include "gs-test.h"
+
+static void
+gs_plugins_fwupd_func (GsPluginLoader *plugin_loader)
+{
+	g_autofree gchar *fn = NULL;
+	g_autoptr(GError) error = NULL;
+	g_autoptr(GFile) file = NULL;
+	g_autoptr(GsApp) app = NULL;
+	g_autoptr(GsPluginJob) plugin_job = NULL;
+
+	/* no fwupd, abort */
+	if (!gs_plugin_loader_get_enabled (plugin_loader, "fwupd")) {
+		g_test_skip ("not enabled");
+		return;
+	}
+
+	/* load local file */
+	fn = gs_test_get_filename (TESTDATADIR, "chiron-0.2.cab");
+	g_assert (fn != NULL);
+	file = g_file_new_for_path (fn);
+	plugin_job = gs_plugin_job_newv (GS_PLUGIN_ACTION_FILE_TO_APP,
+					 "file", file,
+					 NULL);
+	app = gs_plugin_loader_job_process_app (plugin_loader, plugin_job, NULL, &error);
+	gs_test_flush_main_context ();
+	g_assert_no_error (error);
+	g_assert (app != NULL);
+	g_assert_cmpint (gs_app_get_kind (app), ==, AS_APP_KIND_FIRMWARE);
+	g_assert (gs_app_get_license (app) != NULL);
+	g_assert (gs_app_has_category (app, "System"));
+	g_assert_cmpstr (gs_app_get_id (app), ==, "com.test.chiron.firmware");
+	g_assert_cmpstr (gs_app_get_url (app, AS_URL_KIND_HOMEPAGE), ==, "http://127.0.0.1/");
+	g_assert_cmpstr (gs_app_get_name (app), ==, "Chiron");
+	g_assert_cmpstr (gs_app_get_summary (app), ==, "Single line synopsis");
+	g_assert_cmpstr (gs_app_get_version (app), ==, "0.2");
+	g_assert_cmpint ((gint64) gs_app_get_size_download (app), ==, 32784);
+	g_assert_cmpstr (gs_app_get_description (app), ==,
+			 "This is the first paragraph in the example "
+			 "cab file.\n\nThis is the second paragraph.");
+	g_assert_cmpstr (gs_app_get_update_details (app), ==,
+			 "Latest firmware release.");
+
+	/* seems wrong, but this is only set if the update is available */
+	g_assert_cmpint (gs_app_get_state (app), ==, AS_APP_STATE_UNKNOWN);
+}
+
+int
+main (int argc, char **argv)
+{
+	gboolean ret;
+	g_autoptr(GError) error = NULL;
+	g_autoptr(GsPluginLoader) plugin_loader = NULL;
+	const gchar *allowlist[] = {
+		"fwupd",
+		NULL
+	};
+
+	/* While we use %G_TEST_OPTION_ISOLATE_DIRS to create temporary directories
+	 * for each of the tests, we want to use the system MIME registry, assuming
+	 * that it exists and correctly has shared-mime-info installed. */
+#if GLIB_CHECK_VERSION(2, 60, 0)
+	g_content_type_set_mime_dirs (NULL);
+#endif
+
+	g_test_init (&argc, &argv,
+#if GLIB_CHECK_VERSION(2, 60, 0)
+		     G_TEST_OPTION_ISOLATE_DIRS,
+#endif
+		     NULL);
+	g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
+
+	/* only critical and error are fatal */
+	g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
+
+	/* we can only load this once per process */
+	plugin_loader = gs_plugin_loader_new ();
+	gs_plugin_loader_add_location (plugin_loader, LOCALPLUGINDIR);
+	ret = gs_plugin_loader_setup (plugin_loader,
+				      (gchar**) allowlist,
+				      NULL,
+				      NULL,
+				      &error);
+	g_assert_no_error (error);
+	g_assert (ret);
+
+	/* plugin tests go here */
+	g_test_add_data_func ("/gnome-software/plugins/fwupd",
+			      plugin_loader,
+			      (GTestDataFunc) gs_plugins_fwupd_func);
+
+	return g_test_run ();
+}
diff --git a/plugins/fwupd/meson.build b/plugins/fwupd/meson.build
new file mode 100644
index 0000000..7c89add
--- /dev/null
+++ b/plugins/fwupd/meson.build
@@ -0,0 +1,60 @@
+cargs = ['-DG_LOG_DOMAIN="GsPluginFwupd"']
+cargs += ['-DLOCALPLUGINDIR="' + meson.current_build_dir() + '"']
+deps = [
+  plugin_libs,
+  fwupd,
+]
+
+if get_option('mogwai')
+  deps += [mogwai_schedule_client]
+endif
+
+shared_module(
+  'gs_plugin_fwupd',
+  sources : [
+    'gs-fwupd-app.c',
+    'gs-plugin-fwupd.c',
+  ],
+  include_directories : [
+    include_directories('../..'),
+    include_directories('../../lib'),
+  ],
+  install : true,
+  install_dir: plugin_dir,
+  c_args : cargs,
+  dependencies : deps,
+  link_with : [
+    libgnomesoftware
+  ]
+)
+metainfo = 'org.gnome.Software.Plugin.Fwupd.metainfo.xml'
+
+i18n.merge_file(
+  input: metainfo + '.in',
+  output: metainfo,
+  type: 'xml',
+  po_dir: join_paths(meson.source_root(), 'po'),
+  install: true,
+  install_dir: join_paths(get_option('datadir'), 'metainfo')
+)
+
+if get_option('tests')
+  cargs += ['-DTESTDATADIR="' + join_paths(meson.current_source_dir(), 'tests') + '"']
+  e = executable(
+    'gs-self-test-fwupd',
+    compiled_schemas,
+    sources : [
+      'gs-self-test.c'
+    ],
+    include_directories : [
+      include_directories('../..'),
+      include_directories('../../lib'),
+    ],
+    dependencies : deps,
+    link_with : [
+      libgnomesoftware
+    ],
+    c_args : cargs,
+  )
+  test('gs-self-test-fwupd', e, suite: ['plugins', 'fwupd'], env: test_env)
+endif
diff --git a/plugins/fwupd/org.gnome.Software.Plugin.Fwupd.metainfo.xml.in b/plugins/fwupd/org.gnome.Software.Plugin.Fwupd.metainfo.xml.in
new file mode 100644
index 0000000..3f2067d
--- /dev/null
+++ b/plugins/fwupd/org.gnome.Software.Plugin.Fwupd.metainfo.xml.in
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright 2013-2016 Richard Hughes <richard@hughsie.com> -->
+<component type="addon">
+  <id>org.gnome.Software.Plugin.Fwupd</id>
+  <extends>org.gnome.Software.desktop</extends>
+  <name>Firmware Upgrade Support</name>
+  <summary>Provides support for firmware upgrades</summary>
+  <url type="homepage">http://www.fwupd.org</url>
+  <metadata_license>CC0-1.0</metadata_license>
+  <project_license>GPL-2.0+</project_license>
+  <update_contact>richard_at_hughsie.com</update_contact>
+</component>
diff --git a/plugins/fwupd/tests/build-cab.sh b/plugins/fwupd/tests/build-cab.sh
new file mode 100755
index 0000000..ea7bed6
--- /dev/null
+++ b/plugins/fwupd/tests/build-cab.sh
@@ -0,0 +1,4 @@
+gcab --create chiron-0.2.cab	\
+	firmware.dfu			\
+	firmware.dfu.asc		\
+	firmware.metainfo.xml
diff --git a/plugins/fwupd/tests/chiron-0.2.cab b/plugins/fwupd/tests/chiron-0.2.cab
new file mode 100644
index 0000000..6618361
--- /dev/null
+++ b/plugins/fwupd/tests/chiron-0.2.cab
diff --git a/plugins/fwupd/tests/firmware.dfu b/plugins/fwupd/tests/firmware.dfu
new file mode 100644
index 0000000..50f00c0
--- /dev/null
+++ b/plugins/fwupd/tests/firmware.dfu
diff --git a/plugins/fwupd/tests/firmware.dfu.asc b/plugins/fwupd/tests/firmware.dfu.asc
new file mode 100644
index 0000000..0ea79a7
--- /dev/null
+++ b/plugins/fwupd/tests/firmware.dfu.asc
@@ -0,0 +1,11 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.14 (GNU/Linux)
+
+iQEcBAABAgAGBQJWUy6EAAoJEEim2A5FOLrCxokIAJJtLVkuXZHgEu2C2Eq9jGrR
+FZ9/z9XtsMgs33teLdmYUAQwvnNIbtIb6z7JViP8llCREP8y2fH+1OjrOOdtuS/A
+bIJ0r40c9wYeH97ZcXBdHZiYVEFO+etbMBUg5ifuRO5VPjD9H1NqL05Wx9kUg/1T
+a1fwgHopXR0T4jYcg5aijp3mdgfmg4boIklDaRV/g2c93W+0VhDZ2h5sKwBxxlFS
+TrptclTMCvRYmVvL1CDOsBtgzu3jGo03wV9rcnSKzeBWvINcvlRLdS0ejlPaRYDK
+MUY4MBVz3fDW1vFsqLpU80XMOYk0bxtQqQ2MsrlXWp9qazB+A6mC7kOnJQfx0yI=
+=A3W8
+-----END PGP SIGNATURE-----
diff --git a/plugins/fwupd/tests/firmware.metainfo.xml b/plugins/fwupd/tests/firmware.metainfo.xml
new file mode 100644
index 0000000..d942fd8
--- /dev/null
+++ b/plugins/fwupd/tests/firmware.metainfo.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright 2016 Richard Hughes <richard@hughsie.com> -->
+<component type="firmware">
+  <id>com.test.chiron.firmware</id>
+  <name>Chiron</name>
+  <summary>Single line synopsis</summary>
+  <description>
+    <p>
+      This is the first paragraph in the example cab file.
+    </p>
+    <p>
+      This is the second paragraph.
+    </p>
+  </description>
+  <provides>
+    <firmware type="flashed">fd9f37b4-36fb-5245-86a8-4d5993bb153b</firmware>
+  </provides>
+  <url type="homepage">http://127.0.0.1/</url>
+  <metadata_license>CC0-1.0</metadata_license>
+  <project_license>GPL-2.0+</project_license>
+  <developer_name>ACME Corp</developer_name>
+  <releases>
+    <release urgency="medium" version="0.2" timestamp="1447353015">
+      <checksum target="content" filename="firmware.dfu"/>
+      <description>
+        <p>Latest firmware release.</p>
+      </description>
+    </release>
+  </releases>
+</component>