/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- * * Copyright (C) 2015-2017 Richard Hughes * * Licensed under the GNU General Public License Version 2 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include "fwupd-enums-private.h" #include "fwupd-release-private.h" #include "fwupd-resources.h" #include "fu-debug.h" #include "fu-device.h" #include "fu-hwids.h" #include "fu-plugin-private.h" #include "fu-keyring.h" #include "fu-pending.h" #include "fu-plugin.h" #include "fu-quirks.h" #ifndef HAVE_POLKIT_0_114 G_DEFINE_AUTOPTR_CLEANUP_FUNC(PolkitAuthorizationResult, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC(PolkitSubject, g_object_unref) #endif #define FU_MAIN_FIRMWARE_SIZE_MAX (32 * 1024 * 1024) /* bytes */ typedef struct { GDBusConnection *connection; GDBusNodeInfo *introspection_daemon; GDBusProxy *proxy_uid; GUsbContext *usb_ctx; GKeyFile *config; GMainLoop *loop; GPtrArray *devices; /* of FuDeviceItem */ PolkitAuthority *authority; FwupdStatus status; guint percentage; FuPending *pending; AsProfile *profile; AsStore *store; guint store_changed_id; guint owner_id; gboolean coldplug_running; guint coldplug_id; guint coldplug_delay; GPtrArray *plugins; /* of FuPlugin */ GHashTable *plugins_hash; /* of name : FuPlugin */ GHashTable *hwids; /* of hwid : 1 */ } FuMainPrivate; typedef struct { FuDevice *device; FuPlugin *plugin; } FuDeviceItem; static gboolean fu_main_get_updates_item_update (FuMainPrivate *priv, FuDeviceItem *item); static void fu_main_emit_changed (FuMainPrivate *priv) { /* not yet connected */ if (priv->connection == NULL) return; g_dbus_connection_emit_signal (priv->connection, NULL, FWUPD_DBUS_PATH, FWUPD_DBUS_INTERFACE, "Changed", NULL, NULL); } static void fu_main_emit_device_added (FuMainPrivate *priv, FuDevice *device) { GVariant *val; /* not yet connected */ if (priv->connection == NULL) return; val = fwupd_result_to_data (FWUPD_RESULT (device), "(a{sv})"); g_dbus_connection_emit_signal (priv->connection, NULL, FWUPD_DBUS_PATH, FWUPD_DBUS_INTERFACE, "DeviceAdded", val, NULL); } static void fu_main_emit_device_removed (FuMainPrivate *priv, FuDevice *device) { GVariant *val; /* not yet connected */ if (priv->connection == NULL) return; val = fwupd_result_to_data (FWUPD_RESULT (device), "(a{sv})"); g_dbus_connection_emit_signal (priv->connection, NULL, FWUPD_DBUS_PATH, FWUPD_DBUS_INTERFACE, "DeviceRemoved", val, NULL); } static void fu_main_emit_device_changed (FuMainPrivate *priv, FuDevice *device) { GVariant *val; /* not yet connected */ if (priv->connection == NULL) return; val = fwupd_result_to_data (FWUPD_RESULT (device), "(a{sv})"); g_dbus_connection_emit_signal (priv->connection, NULL, FWUPD_DBUS_PATH, FWUPD_DBUS_INTERFACE, "DeviceChanged", val, NULL); } static void fu_main_emit_property_changed (FuMainPrivate *priv, const gchar *property_name, GVariant *property_value) { GVariantBuilder builder; GVariantBuilder invalidated_builder; /* not yet connected */ if (priv->connection == NULL) return; /* build the dict */ g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as")); g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); g_variant_builder_add (&builder, "{sv}", property_name, property_value); g_dbus_connection_emit_signal (priv->connection, NULL, FWUPD_DBUS_PATH, "org.freedesktop.DBus.Properties", "PropertiesChanged", g_variant_new ("(sa{sv}as)", FWUPD_DBUS_INTERFACE, &builder, &invalidated_builder), NULL); g_variant_builder_clear (&builder); g_variant_builder_clear (&invalidated_builder); } static void fu_main_set_status (FuMainPrivate *priv, FwupdStatus status) { if (priv->status == status) return; priv->status = status; /* emit changed */ g_debug ("Emitting PropertyChanged('Status'='%s')", fwupd_status_to_string (status)); fu_main_emit_property_changed (priv, "Status", g_variant_new_uint32 (status)); } static void fu_main_set_percentage (FuMainPrivate *priv, guint percentage) { if (priv->percentage == percentage) return; priv->percentage = percentage; /* emit changed */ g_debug ("Emitting PropertyChanged('Percentage'='%u%%')", percentage); fu_main_emit_property_changed (priv, "Percentage", g_variant_new_uint32 (percentage)); } static GVariant * fu_main_device_array_to_variant (GPtrArray *devices, GError **error) { GVariantBuilder builder; /* no devices */ if (devices->len == 0) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO, "Nothing to do"); return NULL; } g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (guint i = 0; i < devices->len; i++) { GVariant *tmp; FuDeviceItem *item; item = g_ptr_array_index (devices, i); tmp = fwupd_result_to_data (FWUPD_RESULT (item->device), "{sa{sv}}"); g_variant_builder_add_value (&builder, tmp); } return g_variant_new ("(a{sa{sv}})", &builder); } static void fu_main_invocation_return_value (FuMainPrivate *priv, GDBusMethodInvocation *invocation, GVariant *parameters) { fu_main_set_status (priv, FWUPD_STATUS_IDLE); g_dbus_method_invocation_return_value (invocation, parameters); } static void fu_main_invocation_return_error (FuMainPrivate *priv, GDBusMethodInvocation *invocation, const GError *error) { fu_main_set_status (priv, FWUPD_STATUS_IDLE); g_dbus_method_invocation_return_gerror (invocation, error); } static void fu_main_item_free (FuDeviceItem *item) { g_object_unref (item->device); g_object_unref (item->plugin); g_free (item); } static FuDeviceItem * fu_main_get_item_by_id (FuMainPrivate *priv, const gchar *id) { for (guint i = 0; i < priv->devices->len; i++) { FuDeviceItem *item = g_ptr_array_index (priv->devices, i); if (g_strcmp0 (fu_device_get_id (item->device), id) == 0) return item; if (g_strcmp0 (fu_device_get_equivalent_id (item->device), id) == 0) return item; } return NULL; } static FuDeviceItem * fu_main_get_item_by_guid (FuMainPrivate *priv, const gchar *guid) { for (guint i = 0; i < priv->devices->len; i++) { FuDeviceItem *item = g_ptr_array_index (priv->devices, i); if (fu_device_has_guid (item->device, guid)) return item; } return NULL; } static FuPlugin * fu_main_get_plugin_by_name (FuMainPrivate *priv, const gchar *name) { for (guint i = 0; i < priv->plugins->len; i++) { FuPlugin *plugin = g_ptr_array_index (priv->plugins, i); if (g_strcmp0 (fu_plugin_get_name (plugin), name) == 0) return plugin; } return NULL; } static const gchar * fu_main_get_sysconfig_dir (void) { if (g_file_test (SYSCONFDIR, G_FILE_TEST_EXISTS)) return SYSCONFDIR; return "/etc"; } static void fu_main_set_release_from_item (FwupdRelease *rel, AsRelease *release) { AsChecksum *csum; const gchar *tmp; tmp = as_release_get_version (release); if (tmp != NULL) fwupd_release_set_version (rel, tmp); tmp = as_release_get_description (release, NULL); if (tmp != NULL) fwupd_release_set_description (rel, tmp); tmp = as_release_get_location_default (release); if (tmp != NULL) fwupd_release_set_uri (rel, tmp); csum = as_release_get_checksum_by_target (release, AS_CHECKSUM_TARGET_CONTENT); if (csum != NULL) { tmp = as_checksum_get_filename (csum); if (tmp != NULL) fwupd_release_set_filename (rel, tmp); } csum = as_release_get_checksum_by_target (release, AS_CHECKSUM_TARGET_CONTAINER); if (csum != NULL) { tmp = as_checksum_get_value (csum); if (tmp != NULL) fwupd_release_set_checksum (rel, tmp); } fwupd_release_set_size (rel, as_release_get_size (release, AS_SIZE_KIND_INSTALLED)); } static gboolean fu_main_get_release_trust_flags (AsRelease *release, FwupdTrustFlags *trust_flags, GError **error) { AsChecksum *csum_tmp; GBytes *blob_payload; GBytes *blob_signature; const gchar *fn; g_autofree gchar *pki_dir = NULL; g_autofree gchar *fn_signature = NULL; g_autoptr(GError) error_local = NULL; g_autoptr(FuKeyring) kr = NULL; /* no filename? */ csum_tmp = as_release_get_checksum_by_target (release, AS_CHECKSUM_TARGET_CONTENT); fn = as_checksum_get_filename (csum_tmp); if (fn == NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "no filename"); return FALSE; } /* no signature == no trust */ fn_signature = g_strdup_printf ("%s.asc", fn); blob_signature = as_release_get_blob (release, fn_signature); if (blob_signature == NULL) { g_debug ("firmware archive contained no GPG signature"); return TRUE; } /* get payload */ blob_payload = as_release_get_blob (release, fn); if (blob_payload == NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "no payload"); return FALSE; } /* check we were installed correctly */ pki_dir = g_build_filename (fu_main_get_sysconfig_dir (), "pki", "fwupd", NULL); if (!g_file_test (pki_dir, G_FILE_TEST_EXISTS)) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "PKI directory %s not found", pki_dir); return FALSE; } /* verify against the system trusted keys */ kr = fu_keyring_new (); if (!fu_keyring_add_public_keys (kr, pki_dir, error)) return FALSE; if (!fu_keyring_verify_data (kr, blob_payload, blob_signature, &error_local)) { g_warning ("untrusted as failed to verify: %s", error_local->message); return TRUE; } /* awesome! */ g_debug ("marking payload as trusted"); *trust_flags |= FWUPD_TRUST_FLAG_PAYLOAD; return TRUE; } typedef enum { FU_MAIN_AUTH_KIND_UNKNOWN, FU_MAIN_AUTH_KIND_INSTALL, FU_MAIN_AUTH_KIND_UNLOCK, FU_MAIN_AUTH_KIND_VERIFY_UPDATE, FU_MAIN_AUTH_KIND_LAST } FuMainAuthKind; typedef struct { GDBusMethodInvocation *invocation; AsStore *store; FwupdTrustFlags trust_flags; GPtrArray *devices; /* of FuDevice */ GPtrArray *blob_fws; /* of GBytes */ FwupdInstallFlags flags; GBytes *blob_cab; gboolean is_downgrade; FuMainAuthKind auth_kind; FuMainPrivate *priv; } FuMainAuthHelper; static void fu_main_helper_free (FuMainAuthHelper *helper) { /* free */ if (helper->devices != NULL) g_ptr_array_unref (helper->devices); if (helper->blob_fws != NULL) g_ptr_array_unref (helper->blob_fws); if (helper->blob_cab != NULL) g_bytes_unref (helper->blob_cab); if (helper->store != NULL) g_object_unref (helper->store); g_object_unref (helper->invocation); g_free (helper); } static gboolean fu_main_plugin_unlock_authenticated (FuMainAuthHelper *helper, GError **error) { /* check the devices still exists */ for (guint i = 0; i < helper->devices->len; i ++) { FuDeviceItem *item; FuDevice *device = g_ptr_array_index (helper->devices, i); item = fu_main_get_item_by_id (helper->priv, fu_device_get_id (device)); if (item == NULL) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "device %s was removed", fu_device_get_id (device)); return FALSE; } /* run the correct plugin that added this */ if (!fu_plugin_runner_unlock (item->plugin, item->device, error)) return FALSE; /* make the UI update */ fu_main_emit_device_changed (helper->priv, item->device); } /* make the UI update */ fu_main_emit_changed (helper->priv); return TRUE; } static AsApp * fu_main_verify_update_device_to_app (FuDevice *device) { AsApp *app = NULL; g_autofree gchar *id = NULL; g_autoptr(AsChecksum) csum = NULL; g_autoptr(AsProvide) prov = NULL; g_autoptr(AsRelease) rel = NULL; /* make a plausible ID */ id = g_strdup_printf ("%s.firmware", fu_device_get_guid_default (device)); /* add app to store */ app = as_app_new (); as_app_set_id (app, id); as_app_set_kind (app, AS_APP_KIND_FIRMWARE); rel = as_release_new (); as_release_set_version (rel, fu_device_get_version (device)); csum = as_checksum_new (); as_checksum_set_kind (csum, fu_device_get_checksum_kind (device)); as_checksum_set_value (csum, fu_device_get_checksum (device)); as_checksum_set_target (csum, AS_CHECKSUM_TARGET_CONTENT); as_release_add_checksum (rel, csum); as_app_add_release (app, rel); prov = as_provide_new (); as_provide_set_kind (prov, AS_PROVIDE_KIND_FIRMWARE_FLASHED); as_provide_set_value (prov, fu_device_get_guid_default (device)); as_app_add_provide (app, prov); return app; } static gboolean fu_main_plugin_verify_update_authenticated (FuMainAuthHelper *helper, GError **error) { const gchar *fn = "/var/cache/app-info/xmls/fwupd-verify.xml"; g_autoptr(AsStore) store = NULL; g_autoptr(GFile) xml_file = NULL; /* load existing store */ store = as_store_new (); as_store_set_api_version (store, 0.9); xml_file = g_file_new_for_path (fn); if (g_file_query_exists (xml_file, NULL)) { if (!as_store_from_file (store, xml_file, NULL, NULL, error)) return FALSE; } /* check the devices still exists */ for (guint i = 0; i < helper->devices->len; i ++) { FuDevice *device = g_ptr_array_index (helper->devices, i); FuDeviceItem *item; g_autoptr(AsApp) app = NULL; item = fu_main_get_item_by_id (helper->priv, fu_device_get_id (device)); if (item == NULL) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "device %s was removed", fu_device_get_id (device)); return FALSE; } /* unlock device if required */ if (fu_device_has_flag (item->device, FWUPD_DEVICE_FLAG_LOCKED)) { if (!fu_plugin_runner_unlock (item->plugin, item->device, error)) return FALSE; fu_main_emit_device_changed (helper->priv, item->device); } /* get the checksum */ if (fu_device_get_checksum (item->device) == NULL) { if (!fu_plugin_runner_verify (item->plugin, item->device, FU_PLUGIN_VERIFY_FLAG_NONE, error)) return FALSE; fu_main_emit_device_changed (helper->priv, item->device); } /* we got nothing */ if (fu_device_get_checksum (item->device) == NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED, "device verification not supported"); return FALSE; } /* add to store */ app = fu_main_verify_update_device_to_app (item->device); as_store_add_app (store, app); } /* write */ g_debug ("writing %s", fn); return as_store_to_file (store, xml_file, AS_NODE_TO_XML_FLAG_ADD_HEADER | AS_NODE_TO_XML_FLAG_FORMAT_INDENT | AS_NODE_TO_XML_FLAG_FORMAT_MULTILINE, NULL, error); } static gboolean fu_main_plugin_update_authenticated (FuMainAuthHelper *helper, GError **error) { FuMainPrivate *priv = helper->priv; FuDeviceItem *item; /* check the devices still exists */ for (guint i = 0; i < helper->devices->len; i ++) { FuDevice *device = g_ptr_array_index (helper->devices, i); item = fu_main_get_item_by_id (helper->priv, fu_device_get_id (device)); if (item == NULL) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "device %s was removed", fu_device_get_id (device)); return FALSE; } /* Called with online update, test if device is supposed to allow this */ if (!(helper->flags & FWUPD_INSTALL_FLAG_OFFLINE) && !fu_device_has_flag (item->device, FWUPD_DEVICE_FLAG_ALLOW_ONLINE)) { g_set_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED, "Device %s does not allow online updates", fu_device_get_id (device)); return FALSE; } /* Called with offline update, test if device is supposed to allow this */ if (helper->flags & FWUPD_INSTALL_FLAG_OFFLINE && !fu_device_has_flag (item->device, FWUPD_DEVICE_FLAG_ALLOW_OFFLINE)) { g_set_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED, "Device %s does not allow offline updates", fu_device_get_id (device)); return FALSE; } } /* run the correct plugin for each device */ for (guint i = 0; i < helper->devices->len; i ++) { FuDevice *device = g_ptr_array_index (helper->devices, i); GBytes *blob_fw = g_ptr_array_index (helper->blob_fws, i); item = fu_main_get_item_by_id (helper->priv, fu_device_get_id (device)); /* signal to all the plugins the update is about to happen */ for (guint j = 0; j < priv->plugins->len; j++) { FuPlugin *plugin = g_ptr_array_index (priv->plugins, j); if (!fu_plugin_runner_update_prepare (plugin, device, error)) return FALSE; } /* do the update */ if (!fu_plugin_runner_update (item->plugin, item->device, helper->blob_cab, blob_fw, helper->flags, error)) { for (guint j = 0; j < priv->plugins->len; j++) { FuPlugin *plugin = g_ptr_array_index (priv->plugins, j); g_autoptr(GError) error_local = NULL; if (!fu_plugin_runner_update_cleanup (plugin, device, &error_local)) { g_warning ("failed to update-cleanup " "after failed update: %s", error_local->message); } } return FALSE; } /* signal to all the plugins the update has happened */ for (guint j = 0; j < priv->plugins->len; j++) { FuPlugin *plugin = g_ptr_array_index (priv->plugins, j); g_autoptr(GError) error_local = NULL; if (!fu_plugin_runner_update_cleanup (plugin, device, &error_local)) { g_warning ("failed to update-cleanup: %s", error_local->message); } } /* make the UI update */ fu_device_set_modified (item->device, (guint64) g_get_real_time () / G_USEC_PER_SEC); fu_main_emit_device_changed (helper->priv, item->device); } /* make the UI update */ fu_main_emit_changed (helper->priv); return TRUE; } static void fu_main_check_authorization_cb (GObject *source, GAsyncResult *res, gpointer user_data) { FuMainAuthHelper *helper = (FuMainAuthHelper *) user_data; g_autoptr(GError) error = NULL; g_autoptr(GError) error_local = NULL; g_autoptr(PolkitAuthorizationResult) auth = NULL; /* get result */ auth = polkit_authority_check_authorization_finish (POLKIT_AUTHORITY (source), res, &error_local); if (auth == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_AUTH_FAILED, "could not check for auth: %s", error_local->message); fu_main_invocation_return_error (helper->priv, helper->invocation, error); fu_main_helper_free (helper); return; } /* did not auth */ if (!polkit_authorization_result_get_is_authorized (auth)) { g_set_error_literal (&error, FWUPD_ERROR, FWUPD_ERROR_AUTH_FAILED, "failed to obtain auth"); fu_main_invocation_return_error (helper->priv, helper->invocation, error); fu_main_helper_free (helper); return; } /* we're good to go */ if (helper->auth_kind == FU_MAIN_AUTH_KIND_INSTALL) { if (!fu_main_plugin_update_authenticated (helper, &error)) { fu_main_invocation_return_error (helper->priv, helper->invocation, error); fu_main_helper_free (helper); return; } } else if (helper->auth_kind == FU_MAIN_AUTH_KIND_UNLOCK) { if (!fu_main_plugin_unlock_authenticated (helper, &error)) { fu_main_invocation_return_error (helper->priv, helper->invocation, error); fu_main_helper_free (helper); return; } } else if (helper->auth_kind == FU_MAIN_AUTH_KIND_VERIFY_UPDATE) { if (!fu_main_plugin_verify_update_authenticated (helper, &error)) { fu_main_invocation_return_error (helper->priv, helper->invocation, error); fu_main_helper_free (helper); return; } } else { g_assert_not_reached (); } /* success */ fu_main_invocation_return_value (helper->priv, helper->invocation, NULL); fu_main_helper_free (helper); } static gchar * fu_main_get_guids_from_store (AsStore *store) { AsProvide *prov; GPtrArray *provides; GPtrArray *apps; GString *str = g_string_new (""); /* return a string with all the firmware apps in the store */ apps = as_store_get_apps (store); for (guint i = 0; i < apps->len; i++) { AsApp *app = AS_APP (g_ptr_array_index (apps, i)); provides = as_app_get_provides (app); for (guint j = 0; j < provides->len; j++) { prov = AS_PROVIDE (g_ptr_array_index (provides, j)); if (as_provide_get_kind (prov) != AS_PROVIDE_KIND_FIRMWARE_FLASHED) continue; g_string_append_printf (str, "%s,", as_provide_get_value (prov)); } } if (str->len == 0) return NULL; g_string_truncate (str, str->len - 1); return g_string_free (str, FALSE); } static void fu_main_vendor_quirk_release_version (AsApp *app) { AsVersionParseFlag flags = AS_VERSION_PARSE_FLAG_USE_TRIPLET; GPtrArray *releases; /* no quirk required */ if (as_app_get_kind (app) != AS_APP_KIND_FIRMWARE) return; for (guint i = 0; quirk_table[i].identifier != NULL; i++) { if (g_str_has_prefix (as_app_get_id(app), quirk_table[i].identifier)) flags = quirk_table[i].flags; } /* fix each release */ releases = as_app_get_releases (app); for (guint i = 0; i < releases->len; i++) { AsRelease *rel; const gchar *version; guint64 ver_uint32; g_autofree gchar *version_new = NULL; rel = g_ptr_array_index (releases, i); version = as_release_get_version (rel); if (version == NULL) continue; if (g_strstr_len (version, -1, ".") != NULL) continue; /* metainfo files use hex and the LVFS uses decimal */ if (g_str_has_prefix (version, "0x")) { ver_uint32 = g_ascii_strtoull (version + 2, NULL, 16); } else { ver_uint32 = g_ascii_strtoull (version, NULL, 10); } if (ver_uint32 == 0) continue; /* convert to dotted decimal */ version_new = as_utils_version_from_uint32 ((guint32) ver_uint32, flags); as_release_set_version (rel, version_new); } } #if AS_CHECK_VERSION(0,6,7) static gboolean fu_main_check_version_requirement (AsApp *app, AsRequireKind kind, const gchar *id, const gchar *version, GError **error) { AsRequire *req; /* check args */ if (version == NULL) { g_debug ("no paramater given for %s{%s}", as_require_kind_to_string (kind), id); return TRUE; } /* does requirement exist */ req = as_app_get_require_by_value (app, kind, id); if (req == NULL) { g_debug ("no requirement on %s{%s}", as_require_kind_to_string (kind), id); return TRUE; } /* check version */ if (!as_require_version_compare (req, version, error)) { g_prefix_error (error, "version of %s incorrect: ", id); return FALSE; } /* success */ g_debug ("requirement %s %s %s on %s passed", as_require_get_version (req), as_require_compare_to_string (as_require_get_compare (req)), version, id); return TRUE; } #endif static AsApp * fu_main_store_get_app_by_guids (AsStore *store, FuDevice *device) { GPtrArray *guids = fu_device_get_guids (device); for (guint i = 0; i < guids->len; i++) { AsApp *app = NULL; app = as_store_get_app_by_provide (store, AS_PROVIDE_KIND_FIRMWARE_FLASHED, g_ptr_array_index (guids, i)); if (app != NULL) return app; } return NULL; } static gboolean fu_main_check_app_versions (AsApp *app, FuDevice *device, GError **error) { #if AS_CHECK_VERSION(0,6,7) /* make sure requirements are satisfied */ if (!fu_main_check_version_requirement (app, AS_REQUIRE_KIND_ID, "org.freedesktop.fwupd", VERSION, error)) { return FALSE; } if (device != NULL) { if (!fu_main_check_version_requirement (app, AS_REQUIRE_KIND_FIRMWARE, NULL, fu_device_get_version (device), error)) { return FALSE; } if (!fu_main_check_version_requirement (app, AS_REQUIRE_KIND_FIRMWARE, "bootloader", fu_device_get_version_bootloader (device), error)) { return FALSE; } } #endif /* success */ return TRUE; } static AsScreenshot * _as_app_get_screenshot_default (AsApp *app) { GPtrArray *array = as_app_get_screenshots (app); if (array->len == 0) return NULL; return g_ptr_array_index (array, 0); } static gboolean fu_main_update_helper_for_device (FuMainAuthHelper *helper, FuDevice *device, GError **error) { AsApp *app; AsChecksum *csum_tmp; AsRelease *rel; GBytes *blob_fw; const gchar *tmp; const gchar *version; gboolean is_downgrade; gint vercmp; /* find from guid */ app = fu_main_store_get_app_by_guids (helper->store, device); if (app == NULL) { g_autofree gchar *guid = NULL; guid = fu_main_get_guids_from_store (helper->store); g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "firmware is not for this hw: required %s got %s", fu_device_get_guid_default (device), guid); return FALSE; } /* check we can install it */ if (!fu_main_check_app_versions (app, device, error)) return FALSE; /* parse the DriverVer */ rel = as_app_get_release_default (app); if (rel == NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "no releases in the firmware component"); return FALSE; } /* no update abilities */ if (!fu_device_has_flag (device, FWUPD_DEVICE_FLAG_ALLOW_OFFLINE) && !fu_device_has_flag (device, FWUPD_DEVICE_FLAG_ALLOW_ONLINE)) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "Device %s does not currently allow updates", fu_device_get_id (device)); return FALSE; } /* not in bootloader mode */ if (fu_device_has_flag (device, FWUPD_DEVICE_FLAG_NEEDS_BOOTLOADER)) { const gchar *caption = NULL; AsScreenshot *ss = _as_app_get_screenshot_default (app); if (ss != NULL) caption = as_screenshot_get_caption (ss, NULL); if (caption != NULL) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "Device %s needs to manually be put in update mode: %s", fu_device_get_name (device), caption); } else { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "Device %s needs to manually be put in update mode", fu_device_get_name (device)); } return FALSE; } /* get the blob */ csum_tmp = as_release_get_checksum_by_target (rel, AS_CHECKSUM_TARGET_CONTENT); tmp = as_checksum_get_filename (csum_tmp); if (tmp == NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "no checksum filename"); return FALSE; } /* not all devices have to use the same blob */ blob_fw = as_release_get_blob (rel, tmp); if (blob_fw == NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_READ, "failed to get firmware blob"); return FALSE; } /* possibly convert the version from 0x to dotted */ fu_main_vendor_quirk_release_version (app); version = as_release_get_version (rel); fu_device_set_update_version (device, version); /* compare to the lowest supported version, if it exists */ tmp = fu_device_get_version_lowest (device); if (tmp != NULL && as_utils_vercmp (tmp, version) > 0) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_VERSION_NEWER, "Specified firmware is older than the minimum " "required version '%s < %s'", tmp, version); return FALSE; } /* check the device is locked */ if (fu_device_has_flag (device, FWUPD_DEVICE_FLAG_LOCKED)) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "Device %s is locked", fu_device_get_id (device)); return FALSE; } /* compare the versions of what we have installed */ tmp = fu_device_get_version (device); if (tmp == NULL) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "Device %s does not yet have a current version", fu_device_get_id (device)); return FALSE; } vercmp = as_utils_vercmp (tmp, version); if (vercmp == 0 && (helper->flags & FWUPD_INSTALL_FLAG_ALLOW_REINSTALL) == 0) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_VERSION_SAME, "Specified firmware is already installed '%s'", tmp); return FALSE; } is_downgrade = vercmp > 0; if (is_downgrade && (helper->flags & FWUPD_INSTALL_FLAG_ALLOW_OLDER) == 0) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_VERSION_NEWER, "Specified firmware is older than installed '%s < %s'", tmp, version); return FALSE; } /* if any downgrade, we want the global to be true */ if (is_downgrade) helper->is_downgrade = is_downgrade; /* verify */ if (!fu_main_get_release_trust_flags (rel, &helper->trust_flags, error)) return FALSE; /* success */ g_ptr_array_add (helper->blob_fws, g_bytes_ref (blob_fw)); return TRUE; } static gboolean fu_main_update_helper (FuMainAuthHelper *helper, GError **error) { g_autoptr(GError) error_first = NULL; /* load store file which also decompresses firmware */ fu_main_set_status (helper->priv, FWUPD_STATUS_DECOMPRESSING); if (!as_store_from_bytes (helper->store, helper->blob_cab, NULL, error)) return FALSE; /* we've specified a specific device; failure is critical */ if (helper->devices->len > 0) { for (guint i = 0; i < helper->devices->len; i ++) { FuDevice *device = g_ptr_array_index (helper->devices, i); if (!fu_main_update_helper_for_device (helper, device, error)) return FALSE; } return TRUE; } /* if we've not chosen a device, try and find anything in the * cabinet 'store' that matches any installed device and is updatable */ for (guint i = 0; i < helper->priv->devices->len; i++) { AsApp *app; FuDeviceItem *item; g_autoptr(GError) error_local = NULL; /* guid found */ item = g_ptr_array_index (helper->priv->devices, i); app = fu_main_store_get_app_by_guids (helper->store, item->device); if (app == NULL) continue; /* check we can install it */ if (!fu_main_check_app_versions (app, item->device, &error_local)) { if (error_first == NULL) error_first = g_error_copy (error_local); continue; } /* try this device, error not fatal */ if (!fu_main_update_helper_for_device (helper, item->device, &error_local)) { g_debug ("failed to add %s: %s", fu_device_get_id (item->device), error_local->message); /* save this for later */ if (error_first == NULL) error_first = g_error_copy (error_local); continue; } /* success */ g_ptr_array_add (helper->devices, g_object_ref (item->device)); } if (helper->devices->len == 0) { if (error_first != NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, error_first->message); } else { g_autofree gchar *guid = NULL; guid = fu_main_get_guids_from_store (helper->store); g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "no attached hardware matched %s", guid); } return FALSE; } /* sanity check */ if (helper->devices->len != helper->blob_fws->len) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "not enough firmware blobs (%u) for devices (%u)", helper->blob_fws->len, helper->devices->len); return FALSE; } return TRUE; } static guint fu_main_dbus_get_uid (FuMainPrivate *priv, const gchar *sender) { guint uid; g_autoptr(GError) error = NULL; g_autoptr(GVariant) value = NULL; if (priv->proxy_uid == NULL) return G_MAXUINT; value = g_dbus_proxy_call_sync (priv->proxy_uid, "GetConnectionUnixUser", g_variant_new ("(s)", sender), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (value == NULL) { g_warning ("Failed to get uid for %s: %s", sender, error->message); return G_MAXUINT; } g_variant_get (value, "(u)", &uid); return uid; } static FuDeviceItem * fu_main_get_item_by_id_fallback_pending (FuMainPrivate *priv, const gchar *id, GError **error) { FuDevice *dev; FuPlugin *plugin; FuDeviceItem *item = NULL; FwupdUpdateState update_state; const gchar *tmp; g_autoptr(GPtrArray) devices = NULL; /* not a wildcard */ if (g_strcmp0 (id, FWUPD_DEVICE_ID_ANY) != 0) { item = fu_main_get_item_by_id (priv, id); if (item == NULL) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "no suitable device found for %s", id); } return item; } /* allow '*' for any */ devices = fu_pending_get_devices (priv->pending, error); if (devices == NULL) return NULL; for (guint i = 0; i < devices->len; i++) { dev = g_ptr_array_index (devices, i); update_state = fu_device_get_update_state (dev); if (update_state == FWUPD_UPDATE_STATE_UNKNOWN) continue; if (update_state == FWUPD_UPDATE_STATE_PENDING) continue; /* if the device is not still connected, fake a FuDeviceItem */ item = fu_main_get_item_by_id (priv, fu_device_get_id (dev)); if (item == NULL) { tmp = fu_device_get_plugin (dev); plugin = fu_main_get_plugin_by_name (priv, tmp); if (plugin == NULL) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "no plugin %s found", tmp); return NULL; } item = g_new0 (FuDeviceItem, 1); item->device = g_object_ref (dev); item->plugin = g_object_ref (plugin); g_ptr_array_add (priv->devices, item); /* FIXME: just a boolean on FuDeviceItem? */ fu_device_set_metadata (dev, "FakeDevice", "TRUE"); } break; } /* no device found */ if (item == NULL) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "no suitable devices found"); } return item; } static const gchar * fu_main_get_action_id_for_device (FuMainAuthHelper *helper) { gboolean all_removable = TRUE; gboolean is_trusted; /* only test the payload */ is_trusted = (helper->trust_flags & FWUPD_TRUST_FLAG_PAYLOAD) > 0; /* any non-removable means false */ for (guint i = 0; i < helper->devices->len; i ++) { FuDevice *device = g_ptr_array_index (helper->devices, i); if (fu_device_has_flag (device, FWUPD_DEVICE_FLAG_INTERNAL)) { all_removable = FALSE; break; } } /* relax authentication checks for removable devices */ if (all_removable) { if (helper->is_downgrade) return "org.freedesktop.fwupd.downgrade-hotplug"; if (is_trusted) return "org.freedesktop.fwupd.update-hotplug-trusted"; return "org.freedesktop.fwupd.update-hotplug"; } /* internal device */ if (helper->is_downgrade) return "org.freedesktop.fwupd.downgrade-internal"; if (is_trusted) return "org.freedesktop.fwupd.update-internal-trusted"; return "org.freedesktop.fwupd.update-internal"; } static gboolean fu_main_daemon_update_metadata (FuMainPrivate *priv, const gchar *remote_id, gint fd, gint fd_sig, GError **error) { const guint8 *data; gsize size; GPtrArray *apps; g_autofree gchar *xml = NULL; g_autoptr(AsStore) store = NULL; g_autoptr(GBytes) bytes = NULL; g_autoptr(GBytes) bytes_raw = NULL; g_autoptr(GBytes) bytes_sig = NULL; g_autoptr(FuKeyring) kr = NULL; g_autoptr(GConverter) converter = NULL; g_autoptr(GFile) file = NULL; g_autoptr(GFile) file_parent = NULL; g_autoptr(GInputStream) stream_buf = NULL; g_autoptr(GInputStream) stream_fd = NULL; g_autoptr(GInputStream) stream = NULL; g_autoptr(GInputStream) stream_sig = NULL; /* read the entire file into memory */ stream_fd = g_unix_input_stream_new (fd, TRUE); bytes_raw = g_input_stream_read_bytes (stream_fd, 0x100000, NULL, error); if (bytes_raw == NULL) return FALSE; stream_buf = g_memory_input_stream_new (); g_memory_input_stream_add_bytes (G_MEMORY_INPUT_STREAM (stream_buf), bytes_raw); /* peek the file type and get data */ data = g_bytes_get_data (bytes_raw, &size); if (size < 2) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "file is too small"); return FALSE; } if (data[0] == 0x1f && data[1] == 0x8b) { g_debug ("using GZip decompressor for data"); converter = G_CONVERTER (g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP)); stream = g_converter_input_stream_new (stream_buf, converter); bytes = g_input_stream_read_bytes (stream, 0x100000, NULL, error); if (bytes == NULL) return FALSE; } else if (data[0] == '<' && data[1] == '?') { g_debug ("using no decompressor for data"); bytes = g_bytes_ref (bytes_raw); } else { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "file type '0x%02x,0x%02x' not supported", data[0], data[1]); return FALSE; } /* read signature */ stream_sig = g_unix_input_stream_new (fd_sig, TRUE); bytes_sig = g_input_stream_read_bytes (stream_sig, 0x800, NULL, error); if (bytes_sig == NULL) return FALSE; /* verify file */ kr = fu_keyring_new (); if (!fu_keyring_add_public_keys (kr, "/etc/pki/fwupd-metadata", error)) return FALSE; if (!fu_keyring_verify_data (kr, bytes_raw, bytes_sig, error)) return FALSE; /* load the store locally until we know it is valid */ store = as_store_new (); data = g_bytes_get_data (bytes, &size); xml = g_strndup ((const gchar *) data, size); if (!as_store_from_xml (store, xml, NULL, error)) return FALSE; /* add the new application from the store */ as_store_remove_all (priv->store); apps = as_store_get_apps (store); for (guint i = 0; i < apps->len; i++) { AsApp *app = g_ptr_array_index (apps, i); if (remote_id != NULL && remote_id[0] != '\0') as_app_add_metadata (app, "fwupd::RemoteID", remote_id); as_store_add_app (priv->store, app); } /* ensure directory exists */ file = g_file_new_for_path ("/var/cache/app-info/xmls/fwupd.xml"); file_parent = g_file_get_parent (file); if (!g_file_query_exists (file_parent, NULL)) { if (!g_file_make_directory_with_parents (file_parent, NULL, error)) return FALSE; } /* save the new file */ as_store_set_api_version (priv->store, 0.9); as_store_set_origin (priv->store, NULL); if (!as_store_to_file (priv->store, file, AS_NODE_TO_XML_FLAG_ADD_HEADER | AS_NODE_TO_XML_FLAG_FORMAT_MULTILINE | AS_NODE_TO_XML_FLAG_FORMAT_INDENT, NULL, error)) { return FALSE; } return TRUE; } static gboolean fu_main_store_delay_cb (gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; GPtrArray *apps; /* print what we've got */ apps = as_store_get_apps (priv->store); if (apps->len == 0) { g_debug ("no devices in store"); } else { g_debug ("devices now in store:"); for (guint i = 0; i < apps->len; i++) { AsApp *app = g_ptr_array_index (apps, i); g_debug ("%u\t%s\t%s", i + 1, as_app_get_id (app), as_app_get_name (app, NULL)); } } /* are any devices now supported? */ for (guint i = 0; i < priv->devices->len; i++) { FuDeviceItem *item = g_ptr_array_index (priv->devices, i); if (fu_main_get_updates_item_update (priv, item)) fu_main_emit_device_changed (priv, item->device); } priv->store_changed_id = 0; return G_SOURCE_REMOVE; } static void fu_main_store_changed_cb (AsStore *store, FuMainPrivate *priv) { if (priv->store_changed_id != 0) return; priv->store_changed_id = g_timeout_add (200, fu_main_store_delay_cb, priv); } static gboolean fu_main_get_updates_item_update (FuMainPrivate *priv, FuDeviceItem *item) { AsApp *app; AsRelease *release; GPtrArray *releases; const gchar *tmp; const gchar *version; g_autoptr(GError) error = NULL; g_autoptr(GPtrArray) updates_list = NULL; /* get device version */ version = fu_device_get_version (item->device); if (version == NULL) return FALSE; /* match the GUIDs in the XML */ app = fu_main_store_get_app_by_guids (priv->store, item->device); if (app == NULL) return FALSE; /* possibly convert the version from 0x to dotted */ fu_main_vendor_quirk_release_version (app); /* get latest release */ release = as_app_get_release_default (app); if (release == NULL) { g_debug ("%s [%s] has no firmware update metadata", fu_device_get_id (item->device), fu_device_get_name (item->device)); return FALSE; } /* supported in metadata */ fwupd_device_add_flag (fwupd_result_get_device (FWUPD_RESULT (item->device)), FWUPD_DEVICE_FLAG_SUPPORTED); /* check if actually newer than what we have installed */ if (as_utils_vercmp (as_release_get_version (release), version) <= 0) { g_debug ("%s has no firmware updates", fu_device_get_id (item->device)); return FALSE; } /* check we can install it */ if (!fu_main_check_app_versions (app, item->device, &error)) { g_debug ("can not be installed: %s", error->message); return FALSE; } /* only show devices that can be updated */ if (!fu_device_has_flag (item->device, FWUPD_DEVICE_FLAG_ALLOW_OFFLINE) && !fu_device_has_flag (item->device, FWUPD_DEVICE_FLAG_ALLOW_ONLINE)) { g_debug ("ignoring %s [%s] as not updatable live or offline", fu_device_get_id (item->device), fu_device_get_name (item->device)); return FALSE; } /* add application metadata */ fu_device_set_update_id (item->device, as_app_get_id (app)); tmp = as_app_get_developer_name (app, NULL); if (tmp != NULL) fu_device_set_update_vendor (item->device, tmp); tmp = as_app_get_name (app, NULL); if (tmp != NULL) fu_device_set_update_name (item->device, tmp); tmp = as_app_get_comment (app, NULL); if (tmp != NULL) fu_device_set_update_summary (item->device, tmp); tmp = as_app_get_description (app, NULL); if (tmp != NULL) fu_device_set_description (item->device, tmp); tmp = as_app_get_url_item (app, AS_URL_KIND_HOMEPAGE); if (tmp != NULL) fu_device_set_update_homepage (item->device, tmp); tmp = as_app_get_project_license (app); if (tmp != NULL) fu_device_set_update_license (item->device, tmp); tmp = as_app_get_metadata_item (app, "fwupd::RemoteID"); if (tmp != NULL) fu_device_set_update_remote_id (item->device, tmp); #if AS_CHECK_VERSION(0,6,1) tmp = as_app_get_unique_id (app); if (tmp != NULL) fu_device_set_unique_id (item->device, tmp); #else fu_device_set_unique_id (item->device, as_app_get_id (app)); #endif /* add release information */ fu_main_set_release_from_item (fwupd_result_get_release (FWUPD_RESULT (item->device)), release); /* get the list of releases newer than the one installed */ updates_list = g_ptr_array_new (); releases = as_app_get_releases (app); for (guint i = 0; i < releases->len; i++) { release = g_ptr_array_index (releases, i); if (as_utils_vercmp (as_release_get_version (release), version) <= 0) continue; tmp = as_release_get_description (release, NULL); if (tmp == NULL) continue; g_ptr_array_add (updates_list, release); } /* no prefix on each release */ if (updates_list->len == 1) { release = g_ptr_array_index (updates_list, 0); fu_device_set_update_description (item->device, as_release_get_description (release, NULL)); } else { g_autoptr(GString) update_desc = NULL; update_desc = g_string_new (""); /* get the descriptions with a version prefix */ for (guint i = 0; i < updates_list->len; i++) { release = g_ptr_array_index (updates_list, i); g_string_append_printf (update_desc, "

%s:

%s", as_release_get_version (release), as_release_get_description (release, NULL)); } if (update_desc->len > 0) fu_device_set_update_description (item->device, update_desc->str); } /* success */ return TRUE; } /* find any updates using the AppStream metadata */ static GPtrArray * fu_main_get_updates (FuMainPrivate *priv, GError **error) { GPtrArray *updates = g_ptr_array_new (); for (guint i = 0; i < priv->devices->len; i++) { FuDeviceItem *item = g_ptr_array_index (priv->devices, i); if (fu_main_get_updates_item_update (priv, item)) g_ptr_array_add (updates, item); } return updates; } /* find releases for a device */ static GVariant * fu_main_get_releases_to_variant (FuMainPrivate *priv, FuDeviceItem *item, GError **error) { GPtrArray *device_guids; GVariantBuilder builder; g_autoptr(GPtrArray) results = NULL; /* get all the results for the device */ results = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); device_guids = fu_device_get_guids (item->device); for (guint i = 0; i < device_guids->len; i++) { GPtrArray *releases; const gchar *guid = g_ptr_array_index (device_guids, i); AsApp *app = as_store_get_app_by_provide (priv->store, AS_PROVIDE_KIND_FIRMWARE_FLASHED, guid); if (app == NULL) continue; releases = as_app_get_releases (app); for (guint j = 0; j < releases->len; j++) { AsRelease *release = g_ptr_array_index (releases, j); FwupdRelease *rel = fwupd_release_new (); fu_main_set_release_from_item (rel, release); g_ptr_array_add (results, rel); } } /* no devices */ if (results->len == 0) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO, "No releases for device"); return NULL; } /* convert the objects to a variant */ g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (guint i = 0; i < results->len; i++) { GVariant *tmp; FwupdRelease *rel = g_ptr_array_index (results, i); tmp = fwupd_release_to_data (rel, "a{sv}"); //FIXME? g_variant_builder_add_value (&builder, tmp); } return g_variant_new ("(aa{sv})", &builder); } static AsStore * fu_main_get_store_from_fd (FuMainPrivate *priv, gint fd, GError **error) { g_autofree gchar *checksum = NULL; g_autoptr(AsStore) store = NULL; g_autoptr(GBytes) blob_cab = NULL; g_autoptr(GError) error_local = NULL; g_autoptr(GInputStream) stream = NULL; /* read the entire fd to a data blob */ stream = g_unix_input_stream_new (fd, TRUE); blob_cab = g_input_stream_read_bytes (stream, FU_MAIN_FIRMWARE_SIZE_MAX, NULL, &error_local); if (blob_cab == NULL){ g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, error_local->message); return NULL; } /* load file */ store = as_store_new (); if (!as_store_from_bytes (store, blob_cab, NULL, &error_local)) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, error_local->message); return NULL; } /* get a checksum of the file and use it as the origin */ checksum = g_compute_checksum_for_data (G_CHECKSUM_SHA256, g_bytes_get_data (blob_cab, NULL), g_bytes_get_size (blob_cab)); as_store_set_origin (store, checksum); return g_steal_pointer (&store); } static FwupdResult * fu_main_get_result_from_app (FuMainPrivate *priv, AsApp *app, GError **error) { FwupdTrustFlags trust_flags = FWUPD_TRUST_FLAG_NONE; AsRelease *release; FwupdDevice *dev; FwupdRelease *rel; GPtrArray *provides; g_autoptr(FwupdResult) res = NULL; res = fwupd_result_new (); dev = fwupd_result_get_device (res); provides = as_app_get_provides (app); for (guint i = 0; i < provides->len; i++) { AsProvide *prov = AS_PROVIDE (g_ptr_array_index (provides, i)); FuDeviceItem *item; const gchar *guid; /* not firmware */ if (as_provide_get_kind (prov) != AS_PROVIDE_KIND_FIRMWARE_FLASHED) continue; /* is a online or offline update appropriate */ guid = as_provide_get_value (prov); if (guid == NULL) continue; item = fu_main_get_item_by_guid (priv, guid); if (item != NULL) { fwupd_device_set_flags (dev, fu_device_get_flags (item->device)); fwupd_device_set_id (dev, fu_device_get_id (item->device)); } /* add GUID */ fwupd_device_add_guid (dev, guid); } if (fwupd_device_get_guids(dev)->len == 0) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "component has no GUIDs"); return NULL; } /* check we can install it */ if (!fu_main_check_app_versions (app, NULL, error)) return NULL; /* verify trust */ release = as_app_get_release_default (app); if (!fu_main_get_release_trust_flags (release, &trust_flags, error)) return NULL; fwupd_result_set_update_trust_flags (res, trust_flags); /* possibly convert the version from 0x to dotted */ fu_main_vendor_quirk_release_version (app); /* create a result with all the metadata in */ fwupd_device_set_description (dev, as_app_get_description (app, NULL)); rel = fwupd_result_get_release (res); fwupd_release_set_homepage (rel, as_app_get_url_item (app, AS_URL_KIND_HOMEPAGE)); fwupd_release_set_license (rel, as_app_get_project_license (app)); fwupd_release_set_name (rel, as_app_get_name (app, NULL)); fwupd_release_set_summary (rel, as_app_get_comment (app, NULL)); fwupd_release_set_vendor (rel, as_app_get_developer_name (app, NULL)); #if AS_CHECK_VERSION(0,6,1) fwupd_result_set_unique_id (res, as_app_get_unique_id (app)); #else fwupd_result_set_unique_id (res, as_app_get_id (app)); #endif fwupd_release_set_appstream_id (rel, as_app_get_id (app)); fu_main_set_release_from_item (rel, release); return g_steal_pointer (&res); } static GVariant * fu_main_get_details_from_fd (FuMainPrivate *priv, gint fd, GError **error) { AsApp *app = NULL; GPtrArray *apps; g_autoptr(AsStore) store = NULL; g_autoptr(FwupdResult) res = NULL; store = fu_main_get_store_from_fd (priv, fd, error); if (store == NULL) return NULL; /* get all apps */ apps = as_store_get_apps (store); if (apps->len == 0) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "no components"); return NULL; } if (apps->len > 1) { /* we've got a .cab file with multiple components, * so try to find the first thing that's installed */ for (guint i = 0; i < priv->devices->len; i++) { FuDeviceItem *item = g_ptr_array_index (priv->devices, i); app = fu_main_store_get_app_by_guids (store, item->device); if (app != NULL) break; } } /* well, we've tried our best, just show the first entry */ if (app == NULL) app = AS_APP (g_ptr_array_index (apps, 0)); /* check we can install it */ if (!fu_main_check_app_versions (app, NULL, error)) return FALSE; /* create a result with all the metadata in */ as_app_set_origin (app, as_store_get_origin (store)); res = fu_main_get_result_from_app (priv, app, error); if (res == NULL) return NULL; return fwupd_result_to_data (res, "(a{sv})"); } static GVariant * fu_main_get_details_local_from_fd (FuMainPrivate *priv, gint fd, GError **error) { GPtrArray *apps; GVariantBuilder builder; g_autoptr(AsStore) store = NULL; store = fu_main_get_store_from_fd (priv, fd, error); if (store == NULL) return NULL; /* get all apps */ apps = as_store_get_apps (store); if (apps->len == 0) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "no components"); return NULL; } /* create results with all the metadata in */ g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (guint i = 0; i < apps->len; i++) { g_autoptr(FwupdResult) res = NULL; AsApp *app = g_ptr_array_index (apps, i); GVariant *tmp; /* check we can install it */ if (!fu_main_check_app_versions (app, NULL, error)) return NULL; as_app_set_origin (app, as_store_get_origin (store)); res = fu_main_get_result_from_app (priv, app, error); if (res == NULL) return NULL; tmp = fwupd_result_to_data (res, "{sa{sv}}"); g_variant_builder_add_value (&builder, tmp); } return g_variant_new ("(a{sa{sv}})", &builder); } static void fu_main_daemon_method_call (GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; GVariant *val; g_autoptr(GError) error = NULL; /* return 'as' */ if (g_strcmp0 (method_name, "GetDevices") == 0) { g_debug ("Called %s()", method_name); val = fu_main_device_array_to_variant (priv->devices, &error); if (val == NULL) { if (g_error_matches (error, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO)) { g_prefix_error (&error, "No detected devices: "); } fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, val); return; } /* return 'as' */ if (g_strcmp0 (method_name, "GetUpdates") == 0) { g_autoptr(GPtrArray) updates = NULL; g_debug ("Called %s()", method_name); updates = fu_main_get_updates (priv, &error); if (updates == NULL) { fu_main_invocation_return_error (priv, invocation, error); return; } val = fu_main_device_array_to_variant (updates, &error); if (val == NULL) { if (g_error_matches (error, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO)) { g_prefix_error (&error, "No devices can be updated: "); } fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, val); return; } /* return variant */ if (g_strcmp0 (method_name, "GetReleases") == 0) { FuDeviceItem *item; const gchar *device_id = NULL; g_autoptr(GPtrArray) releases = NULL; g_variant_get (parameters, "(&s)", &device_id); g_debug ("Called %s(%s)", method_name, device_id); /* find the device */ item = fu_main_get_item_by_id (priv, device_id); if (item == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "no device with ID %s", device_id); fu_main_invocation_return_error (priv, invocation, error); return; } val = fu_main_get_releases_to_variant (priv, item, &error); if (val == NULL) { if (g_error_matches (error, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO)) { g_prefix_error (&error, "No releases found: "); } fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, val); return; } /* return '' */ if (g_strcmp0 (method_name, "ClearResults") == 0) { FuDeviceItem *item = NULL; const gchar *id = NULL; g_variant_get (parameters, "(&s)", &id); g_debug ("Called %s(%s)", method_name, id); /* find device */ item = fu_main_get_item_by_id_fallback_pending (priv, id, &error); if (item == NULL) { fu_main_invocation_return_error (priv, invocation, error); return; } /* call into the plugin */ if (!fu_plugin_runner_clear_results (item->plugin, item->device, &error)) { fu_main_invocation_return_error (priv, invocation, error); return; } /* success */ fu_main_invocation_return_value (priv, invocation, NULL); return; } /* return 'a{sv}' */ if (g_strcmp0 (method_name, "GetResults") == 0) { FuDeviceItem *item = NULL; const gchar *id = NULL; g_variant_get (parameters, "(&s)", &id); g_debug ("Called %s(%s)", method_name, id); /* find device */ item = fu_main_get_item_by_id_fallback_pending (priv, id, &error); if (item == NULL) { fu_main_invocation_return_error (priv, invocation, error); return; } /* call into the plugin */ if (!fu_plugin_runner_get_results (item->plugin, item->device, &error)) { fu_main_invocation_return_error (priv, invocation, error); return; } /* ensure the unique ID is set */ if (fwupd_result_get_unique_id (FWUPD_RESULT (item->device)) == NULL) { g_autofree gchar *id2 = NULL; FwupdResult *res = FWUPD_RESULT (item->device); FwupdDevice *dev = fwupd_result_get_device (res); #if AS_CHECK_VERSION(0,6,1) id2 = as_utils_unique_id_build (AS_APP_SCOPE_SYSTEM, AS_BUNDLE_KIND_UNKNOWN, NULL, AS_APP_KIND_FIRMWARE, fwupd_device_get_name (dev), fwupd_device_get_version (dev)); #else id2 = g_strdup_printf ("system/*/*/firmware/%s/%s", fwupd_device_get_name (dev), fwupd_device_get_version (dev)); #endif fwupd_result_set_unique_id (res, id2); } /* success */ val = fwupd_result_to_data (FWUPD_RESULT (item->device), "(a{sv})"); fu_main_invocation_return_value (priv, invocation, val); return; } /* return '' */ if (g_strcmp0 (method_name, "UpdateMetadata") == 0) { GDBusMessage *message; GUnixFDList *fd_list; gint fd_data; gint fd_sig; g_debug ("Called %s()", method_name); message = g_dbus_method_invocation_get_message (invocation); fd_list = g_dbus_message_get_unix_fd_list (message); if (fd_list == NULL || g_unix_fd_list_get_length (fd_list) != 2) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "invalid handle"); fu_main_invocation_return_error (priv, invocation, error); return; } fd_data = g_unix_fd_list_get (fd_list, 0, &error); if (fd_data < 0) { fu_main_invocation_return_error (priv, invocation, error); return; } fd_sig = g_unix_fd_list_get (fd_list, 1, &error); if (fd_sig < 0) { fu_main_invocation_return_error (priv, invocation, error); return; } if (!fu_main_daemon_update_metadata (priv, NULL, fd_data, fd_sig, &error)) { g_prefix_error (&error, "failed to update metadata: "); fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, NULL); return; } /* return '' */ if (g_strcmp0 (method_name, "UpdateMetadataWithId") == 0) { GDBusMessage *message; GUnixFDList *fd_list; const gchar *id = NULL; gint fd_data; gint fd_sig; g_variant_get (parameters, "(&shh)", &id); g_debug ("Called %s(%s)", method_name, id); message = g_dbus_method_invocation_get_message (invocation); fd_list = g_dbus_message_get_unix_fd_list (message); if (fd_list == NULL || g_unix_fd_list_get_length (fd_list) != 2) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "invalid handle"); fu_main_invocation_return_error (priv, invocation, error); return; } fd_data = g_unix_fd_list_get (fd_list, 0, &error); if (fd_data < 0) { fu_main_invocation_return_error (priv, invocation, error); return; } fd_sig = g_unix_fd_list_get (fd_list, 1, &error); if (fd_sig < 0) { fu_main_invocation_return_error (priv, invocation, error); return; } if (!fu_main_daemon_update_metadata (priv, id, fd_data, fd_sig, &error)) { g_prefix_error (&error, "failed to update metadata: "); fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, NULL); return; } /* return 's' */ if (g_strcmp0 (method_name, "Unlock") == 0) { FuDeviceItem *item = NULL; FuMainAuthHelper *helper; const gchar *id = NULL; g_autoptr(PolkitSubject) subject = NULL; /* check the id exists */ g_variant_get (parameters, "(&s)", &id); g_debug ("Called %s(%s)", method_name, id); item = fu_main_get_item_by_id (priv, id); if (item == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "No such device %s", id); fu_main_invocation_return_error (priv, invocation, error); return; } /* check the device is locked */ if (!fu_device_has_flag (item->device, FWUPD_DEVICE_FLAG_LOCKED)) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "Device %s is not locked", id); fu_main_invocation_return_error (priv, invocation, error); return; } /* process the firmware */ helper = g_new0 (FuMainAuthHelper, 1); helper->auth_kind = FU_MAIN_AUTH_KIND_UNLOCK; helper->invocation = g_object_ref (invocation); helper->devices = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); helper->priv = priv; /* FIXME: do we want to support "*"? */ g_ptr_array_add (helper->devices, g_object_ref (item->device)); /* authenticate */ subject = polkit_system_bus_name_new (sender); polkit_authority_check_authorization (helper->priv->authority, subject, "org.freedesktop.fwupd.device-unlock", NULL, POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION, NULL, fu_main_check_authorization_cb, helper); return; } /* return 'b' */ if (g_strcmp0 (method_name, "VerifyUpdate") == 0) { FuDeviceItem *item = NULL; FuMainAuthHelper *helper; const gchar *id = NULL; g_autoptr(PolkitSubject) subject = NULL; /* check the id exists */ g_variant_get (parameters, "(&s)", &id); g_debug ("Called %s(%s)", method_name, id); item = fu_main_get_item_by_id (priv, id); if (item == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "No such device %s", id); fu_main_invocation_return_error (priv, invocation, error); return; } /* process the firmware */ helper = g_new0 (FuMainAuthHelper, 1); helper->auth_kind = FU_MAIN_AUTH_KIND_VERIFY_UPDATE; helper->invocation = g_object_ref (invocation); helper->devices = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); helper->priv = priv; g_ptr_array_add (helper->devices, g_object_ref (item->device)); /* authenticate */ subject = polkit_system_bus_name_new (sender); polkit_authority_check_authorization (helper->priv->authority, subject, "org.freedesktop.fwupd.verify-update", NULL, POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION, NULL, fu_main_check_authorization_cb, helper); return; } /* return 's' */ if (g_strcmp0 (method_name, "Verify") == 0) { AsApp *app; AsChecksum *csum; AsRelease *release; FuDeviceItem *item = NULL; const gchar *hash = NULL; const gchar *id = NULL; const gchar *version = NULL; /* check the id exists */ g_variant_get (parameters, "(&s)", &id); g_debug ("Called %s(%s)", method_name, id); item = fu_main_get_item_by_id (priv, id); if (item == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "No such device %s", id); fu_main_invocation_return_error (priv, invocation, error); return; } /* set the device firmware hash */ if (!fu_plugin_runner_verify (item->plugin, item->device, FU_PLUGIN_VERIFY_FLAG_NONE, &error)) { fu_main_invocation_return_error (priv, invocation, error); return; } /* find component in metadata */ app = fu_main_store_get_app_by_guids (priv->store, item->device); if (app == NULL) { g_set_error_literal (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "No metadata"); fu_main_invocation_return_error (priv, invocation, error); return; } /* find version in metadata */ version = fu_device_get_version (item->device); release = as_app_get_release (app, version); if (release == NULL) release = as_app_get_release_default (app); if (release == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "No version %s", version); fu_main_invocation_return_error (priv, invocation, error); return; } /* find checksum */ csum = as_release_get_checksum_by_target (release, AS_CHECKSUM_TARGET_CONTENT); if (csum == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "No content checksum for %s", version); fu_main_invocation_return_error (priv, invocation, error); return; } hash = fu_device_get_checksum (item->device); if (g_strcmp0 (as_checksum_get_value (csum), hash) != 0) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "For v%s expected %s, got %s", version, as_checksum_get_value (csum), hash); fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, NULL); return; } /* return '' */ if (g_strcmp0 (method_name, "Install") == 0) { FuDeviceItem *item = NULL; FuMainAuthHelper *helper; FwupdInstallFlags flags = FWUPD_INSTALL_FLAG_NONE; GDBusMessage *message; GUnixFDList *fd_list; GVariant *prop_value; const gchar *action_id; const gchar *id = NULL; gchar *prop_key; gint32 fd_handle = 0; gint fd; g_autoptr(PolkitSubject) subject = NULL; g_autoptr(GVariantIter) iter = NULL; g_autoptr(GBytes) blob_cab = NULL; g_autoptr(GInputStream) stream = NULL; /* check the id exists */ g_variant_get (parameters, "(&sha{sv})", &id, &fd_handle, &iter); g_debug ("Called %s(%s,%i)", method_name, id, fd_handle); if (g_strcmp0 (id, FWUPD_DEVICE_ID_ANY) != 0) { item = fu_main_get_item_by_id (priv, id); if (item == NULL) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "no such device %s", id); fu_main_invocation_return_error (priv, invocation, error); return; } } /* get options */ while (g_variant_iter_next (iter, "{&sv}", &prop_key, &prop_value)) { g_debug ("got option %s", prop_key); if (g_strcmp0 (prop_key, "offline") == 0 && g_variant_get_boolean (prop_value) == TRUE) flags |= FWUPD_INSTALL_FLAG_OFFLINE; if (g_strcmp0 (prop_key, "allow-older") == 0 && g_variant_get_boolean (prop_value) == TRUE) flags |= FWUPD_INSTALL_FLAG_ALLOW_OLDER; if (g_strcmp0 (prop_key, "allow-reinstall") == 0 && g_variant_get_boolean (prop_value) == TRUE) flags |= FWUPD_INSTALL_FLAG_ALLOW_REINSTALL; if (g_strcmp0 (prop_key, "force") == 0 && g_variant_get_boolean (prop_value) == TRUE) flags |= FWUPD_INSTALL_FLAG_FORCE; g_variant_unref (prop_value); } /* get the fd */ message = g_dbus_method_invocation_get_message (invocation); fd_list = g_dbus_message_get_unix_fd_list (message); if (fd_list == NULL || g_unix_fd_list_get_length (fd_list) != 1) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "invalid handle"); fu_main_invocation_return_error (priv, invocation, error); return; } fd = g_unix_fd_list_get (fd_list, 0, &error); if (fd < 0) { fu_main_invocation_return_error (priv, invocation, error); return; } /* read the entire fd to a data blob */ stream = g_unix_input_stream_new (fd, TRUE); blob_cab = g_input_stream_read_bytes (stream, FU_MAIN_FIRMWARE_SIZE_MAX, NULL, &error); if (blob_cab == NULL){ fu_main_invocation_return_error (priv, invocation, error); return; } /* process the firmware */ helper = g_new0 (FuMainAuthHelper, 1); helper->auth_kind = FU_MAIN_AUTH_KIND_INSTALL; helper->invocation = g_object_ref (invocation); helper->trust_flags = FWUPD_TRUST_FLAG_NONE; helper->blob_cab = g_bytes_ref (blob_cab); helper->flags = flags; helper->priv = priv; helper->store = as_store_new (); helper->devices = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); helper->blob_fws = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref); if (item != NULL) g_ptr_array_add (helper->devices, g_object_ref (item->device)); if (!fu_main_update_helper (helper, &error)) { fu_main_invocation_return_error (helper->priv, helper->invocation, error); fu_main_helper_free (helper); return; } /* is root */ if (fu_main_dbus_get_uid (priv, sender) == 0) { if (!fu_main_plugin_update_authenticated (helper, &error)) { fu_main_invocation_return_error (priv, invocation, error); } else { fu_main_invocation_return_value (priv, invocation, NULL); } fu_main_helper_free (helper); return; } /* authenticate */ action_id = fu_main_get_action_id_for_device (helper); subject = polkit_system_bus_name_new (sender); polkit_authority_check_authorization (helper->priv->authority, subject, action_id, NULL, POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION, NULL, fu_main_check_authorization_cb, helper); return; } /* get a single result object from a local file */ if (g_strcmp0 (method_name, "GetDetails") == 0) { GDBusMessage *message; GUnixFDList *fd_list; gint32 fd_handle = 0; gint fd; /* get parameters */ g_variant_get (parameters, "(h)", &fd_handle); g_debug ("Called %s(%i)", method_name, fd_handle); /* get the fd */ message = g_dbus_method_invocation_get_message (invocation); fd_list = g_dbus_message_get_unix_fd_list (message); if (fd_list == NULL || g_unix_fd_list_get_length (fd_list) != 1) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "invalid handle"); fu_main_invocation_return_error (priv, invocation, error); return; } fd = g_unix_fd_list_get (fd_list, 0, &error); if (fd < 0) { fu_main_invocation_return_error (priv, invocation, error); return; } /* get details about the file */ val = fu_main_get_details_from_fd (priv, fd, &error); if (val == NULL) { fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, val); return; } /* get multiple result objects from a local file */ if (g_strcmp0 (method_name, "GetDetailsLocal") == 0) { GDBusMessage *message; GUnixFDList *fd_list; gint32 fd_handle = 0; gint fd; /* get parameters */ g_variant_get (parameters, "(h)", &fd_handle); g_debug ("Called %s(%i)", method_name, fd_handle); /* get the fd */ message = g_dbus_method_invocation_get_message (invocation); fd_list = g_dbus_message_get_unix_fd_list (message); if (fd_list == NULL || g_unix_fd_list_get_length (fd_list) != 1) { g_set_error (&error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "invalid handle"); fu_main_invocation_return_error (priv, invocation, error); return; } fd = g_unix_fd_list_get (fd_list, 0, &error); if (fd < 0) { fu_main_invocation_return_error (priv, invocation, error); return; } /* get details about the file */ val = fu_main_get_details_local_from_fd (priv, fd, &error); if (val == NULL) { fu_main_invocation_return_error (priv, invocation, error); return; } fu_main_invocation_return_value (priv, invocation, val); return; } /* we suck */ g_set_error (&error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "no such method %s", method_name); fu_main_invocation_return_error (priv, invocation, error); } static GVariant * fu_main_daemon_get_property (GDBusConnection *connection_, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *property_name, GError **error, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; if (g_strcmp0 (property_name, "DaemonVersion") == 0) return g_variant_new_string (VERSION); if (g_strcmp0 (property_name, "Status") == 0) return g_variant_new_uint32 (priv->status); /* return an error */ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_PROPERTY, "failed to get daemon property %s", property_name); return NULL; } static void fu_main_plugins_setup (FuMainPrivate *priv) { g_autoptr(AsProfileTask) ptask = NULL; ptask = as_profile_start_literal (priv->profile, "FuMain:setup"); g_assert (ptask != NULL); for (guint i = 0; i < priv->plugins->len; i++) { g_autoptr(GError) error = NULL; g_autoptr(AsProfileTask) ptask2 = NULL; FuPlugin *plugin = g_ptr_array_index (priv->plugins, i); ptask2 = as_profile_start (priv->profile, "FuMain:setup{%s}", fu_plugin_get_name (plugin)); g_assert (ptask2 != NULL); if (!fu_plugin_runner_startup (plugin, &error)) { fu_plugin_set_enabled (plugin, FALSE); g_warning ("disabling plugin because: %s", error->message); } } } static void fu_main_plugins_coldplug (FuMainPrivate *priv) { g_autoptr(AsProfileTask) ptask = NULL; /* don't allow coldplug to be scheduled when in coldplug */ priv->coldplug_running = TRUE; /* prepare */ for (guint i = 0; i < priv->plugins->len; i++) { g_autoptr(GError) error = NULL; FuPlugin *plugin = g_ptr_array_index (priv->plugins, i); if (!fu_plugin_runner_coldplug_prepare (plugin, &error)) g_warning ("failed to prepare coldplug: %s", error->message); } /* do this in one place */ if (priv->coldplug_delay > 0) { g_debug ("sleeping for %ums", priv->coldplug_delay); g_usleep (priv->coldplug_delay * 1000); } /* exec */ ptask = as_profile_start_literal (priv->profile, "FuMain:coldplug"); g_assert (ptask != NULL); for (guint i = 0; i < priv->plugins->len; i++) { g_autoptr(GError) error = NULL; g_autoptr(AsProfileTask) ptask2 = NULL; FuPlugin *plugin = g_ptr_array_index (priv->plugins, i); ptask2 = as_profile_start (priv->profile, "FuMain:coldplug{%s}", fu_plugin_get_name (plugin)); g_assert (ptask2 != NULL); if (!fu_plugin_runner_coldplug (plugin, &error)) { fu_plugin_set_enabled (plugin, FALSE); g_warning ("disabling plugin because: %s", error->message); } } /* cleanup */ for (guint i = 0; i < priv->plugins->len; i++) { g_autoptr(GError) error = NULL; FuPlugin *plugin = g_ptr_array_index (priv->plugins, i); if (!fu_plugin_runner_coldplug_cleanup (plugin, &error)) g_warning ("failed to cleanup coldplug: %s", error->message); } /* we can recoldplug from this point on */ priv->coldplug_running = FALSE; } static void fu_main_on_bus_acquired_cb (GDBusConnection *connection, const gchar *name, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; guint registration_id; g_autoptr(GError) error = NULL; static const GDBusInterfaceVTable interface_vtable = { fu_main_daemon_method_call, fu_main_daemon_get_property, NULL }; priv->connection = g_object_ref (connection); registration_id = g_dbus_connection_register_object (connection, FWUPD_DBUS_PATH, priv->introspection_daemon->interfaces[0], &interface_vtable, priv, /* user_data */ NULL, /* user_data_free_func */ NULL); /* GError** */ g_assert (registration_id > 0); /* connect to D-Bus directly */ priv->proxy_uid = g_dbus_proxy_new_sync (priv->connection, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, NULL, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", NULL, &error); if (priv->proxy_uid == NULL) { g_warning ("cannot connect to DBus: %s", error->message); return; } /* dump startup profile data */ if (fu_debug_is_verbose ()) as_profile_dump (priv->profile); } static void fu_main_on_name_acquired_cb (GDBusConnection *connection, const gchar *name, gpointer user_data) { g_debug ("FuMain: acquired name: %s", name); } static void fu_main_on_name_lost_cb (GDBusConnection *connection, const gchar *name, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; g_debug ("FuMain: lost name: %s", name); g_main_loop_quit (priv->loop); } static gboolean fu_main_timed_exit_cb (gpointer user_data) { GMainLoop *loop = (GMainLoop *) user_data; g_main_loop_quit (loop); return G_SOURCE_REMOVE; } static GDBusNodeInfo * fu_main_load_introspection (const gchar *filename, GError **error) { g_autoptr(GBytes) data = NULL; g_autofree gchar *path = NULL; /* lookup data */ path = g_build_filename ("/org/freedesktop/fwupd", filename, NULL); data = g_resource_lookup_data (fu_get_resource (), path, G_RESOURCE_LOOKUP_FLAGS_NONE, error); if (data == NULL) return NULL; /* build introspection from XML */ return g_dbus_node_info_new_for_xml (g_bytes_get_data (data, NULL), error); } static void fu_main_plugin_device_added_cb (FuPlugin *plugin, FuDevice *device, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; FuDeviceItem *item; g_auto(GStrv) guids = NULL; g_autoptr(GError) error = NULL; /* device has no GUIDs set! */ if (fu_device_get_guid_default (device) == NULL) { g_warning ("no GUIDs for device %s [%s]", fu_device_get_id (device), fu_device_get_name (device)); return; } /* is this GUID blacklisted */ guids = g_key_file_get_string_list (priv->config, "fwupd", "BlacklistDevices", NULL, /* length */ NULL); if (guids != NULL && g_strv_contains ((const gchar * const *) guids, fu_device_get_guid_default (device))) { g_debug ("%s is blacklisted [%s], ignoring from %s", fu_device_get_id (device), fu_device_get_guid_default (device), fu_plugin_get_name (plugin)); return; } /* remove any fake device */ item = fu_main_get_item_by_id (priv, fu_device_get_id (device)); if (item != NULL) { g_debug ("already added %s by %s, ignoring same device from %s", fu_device_get_id (item->device), fu_device_get_plugin (item->device), fu_plugin_get_name (plugin)); return; } /* create new device */ item = g_new0 (FuDeviceItem, 1); item->device = g_object_ref (device); item->plugin = g_object_ref (plugin); g_ptr_array_add (priv->devices, item); /* match the metadata at this point so clients can tell if the * device is worthy */ fu_main_get_updates_item_update (priv, item); /* notify clients */ fu_main_emit_device_added (priv, item->device); fu_main_emit_changed (priv); } static void fu_main_plugin_device_removed_cb (FuPlugin *plugin, FuDevice *device, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; FuDeviceItem *item; item = fu_main_get_item_by_id (priv, fu_device_get_id (device)); if (item == NULL) { g_debug ("no device to remove %s", fu_device_get_id (device)); return; } /* check this came from the same plugin */ if (g_strcmp0 (fu_plugin_get_name (plugin), fu_plugin_get_name (item->plugin)) != 0) { g_debug ("ignoring duplicate removal from %s", fu_plugin_get_name (plugin)); return; } /* make the UI update */ fu_main_emit_device_removed (priv, device); g_ptr_array_remove (priv->devices, item); fu_main_emit_changed (priv); } static void fu_main_plugin_status_changed_cb (FuPlugin *plugin, FwupdStatus status, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; fu_main_set_status (priv, status); } static void fu_main_plugin_percentage_changed_cb (FuPlugin *plugin, guint percentage, gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; fu_main_set_percentage (priv, percentage); } static gboolean fu_main_recoldplug_delay_cb (gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; g_debug ("performing a recoldplug"); fu_main_plugins_coldplug (priv); priv->coldplug_id = 0; return FALSE; } static void fu_main_plugin_recoldplug_cb (FuPlugin *plugin, FuMainPrivate *priv) { if (priv->coldplug_running) { g_warning ("coldplug already running, cannot recoldplug"); return; } g_debug ("scheduling a recoldplug"); if (priv->coldplug_id != 0) g_source_remove (priv->coldplug_id); priv->coldplug_id = g_timeout_add (1500, fu_main_recoldplug_delay_cb, priv); } static void fu_main_plugin_set_coldplug_delay_cb (FuPlugin *plugin, guint duration, FuMainPrivate *priv) { priv->coldplug_delay = MAX (priv->coldplug_delay, duration); g_debug ("got coldplug delay of %ums, global maximum is now %ums", duration, priv->coldplug_delay); } static gboolean fu_main_load_hwids (FuMainPrivate *priv, GError **error) { g_autoptr(FuHwids) hwids = fu_hwids_new (); /* read files in /sys */ if (!fu_hwids_setup (hwids, NULL, error)) return FALSE; /* add GUIDs */ for (guint i = 0; i < 15; i++) { g_autofree gchar *guid = NULL; g_autofree gchar *key = NULL; g_autofree gchar *values = NULL; g_autoptr(GError) error_local = NULL; /* get the GUID and add to hash */ key = g_strdup_printf ("HardwareID-%u", i); guid = fu_hwids_get_guid (hwids, key, &error_local); if (guid == NULL) { g_debug ("%s is not available, %s", key, error_local->message); continue; } g_hash_table_insert (priv->hwids, g_strdup (guid), GUINT_TO_POINTER (1)); /* show what makes up the GUID */ values = fu_hwids_get_replace_values (hwids, key, NULL); g_debug ("{%s} <- %s", guid, values); } return TRUE; } static gboolean fu_main_load_plugins (FuMainPrivate *priv, GError **error) { const gchar *fn; g_autoptr(GDir) dir = NULL; g_auto(GStrv) blacklist = NULL; /* get plugin blacklist */ blacklist = g_key_file_get_string_list (priv->config, "fwupd", "BlacklistPlugins", NULL, /* length */ NULL); /* search */ dir = g_dir_open (PLUGINDIR, 0, error); if (dir == NULL) return FALSE; while ((fn = g_dir_read_name (dir)) != NULL) { g_autofree gchar *filename = NULL; g_autoptr(FuPlugin) plugin = NULL; g_autoptr(GError) error_local = NULL; /* ignore non-plugins */ if (!g_str_has_suffix (fn, ".so")) continue; /* open module */ filename = g_build_filename (PLUGINDIR, fn, NULL); plugin = fu_plugin_new (); fu_plugin_set_usb_context (plugin, priv->usb_ctx); fu_plugin_set_hwids (plugin, priv->hwids); g_debug ("adding plugin %s", filename); if (!fu_plugin_open (plugin, filename, &error_local)) { g_warning ("failed to open plugin %s: %s", filename, error_local->message); continue; } /* is blacklisted */ if (blacklist != NULL && g_strv_contains ((const gchar * const *) blacklist, fu_plugin_get_name (plugin))) { fu_plugin_set_enabled (plugin, FALSE); g_debug ("%s blacklisted by config", fu_plugin_get_name (plugin)); continue; } /* watch for changes */ g_signal_connect (plugin, "device-added", G_CALLBACK (fu_main_plugin_device_added_cb), priv); g_signal_connect (plugin, "device-removed", G_CALLBACK (fu_main_plugin_device_removed_cb), priv); g_signal_connect (plugin, "status-changed", G_CALLBACK (fu_main_plugin_status_changed_cb), priv); g_signal_connect (plugin, "percentage-changed", G_CALLBACK (fu_main_plugin_percentage_changed_cb), priv); g_signal_connect (plugin, "recoldplug", G_CALLBACK (fu_main_plugin_recoldplug_cb), priv); g_signal_connect (plugin, "set-coldplug-delay", G_CALLBACK (fu_main_plugin_set_coldplug_delay_cb), priv); /* add */ g_ptr_array_add (priv->plugins, g_object_ref (plugin)); g_hash_table_insert (priv->plugins_hash, g_strdup (fu_plugin_get_name (plugin)), g_object_ref (plugin)); } return TRUE; } /* returns FALSE if any plugins have pending devices to be added */ static gboolean fu_main_check_plugins_pending (FuMainPrivate *priv, GError **error) { for (guint i = 0; i < priv->plugins->len; i++) { FuPlugin *plugin = g_ptr_array_index (priv->plugins, i); if (fu_plugin_has_device_delay (plugin)) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "%s pending", fu_plugin_get_name (plugin)); return FALSE; } } return TRUE; } static gboolean fu_main_perhaps_own_name (gpointer user_data) { FuMainPrivate *priv = (FuMainPrivate *) user_data; g_autoptr(GError) error = NULL; /* are any plugins pending */ if (!fu_main_check_plugins_pending (priv, &error)) { g_debug ("trying again: %s", error->message); return G_SOURCE_CONTINUE; } /* own the object */ g_debug ("registering D-Bus service"); priv->owner_id = g_bus_own_name (G_BUS_TYPE_SYSTEM, FWUPD_DBUS_SERVICE, G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE, fu_main_on_bus_acquired_cb, fu_main_on_name_acquired_cb, fu_main_on_name_lost_cb, priv, NULL); return G_SOURCE_REMOVE; } static void fu_main_private_free (FuMainPrivate *priv) { if (priv->loop != NULL) g_main_loop_unref (priv->loop); if (priv->owner_id > 0) g_bus_unown_name (priv->owner_id); if (priv->proxy_uid != NULL) g_object_unref (priv->proxy_uid); if (priv->usb_ctx != NULL) g_object_unref (priv->usb_ctx); if (priv->config != NULL) g_key_file_unref (priv->config); if (priv->connection != NULL) g_object_unref (priv->connection); if (priv->authority != NULL) g_object_unref (priv->authority); if (priv->profile != NULL) g_object_unref (priv->profile); if (priv->store != NULL) g_object_unref (priv->store); if (priv->introspection_daemon != NULL) g_dbus_node_info_unref (priv->introspection_daemon); if (priv->store_changed_id != 0) g_source_remove (priv->store_changed_id); if (priv->pending != NULL) g_object_unref (priv->pending); if (priv->coldplug_id != 0) g_source_remove (priv->coldplug_id); if (priv->plugins != NULL) g_ptr_array_unref (priv->plugins); if (priv->hwids != NULL) g_hash_table_unref (priv->hwids); if (priv->plugins_hash != NULL) g_hash_table_unref (priv->plugins_hash); g_ptr_array_unref (priv->devices); g_free (priv); } G_DEFINE_AUTOPTR_CLEANUP_FUNC(FuMainPrivate, fu_main_private_free) int main (int argc, char *argv[]) { gboolean immediate_exit = FALSE; gboolean timed_exit = FALSE; const GOptionEntry options[] = { { "timed-exit", '\0', 0, G_OPTION_ARG_NONE, &timed_exit, /* TRANSLATORS: exit after we've started up, used for user profiling */ _("Exit after a small delay"), NULL }, { "immediate-exit", '\0', 0, G_OPTION_ARG_NONE, &immediate_exit, /* TRANSLATORS: exit straight away, used for automatic profiling */ _("Exit after the engine has loaded"), NULL }, { NULL} }; g_autoptr(FuMainPrivate) priv = NULL; g_autoptr(GError) error = NULL; g_autoptr(GOptionContext) context = NULL; g_autofree gchar *config_file = NULL; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* TRANSLATORS: program name */ g_set_application_name (_("Firmware Update Daemon")); context = g_option_context_new (NULL); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, fu_debug_get_option_group ()); /* TRANSLATORS: program summary */ g_option_context_set_summary (context, _("Firmware Update D-Bus Service")); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("Failed to parse command line: %s\n", error->message); return EXIT_FAILURE; } /* create new objects */ priv = g_new0 (FuMainPrivate, 1); priv->status = FWUPD_STATUS_IDLE; priv->percentage = 0; priv->devices = g_ptr_array_new_with_free_func ((GDestroyNotify) fu_main_item_free); priv->loop = g_main_loop_new (NULL, FALSE); priv->pending = fu_pending_new (); priv->store = as_store_new (); priv->profile = as_profile_new (); g_signal_connect (priv->store, "changed", G_CALLBACK (fu_main_store_changed_cb), priv); as_store_set_watch_flags (priv->store, AS_STORE_WATCH_FLAG_ADDED | AS_STORE_WATCH_FLAG_REMOVED); /* load AppStream */ as_store_add_filter (priv->store, AS_APP_KIND_FIRMWARE); if (!as_store_load (priv->store, AS_STORE_LOAD_FLAG_IGNORE_INVALID | AS_STORE_LOAD_FLAG_APP_INFO_SYSTEM, NULL, &error)){ g_printerr ("Failed to load AppStream data: %s\n", error->message); return EXIT_FAILURE; } /* read config file */ config_file = g_build_filename (fu_main_get_sysconfig_dir (), "fwupd.conf", NULL); g_debug ("loading config values from %s", config_file); priv->config = g_key_file_new (); if (!g_key_file_load_from_file (priv->config, config_file, G_KEY_FILE_NONE, &error)) { g_printerr ("Failed to load config file %s: %s\n", config_file, error->message); return EXIT_FAILURE; } /* set shared USB context */ priv->usb_ctx = g_usb_context_new (&error); if (priv->usb_ctx == NULL) { g_printerr ("Failed to get USB context: %s\n", error->message); return EXIT_FAILURE; } /* load the hwids */ priv->hwids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); if (!fu_main_load_hwids (priv, &error)) { g_printerr ("Failed to load hwids: %s\n", error->message); return EXIT_FAILURE; } /* load plugin */ priv->plugins = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); priv->plugins_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref); if (!fu_main_load_plugins (priv, &error)) { g_printerr ("Failed to load plugins: %s\n", error->message); return EXIT_FAILURE; } /* disable udev? */ if (!g_key_file_get_boolean (priv->config, "fwupd", "EnableOptionROM", NULL)) { FuPlugin *plugin = g_hash_table_lookup (priv->plugins_hash, "udev"); if (plugin != NULL) fu_plugin_set_enabled (plugin, FALSE); } /* load introspection from file */ priv->introspection_daemon = fu_main_load_introspection (FWUPD_DBUS_INTERFACE ".xml", &error); if (priv->introspection_daemon == NULL) { g_printerr ("Failed to load introspection: %s\n", error->message); return EXIT_FAILURE; } /* get authority */ priv->authority = polkit_authority_get_sync (NULL, &error); if (priv->authority == NULL) { g_printerr ("Failed to load authority: %s\n", error->message); return EXIT_FAILURE; } /* add devices */ fu_main_plugins_setup (priv); g_usb_context_enumerate (priv->usb_ctx); fu_main_plugins_coldplug (priv); /* keep polling until all the plugins are ready */ g_timeout_add (200, fu_main_perhaps_own_name, priv); /* Only timeout and close the mainloop if we have specified it * on the command line */ if (immediate_exit) g_idle_add (fu_main_timed_exit_cb, priv->loop); else if (timed_exit) g_timeout_add_seconds (5, fu_main_timed_exit_cb, priv->loop); /* wait */ g_info ("Daemon ready for requests"); g_main_loop_run (priv->loop); /* success */ return EXIT_SUCCESS; }