/* * Copyright (C) 2016-2018 Richard Hughes * * SPDX-License-Identifier: LGPL-2.1+ */ #define G_LOG_DOMAIN "FuPlugin" #include "config.h" #include #include #include #include #include #ifdef HAVE_VALGRIND #include #endif /* HAVE_VALGRIND */ #include "fu-device-private.h" #include "fu-plugin-private.h" #include "fu-mutex.h" /** * SECTION:fu-plugin * @short_description: a daemon plugin * * An object that represents a plugin run by the daemon. * * See also: #FuDevice */ #define FU_PLUGIN_COLDPLUG_DELAY_MAXIMUM 3000u /* ms */ static void fu_plugin_finalize (GObject *object); typedef struct { GModule *module; GUsbContext *usb_ctx; guint order; guint priority; GPtrArray *rules[FU_PLUGIN_RULE_LAST]; gchar *build_hash; FuHwids *hwids; FuQuirks *quirks; GHashTable *runtime_versions; GHashTable *compile_versions; GPtrArray *udev_subsystems; FuSmbios *smbios; GType device_gtype; GHashTable *devices; /* (nullable): platform_id:GObject */ GRWLock devices_mutex; GHashTable *report_metadata; /* (nullable): key:value */ FuPluginData *data; } FuPluginPrivate; enum { SIGNAL_DEVICE_ADDED, SIGNAL_DEVICE_REMOVED, SIGNAL_DEVICE_REGISTER, SIGNAL_RULES_CHANGED, SIGNAL_RECOLDPLUG, SIGNAL_SET_COLDPLUG_DELAY, SIGNAL_CHECK_SUPPORTED, SIGNAL_ADD_FIRMWARE_GTYPE, SIGNAL_SECURITY_CHANGED, SIGNAL_LAST }; static guint signals[SIGNAL_LAST] = { 0 }; G_DEFINE_TYPE_WITH_PRIVATE (FuPlugin, fu_plugin, FWUPD_TYPE_PLUGIN) #define GET_PRIVATE(o) (fu_plugin_get_instance_private (o)) typedef const gchar *(*FuPluginGetNameFunc) (void); typedef void (*FuPluginInitFunc) (FuPlugin *self); typedef gboolean (*FuPluginStartupFunc) (FuPlugin *self, GError **error); typedef void (*FuPluginDeviceRegisterFunc) (FuPlugin *self, FuDevice *device); typedef gboolean (*FuPluginDeviceFunc) (FuPlugin *self, FuDevice *device, GError **error); typedef gboolean (*FuPluginFlaggedDeviceFunc) (FuPlugin *self, FwupdInstallFlags flags, FuDevice *device, GError **error); typedef gboolean (*FuPluginDeviceArrayFunc) (FuPlugin *self, GPtrArray *devices, GError **error); typedef gboolean (*FuPluginVerifyFunc) (FuPlugin *self, FuDevice *device, FuPluginVerifyFlags flags, GError **error); typedef gboolean (*FuPluginUpdateFunc) (FuPlugin *self, FuDevice *device, GBytes *blob_fw, FwupdInstallFlags flags, GError **error); typedef gboolean (*FuPluginUsbDeviceAddedFunc) (FuPlugin *self, FuUsbDevice *device, GError **error); typedef gboolean (*FuPluginUdevDeviceAddedFunc) (FuPlugin *self, FuUdevDevice *device, GError **error); typedef void (*FuPluginSecurityAttrsFunc) (FuPlugin *self, FuSecurityAttrs *attrs); /** * fu_plugin_is_open: * @self: A #FuPlugin * * Determines if the plugin is opened * * Returns: TRUE for opened, FALSE for not * * Since: 1.3.5 **/ gboolean fu_plugin_is_open (FuPlugin *self) { FuPluginPrivate *priv = GET_PRIVATE (self); return priv->module != NULL; } /** * fu_plugin_get_name: * @self: A #FuPlugin * * Gets the plugin name. * * Returns: a plugin name, or %NULL for unknown. * * Since: 0.8.0 **/ const gchar * fu_plugin_get_name (FuPlugin *self) { g_return_val_if_fail (FU_IS_PLUGIN (self), NULL); return fwupd_plugin_get_name (FWUPD_PLUGIN (self)); } /** * fu_plugin_set_name: * @self: A #FuPlugin * @name: A string * * Sets the plugin name. * * Since: 0.8.0 **/ void fu_plugin_set_name (FuPlugin *self, const gchar *name) { g_return_if_fail (FU_IS_PLUGIN (self)); fwupd_plugin_set_name (FWUPD_PLUGIN (self), name); } /** * fu_plugin_set_build_hash: * @self: A #FuPlugin * @build_hash: A checksum * * Sets the plugin build hash, typically a SHA256 checksum. All plugins must * set the correct checksum to avoid the daemon being marked as tainted. * * Since: 1.2.4 **/ void fu_plugin_set_build_hash (FuPlugin *self, const gchar *build_hash) { FuPluginPrivate *priv = GET_PRIVATE (self); g_return_if_fail (FU_IS_PLUGIN (self)); g_return_if_fail (build_hash != NULL); g_free (priv->build_hash); priv->build_hash = g_strdup (build_hash); } /** * fu_plugin_get_build_hash: * @self: A #FuPlugin * * Gets the build hash a plugin was generated with. * * Returns: (transfer none): a #gchar, or %NULL for unset. * * Since: 1.2.4 **/ const gchar * fu_plugin_get_build_hash (FuPlugin *self) { FuPluginPrivate *priv = GET_PRIVATE (self); g_return_val_if_fail (FU_IS_PLUGIN (self), NULL); return priv->build_hash; } /** * fu_plugin_cache_lookup: * @self: A #FuPlugin * @id: the key * * Finds an object in the per-plugin cache. * * Returns: (transfer none): a #GObject, or %NULL for unfound. * * Since: 0.8.0 **/ gpointer fu_plugin_cache_lookup (FuPlugin *self, const gchar *id) { FuPluginPrivate *priv = GET_PRIVATE (self); g_autoptr(GRWLockReaderLocker) locker = g_rw_lock_reader_locker_new (&priv->devices_mutex); g_return_val_if_fail (FU_IS_PLUGIN (self), NULL); g_return_val_if_fail (id != NULL, NULL); g_return_val_if_fail (locker != NULL, NULL); if (priv->devices == NULL) return NULL; return g_hash_table_lookup (priv->devices, id); } /** * fu_plugin_cache_add: * @self: A #FuPlugin * @id: the key * @dev: a #GObject, typically a #FuDevice * * Adds an object to the per-plugin cache. * * Since: 0.8.0 **/ void fu_plugin_cache_add (FuPlugin *self, const gchar *id, gpointer dev) { FuPluginPrivate *priv = GET_PRIVATE (self); g_autoptr(GRWLockWriterLocker) locker = g_rw_lock_writer_locker_new (&priv->devices_mutex); g_return_if_fail (FU_IS_PLUGIN (self)); g_return_if_fail (id != NULL); g_return_if_fail (locker != NULL); if (priv->devices == NULL) { priv->devices = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref); } g_hash_table_insert (priv->devices, g_strdup (id), g_object_ref (dev)); } /** * fu_plugin_cache_remove: * @self: A #FuPlugin * @id: the key * * Removes an object from the per-plugin cache. * * Since: 0.8.0 **/ void fu_plugin_cache_remove (FuPlugin *self, const gchar *id) { FuPluginPrivate *priv = GET_PRIVATE (self); g_autoptr(GRWLockWriterLocker) locker = g_rw_lock_writer_locker_new (&priv->devices_mutex); g_return_if_fail (FU_IS_PLUGIN (self)); g_return_if_fail (id != NULL); g_return_if_fail (locker != NULL); if (priv->devices == NULL) return; g_hash_table_remove (priv->devices, id); } /** * fu_plugin_get_data: * @self: A #FuPlugin * * Gets the per-plugin allocated private data. This will return %NULL unless * fu_plugin_alloc_data() has been called by the plugin. * * Returns: (transfer none): a pointer to a structure, or %NULL for unset. * * Since: 0.8.0 **/ FuPluginData * fu_plugin_get_data (FuPlugin *self) { FuPluginPrivate *priv = GET_PRIVATE (self); g_return_val_if_fail (FU_IS_PLUGIN (self), NULL); return priv->data; } /** * fu_plugin_alloc_data: (skip): * @self: A #FuPlugin * @data_sz: the size to allocate * * Allocates the per-plugin allocated private data. * * Returns: (transfer full): a pointer to a structure, or %NULL for unset. * * Since: 0.8.0 **/ FuPluginData * fu_plugin_alloc_data (FuPlugin *self, gsize data_sz) { FuPluginPrivate *priv = GET_PRIVATE (self); g_return_val_if_fail (FU_IS_PLUGIN (self), NULL); if (priv->data != NULL) { g_critical ("fu_plugin_alloc_data() already used by plugin"); return priv->data; } priv->data = g_malloc0 (data_sz); return priv->data; } /** * fu_plugin_get_usb_context: * @self: A #FuPlugin * * Gets the shared USB context that all plugins can use. * * Returns: (transfer none): a #GUsbContext. * * Since: 0.8.0 **/ GUsbContext * fu_plugin_get_usb_context (FuPlugin *self) { FuPluginPrivate *priv = GET_PRIVATE (self); g_return_val_if_fail (FU_IS_PLUGIN (self), NULL); return priv->usb_ctx; } /** * fu_plugin_set_usb_context: * @self: A #FuPlugin * @usb_ctx: A #FGUsbContext * * Sets the shared USB context for a plugin * * Since: 0.8.0 **/ void fu_plugin_set_usb_context (FuPlugin *self, GUsbContext *usb_ctx) { FuPluginPrivate *priv = GET_PRIVATE (self); g_set_object (&priv->usb_ctx, usb_ctx); } /** * fu_plugin_get_enabled: * @self: A #FuPlugin * * Returns if the plugin is enabled. Plugins may self-disable using * fu_plugin_set_enabled() or can be disabled by the daemon. * * Returns: %TRUE if the plugin is currently enabled. * * Since: 0.8.0 **/ gboolean fu_plugin_get_enabled (FuPlugin *self) { g_return_val_if_fail (FU_IS_PLUGIN (self), FALSE); return !fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED); } /** * fu_plugin_set_enabled: * @self: A #FuPlugin * @enabled: the enabled value * * Enables or disables a plugin. Plugins can self-disable at any point. * * Since: 0.8.0 **/ void fu_plugin_set_enabled (FuPlugin *self, gboolean enabled) { g_return_if_fail (FU_IS_PLUGIN (self)); if (enabled) { fwupd_plugin_remove_flag (FWUPD_PLUGIN (self), FWUPD_PLUGIN_FLAG_DISABLED); } else { fu_plugin_add_flag (self, FWUPD_PLUGIN_FLAG_DISABLED); } } /** * fu_plugin_guess_name_from_fn: * @filename: filename to guess * * Tries to guess the name of the plugin from a filename * * Returns: (transfer full): the guessed name of the plugin * * Since: 1.0.8 **/ gchar * fu_plugin_guess_name_from_fn (const gchar *filename) { const gchar *prefix = "libfu_plugin_"; gchar *name; gchar *str = g_strstr_len (filename, -1, prefix); if (str == NULL) return NULL; name = g_strdup (str + strlen (prefix)); g_strdelimit (name, ".", '\0'); return name; } /** * fu_plugin_open: * @self: A #FuPlugin * @filename: The shared object filename to open * @error: A #GError or NULL * * Opens the plugin module * * Returns: TRUE for success, FALSE for fail * * Since: 0.8.0 **/ gboolean fu_plugin_open (FuPlugin *self, const gchar *filename, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginInitFunc func = NULL; priv->module = g_module_open (filename, 0); if (priv->module == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "failed to open plugin %s: %s", filename, g_module_error ()); fu_plugin_add_flag (self, FWUPD_PLUGIN_FLAG_FAILED_OPEN); fu_plugin_add_flag (self, FWUPD_PLUGIN_FLAG_USER_WARNING); return FALSE; } /* set automatically */ if (fu_plugin_get_name (self) == NULL) { g_autofree gchar *str = fu_plugin_guess_name_from_fn (filename); fu_plugin_set_name (self, str); } /* optional */ g_module_symbol (priv->module, "fu_plugin_init", (gpointer *) &func); if (func != NULL) { g_debug ("init(%s)", filename); func (self); } return TRUE; } /* order of usefulness to the user */ static const gchar * fu_plugin_build_device_update_error (FuPlugin *self) { if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_NO_HARDWARE)) return "Not updatable as required hardware was not found"; if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_LEGACY_BIOS)) return "Not updatable in legacy BIOS mode"; if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_CAPSULES_UNSUPPORTED)) return "Not updatable as UEFI capsule updates not enabled"; if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_UNLOCK_REQUIRED)) return "Not updatable as requires unlock"; if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_EFIVAR_NOT_MOUNTED)) return "Not updatable as efivarfs was not found"; if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_ESP_NOT_FOUND)) return "Not updatable as UEFI ESP partition not detected"; if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return "Not updatable as plugin was disabled"; return NULL; } /** * fu_plugin_device_add: * @self: A #FuPlugin * @device: A #FuDevice * * Asks the daemon to add a device to the exported list. If this device ID * has already been added by a different plugin then this request will be * ignored. * * Plugins should use fu_plugin_device_add_delay() if they are not capable of * actually flashing an image to the hardware so that higher-priority plugins * can add the device themselves. * * Since: 0.8.0 **/ void fu_plugin_device_add (FuPlugin *self, FuDevice *device) { GPtrArray *children; g_autoptr(GError) error = NULL; g_return_if_fail (FU_IS_PLUGIN (self)); g_return_if_fail (FU_IS_DEVICE (device)); /* ensure the device ID is set from the physical and logical IDs */ if (!fu_device_ensure_id (device, &error)) { g_warning ("ignoring add: %s", error->message); return; } /* proxy to device where required */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_CLEAR_UPDATABLE)) { g_debug ("plugin %s has _CLEAR_UPDATABLE, so removing from %s", fu_plugin_get_name (self), fu_device_get_id (device)); fu_device_remove_flag (device, FWUPD_DEVICE_FLAG_UPDATABLE); } if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_USER_WARNING) && fu_device_get_update_error (device) == NULL) { const gchar *tmp = fu_plugin_build_device_update_error (self); g_debug ("setting %s update error to '%s' from %s", fu_device_get_id (device), tmp, fu_plugin_get_name (self)); fu_device_set_update_error (device, tmp); } g_debug ("emit added from %s: %s", fu_plugin_get_name (self), fu_device_get_id (device)); fu_device_set_created (device, (guint64) g_get_real_time () / G_USEC_PER_SEC); fu_device_set_plugin (device, fu_plugin_get_name (self)); g_signal_emit (self, signals[SIGNAL_DEVICE_ADDED], 0, device); /* add children if they have not already been added */ children = fu_device_get_children (device); for (guint i = 0; i < children->len; i++) { FuDevice *child = g_ptr_array_index (children, i); if (fu_device_get_created (child) == 0) fu_plugin_device_add (self, child); } } /** * fu_plugin_device_register: * @self: A #FuPlugin * @device: A #FuDevice * * Registers the device with other plugins so they can set metadata. * * Plugins do not have to call this manually as this is done automatically * when using fu_plugin_device_add(). They may wish to use this manually * if for instance the coldplug should be ignored based on the metadata * set from other plugins. * * Since: 0.9.7 **/ void fu_plugin_device_register (FuPlugin *self, FuDevice *device) { g_autoptr(GError) error = NULL; g_return_if_fail (FU_IS_PLUGIN (self)); g_return_if_fail (FU_IS_DEVICE (device)); /* ensure the device ID is set from the physical and logical IDs */ if (!fu_device_ensure_id (device, &error)) { g_warning ("ignoring registration: %s", error->message); return; } g_debug ("emit device-register from %s: %s", fu_plugin_get_name (self), fu_device_get_id (device)); g_signal_emit (self, signals[SIGNAL_DEVICE_REGISTER], 0, device); } /** * fu_plugin_device_remove: * @self: A #FuPlugin * @device: A #FuDevice * * Asks the daemon to remove a device from the exported list. * * Since: 0.8.0 **/ void fu_plugin_device_remove (FuPlugin *self, FuDevice *device) { g_return_if_fail (FU_IS_PLUGIN (self)); g_return_if_fail (FU_IS_DEVICE (device)); g_debug ("emit removed from %s: %s", fu_plugin_get_name (self), fu_device_get_id (device)); g_signal_emit (self, signals[SIGNAL_DEVICE_REMOVED], 0, device); } /** * fu_plugin_request_recoldplug: * @self: A #FuPlugin * * Ask all the plugins to coldplug all devices, which will include the prepare() * and cleanup() phases. Duplicate devices added will be ignored. * * Since: 0.8.0 **/ void fu_plugin_request_recoldplug (FuPlugin *self) { g_return_if_fail (FU_IS_PLUGIN (self)); g_signal_emit (self, signals[SIGNAL_RECOLDPLUG], 0); } /** * fu_plugin_security_changed: * @self: A #FuPlugin * * Informs the daemon that the HSI state may have changed. * * Since: 1.5.0 **/ void fu_plugin_security_changed (FuPlugin *self) { g_return_if_fail (FU_IS_PLUGIN (self)); g_signal_emit (self, signals[SIGNAL_SECURITY_CHANGED], 0); } /** * fu_plugin_check_hwid: * @self: A #FuPlugin * @hwid: A Hardware ID GUID, e.g. `6de5d951-d755-576b-bd09-c5cf66b27234` * * Checks to see if a specific GUID exists. All hardware IDs on a * specific system can be shown using the `fwupdmgr hwids` command. * * Returns: %TRUE if the HwId is found on the system. * * Since: 0.9.1 **/ gboolean fu_plugin_check_hwid (FuPlugin *self, const gchar *hwid) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->hwids == NULL) return FALSE; return fu_hwids_has_guid (priv->hwids, hwid); } /** * fu_plugin_get_hwid_replace_value: * @self: A #FuPlugin * @keys: A key, e.g. `HardwareID-3` or %FU_HWIDS_KEY_PRODUCT_SKU * @error: A #GError or %NULL * * Gets the replacement value for a specific key. All hardware IDs on a * specific system can be shown using the `fwupdmgr hwids` command. * * Returns: (transfer full): a string, or %NULL for error. * * Since: 1.3.3 **/ gchar * fu_plugin_get_hwid_replace_value (FuPlugin *self, const gchar *keys, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->hwids == NULL) return NULL; return fu_hwids_get_replace_values (priv->hwids, keys, error); } /** * fu_plugin_get_hwids: * @self: A #FuPlugin * * Returns all the HWIDs defined in the system. All hardware IDs on a * specific system can be shown using the `fwupdmgr hwids` command. * * Returns: (transfer none) (element-type utf8): An array of GUIDs * * Since: 1.1.1 **/ GPtrArray * fu_plugin_get_hwids (FuPlugin *self) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->hwids == NULL) return NULL; return fu_hwids_get_guids (priv->hwids); } /** * fu_plugin_has_custom_flag: * @self: A #FuPlugin * @flag: A custom text flag, specific to the plugin, e.g. `uefi-force-enable` * * Returns if a per-plugin HwId custom flag exists, typically added from a DMI quirk. * * Returns: %TRUE if the quirk entry exists * * Since: 1.3.1 **/ gboolean fu_plugin_has_custom_flag (FuPlugin *self, const gchar *flag) { FuPluginPrivate *priv = GET_PRIVATE (self); GPtrArray *hwids = fu_plugin_get_hwids (self); g_return_val_if_fail (FU_IS_PLUGIN (self), FALSE); g_return_val_if_fail (flag != NULL, FALSE); /* never set up, e.g. in tests */ if (hwids == NULL) return FALSE; /* search each hwid */ for (guint i = 0; i < hwids->len; i++) { const gchar *hwid = g_ptr_array_index (hwids, i); const gchar *value; g_autofree gchar *key = g_strdup_printf ("HwId=%s", hwid); /* does prefixed quirk exist */ value = fu_quirks_lookup_by_id (priv->quirks, key, FU_QUIRKS_FLAGS); if (value != NULL) { g_auto(GStrv) quirks = g_strsplit (value, ",", -1); if (g_strv_contains ((const gchar * const *) quirks, flag)) return TRUE; } } return FALSE; } /** * fu_plugin_check_supported: * @self: A #FuPlugin * @guid: A Hardware ID GUID, e.g. `6de5d951-d755-576b-bd09-c5cf66b27234` * * Checks to see if a specific device GUID is supported, i.e. available in the * AppStream metadata. * * Returns: %TRUE if the device is supported. * * Since: 1.0.0 **/ static gboolean fu_plugin_check_supported (FuPlugin *self, const gchar *guid) { gboolean retval = FALSE; g_signal_emit (self, signals[SIGNAL_CHECK_SUPPORTED], 0, guid, &retval); return retval; } /** * fu_plugin_get_dmi_value: * @self: A #FuPlugin * @dmi_id: A DMI ID, e.g. `BiosVersion` * * Gets a hardware DMI value. * * Returns: The string, or %NULL * * Since: 0.9.7 **/ const gchar * fu_plugin_get_dmi_value (FuPlugin *self, const gchar *dmi_id) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->hwids == NULL) return NULL; return fu_hwids_get_value (priv->hwids, dmi_id); } /** * fu_plugin_get_smbios_string: * @self: A #FuPlugin * @structure_type: A SMBIOS structure type, e.g. %FU_SMBIOS_STRUCTURE_TYPE_BIOS * @offset: A SMBIOS offset * * Gets a hardware SMBIOS string. * * The @type and @offset can be referenced from the DMTF SMBIOS specification: * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.1.1.pdf * * Returns: A string, or %NULL * * Since: 0.9.8 **/ const gchar * fu_plugin_get_smbios_string (FuPlugin *self, guint8 structure_type, guint8 offset) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->smbios == NULL) return NULL; return fu_smbios_get_string (priv->smbios, structure_type, offset, NULL); } /** * fu_plugin_get_smbios_data: * @self: A #FuPlugin * @structure_type: A SMBIOS structure type, e.g. %FU_SMBIOS_STRUCTURE_TYPE_BIOS * * Gets a hardware SMBIOS data. * * Returns: (transfer full): A #GBytes, or %NULL * * Since: 0.9.8 **/ GBytes * fu_plugin_get_smbios_data (FuPlugin *self, guint8 structure_type) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->smbios == NULL) return NULL; return fu_smbios_get_data (priv->smbios, structure_type, NULL); } /** * fu_plugin_set_hwids: * @self: A #FuPlugin * @hwids: A #FuHwids * * Sets the hwids for a plugin * * Since: 0.9.7 **/ void fu_plugin_set_hwids (FuPlugin *self, FuHwids *hwids) { FuPluginPrivate *priv = GET_PRIVATE (self); g_set_object (&priv->hwids, hwids); } /** * fu_plugin_set_udev_subsystems: * @self: A #FuPlugin * @udev_subsystems: (element-type utf8): A #GPtrArray * * Sets the udev subsystems used by a plugin * * Since: 1.1.2 **/ void fu_plugin_set_udev_subsystems (FuPlugin *self, GPtrArray *udev_subsystems) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->udev_subsystems != NULL) g_ptr_array_unref (priv->udev_subsystems); priv->udev_subsystems = g_ptr_array_ref (udev_subsystems); } /** * fu_plugin_set_quirks: * @self: A #FuPlugin * @quirks: A #FuQuirks * * Sets the quirks for a plugin * * Since: 1.0.1 **/ void fu_plugin_set_quirks (FuPlugin *self, FuQuirks *quirks) { FuPluginPrivate *priv = GET_PRIVATE (self); g_set_object (&priv->quirks, quirks); } /** * fu_plugin_get_quirks: * @self: A #FuPlugin * * Returns the hardware database object. This can be used to discover device * quirks or other device-specific settings. * * Returns: (transfer none): a #FuQuirks, or %NULL if not set * * Since: 1.0.1 **/ FuQuirks * fu_plugin_get_quirks (FuPlugin *self) { FuPluginPrivate *priv = GET_PRIVATE (self); return priv->quirks; } /** * fu_plugin_set_runtime_versions: * @self: A #FuPlugin * @runtime_versions: A #GHashTables * * Sets the runtime versions for a plugin * * Since: 1.0.7 **/ void fu_plugin_set_runtime_versions (FuPlugin *self, GHashTable *runtime_versions) { FuPluginPrivate *priv = GET_PRIVATE (self); priv->runtime_versions = g_hash_table_ref (runtime_versions); } /** * fu_plugin_add_runtime_version: * @self: A #FuPlugin * @component_id: An AppStream component id, e.g. "org.gnome.Software" * @version: A version string, e.g. "1.2.3" * * Sets a runtime version of a specific dependency. * * Since: 1.0.7 **/ void fu_plugin_add_runtime_version (FuPlugin *self, const gchar *component_id, const gchar *version) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->runtime_versions == NULL) return; g_hash_table_insert (priv->runtime_versions, g_strdup (component_id), g_strdup (version)); } /** * fu_plugin_set_compile_versions: * @self: A #FuPlugin * @compile_versions: A #GHashTables * * Sets the compile time versions for a plugin * * Since: 1.0.7 **/ void fu_plugin_set_compile_versions (FuPlugin *self, GHashTable *compile_versions) { FuPluginPrivate *priv = GET_PRIVATE (self); priv->compile_versions = g_hash_table_ref (compile_versions); } /** * fu_plugin_add_compile_version: * @self: A #FuPlugin * @component_id: An AppStream component id, e.g. "org.gnome.Software" * @version: A version string, e.g. "1.2.3" * * Sets a compile-time version of a specific dependency. * * Since: 1.0.7 **/ void fu_plugin_add_compile_version (FuPlugin *self, const gchar *component_id, const gchar *version) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->compile_versions == NULL) return; g_hash_table_insert (priv->compile_versions, g_strdup (component_id), g_strdup (version)); } /** * fu_plugin_lookup_quirk_by_id: * @self: A #FuPlugin * @group: A string, e.g. "DfuFlags" * @key: An ID to match the entry, e.g. "Summary" * * Looks up an entry in the hardware database using a string value. * * Returns: (transfer none): values from the database, or %NULL if not found * * Since: 1.0.1 **/ const gchar * fu_plugin_lookup_quirk_by_id (FuPlugin *self, const gchar *group, const gchar *key) { FuPluginPrivate *priv = GET_PRIVATE (self); g_return_val_if_fail (FU_IS_PLUGIN (self), NULL); /* exact ID */ return fu_quirks_lookup_by_id (priv->quirks, group, key); } /** * fu_plugin_lookup_quirk_by_id_as_uint64: * @self: A #FuPlugin * @group: A string, e.g. "DfuFlags" * @key: An ID to match the entry, e.g. "Size" * * Looks up an entry in the hardware database using a string key, returning * an integer value. Values are assumed base 10, unless prefixed with "0x" * where they are parsed as base 16. * * Returns: guint64 id or 0 if not found * * Since: 1.1.2 **/ guint64 fu_plugin_lookup_quirk_by_id_as_uint64 (FuPlugin *self, const gchar *group, const gchar *key) { return fu_common_strtoull (fu_plugin_lookup_quirk_by_id (self, group, key)); } /** * fu_plugin_set_smbios: * @self: A #FuPlugin * @smbios: A #FuSmbios * * Sets the smbios for a plugin * * Since: 1.0.0 **/ void fu_plugin_set_smbios (FuPlugin *self, FuSmbios *smbios) { FuPluginPrivate *priv = GET_PRIVATE (self); g_set_object (&priv->smbios, smbios); } /** * fu_plugin_set_coldplug_delay: * @self: A #FuPlugin * @duration: A delay in milliseconds * * Set the minimum time that should be waited in-between the call to * fu_plugin_coldplug_prepare() and fu_plugin_coldplug(). This is usually going * to be the minimum hardware initialization time from a datasheet. * * It is better to use this function rather than using a sleep() in the plugin * itself as then only one delay is done in the daemon rather than waiting for * each coldplug prepare in a serial way. * * Additionally, very long delays should be avoided as the daemon will be * blocked from processing requests whilst the coldplug delay is being * performed. * * Since: 0.8.0 **/ void fu_plugin_set_coldplug_delay (FuPlugin *self, guint duration) { g_return_if_fail (FU_IS_PLUGIN (self)); g_return_if_fail (duration > 0); /* check sanity */ if (duration > FU_PLUGIN_COLDPLUG_DELAY_MAXIMUM) { g_warning ("duration of %ums is crazy, truncating to %ums", duration, FU_PLUGIN_COLDPLUG_DELAY_MAXIMUM); duration = FU_PLUGIN_COLDPLUG_DELAY_MAXIMUM; } /* emit */ g_signal_emit (self, signals[SIGNAL_SET_COLDPLUG_DELAY], 0, duration); } static gboolean fu_plugin_device_attach (FuPlugin *self, FuDevice *device, GError **error) { g_autoptr(FuDeviceLocker) locker = NULL; locker = fu_device_locker_new (device, error); if (locker == NULL) return FALSE; return fu_device_attach (device, error); } static gboolean fu_plugin_device_detach (FuPlugin *self, FuDevice *device, GError **error) { g_autoptr(FuDeviceLocker) locker = NULL; locker = fu_device_locker_new (device, error); if (locker == NULL) return FALSE; return fu_device_detach (device, error); } static gboolean fu_plugin_device_activate (FuPlugin *self, FuDevice *device, GError **error) { g_autoptr(FuDeviceLocker) locker = NULL; locker = fu_device_locker_new (device, error); if (locker == NULL) return FALSE; return fu_device_activate (device, error); } static gboolean fu_plugin_device_write_firmware (FuPlugin *self, FuDevice *device, GBytes *fw, FwupdInstallFlags flags, GError **error) { g_autoptr(FuDeviceLocker) locker = NULL; locker = fu_device_locker_new (device, error); if (locker == NULL) return FALSE; /* back the old firmware up to /var/lib/fwupd */ if (fu_device_has_flag (device, FWUPD_DEVICE_FLAG_BACKUP_BEFORE_INSTALL)) { g_autoptr(GBytes) fw_old = NULL; g_autofree gchar *path = NULL; g_autofree gchar *fn = NULL; g_autofree gchar *localstatedir = NULL; fw_old = fu_device_dump_firmware (device, error); if (fw_old == NULL) { g_prefix_error (error, "failed to backup old firmware: "); return FALSE; } localstatedir = fu_common_get_path (FU_PATH_KIND_LOCALSTATEDIR_PKG); fn = g_strdup_printf ("%s.bin", fu_device_get_version (device)); path = g_build_filename (localstatedir, "backup", fu_device_get_id (device), fu_device_get_serial (device) != NULL ? fu_device_get_serial (device) : "default", fn, NULL); if (!fu_common_set_contents_bytes (path, fw_old, error)) return FALSE; } return fu_device_write_firmware (device, fw, flags, error); } static gboolean fu_plugin_device_read_firmware (FuPlugin *self, FuDevice *device, GError **error) { g_autoptr(FuDeviceLocker) locker = NULL; g_autoptr(FuFirmware) firmware = NULL; g_autoptr(GBytes) fw = NULL; GChecksumType checksum_types[] = { G_CHECKSUM_SHA1, G_CHECKSUM_SHA256, 0 }; locker = fu_device_locker_new (device, error); if (locker == NULL) return FALSE; if (!fu_device_detach (device, error)) return FALSE; firmware = fu_device_read_firmware (device, error); if (firmware == NULL) { g_autoptr(GError) error_local = NULL; if (!fu_device_attach (device, &error_local)) g_debug ("ignoring attach failure: %s", error_local->message); g_prefix_error (error, "failed to read firmware: "); return FALSE; } fw = fu_firmware_write (firmware, error); if (fw == NULL) { g_autoptr(GError) error_local = NULL; if (!fu_device_attach (device, &error_local)) g_debug ("ignoring attach failure: %s", error_local->message); g_prefix_error (error, "failed to write firmware: "); return FALSE; } for (guint i = 0; checksum_types[i] != 0; i++) { g_autofree gchar *hash = NULL; hash = g_compute_checksum_for_bytes (checksum_types[i], fw); fu_device_add_checksum (device, hash); } return fu_device_attach (device, error); } /** * fu_plugin_runner_startup: * @self: a #FuPlugin * @error: a #GError or NULL * * Runs the startup routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_startup (FuPlugin *self, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginStartupFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_startup", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("startup(%s)", fu_plugin_get_name (self)); if (!func (self, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in startup(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to startup using %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } static gboolean fu_plugin_runner_device_generic (FuPlugin *self, FuDevice *device, const gchar *symbol_name, FuPluginDeviceFunc device_func, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginDeviceFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, symbol_name, (gpointer *) &func); if (func == NULL) { if (device_func != NULL) { g_debug ("running superclassed %s(%s)", symbol_name + 10, fu_plugin_get_name (self)); return device_func (self, device, error); } return TRUE; } g_debug ("%s(%s)", symbol_name + 10, fu_plugin_get_name (self)); if (!func (self, device, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in %s(%s)", fu_plugin_get_name (self), symbol_name + 10); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to %s using %s: ", symbol_name + 10, fu_plugin_get_name (self)); return FALSE; } return TRUE; } static gboolean fu_plugin_runner_flagged_device_generic (FuPlugin *self, FwupdInstallFlags flags, FuDevice *device, const gchar *symbol_name, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginFlaggedDeviceFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, symbol_name, (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("%s(%s)", symbol_name + 10, fu_plugin_get_name (self)); if (!func (self, flags, device, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in %s(%s)", fu_plugin_get_name (self), symbol_name + 10); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to %s using %s: ", symbol_name + 10, fu_plugin_get_name (self)); return FALSE; } return TRUE; } static gboolean fu_plugin_runner_device_array_generic (FuPlugin *self, GPtrArray *devices, const gchar *symbol_name, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginDeviceArrayFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, symbol_name, (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("%s(%s)", symbol_name + 10, fu_plugin_get_name (self)); if (!func (self, devices, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in for %s(%s)", fu_plugin_get_name (self), symbol_name + 10); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to %s using %s: ", symbol_name + 10, fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_coldplug: * @self: a #FuPlugin * @error: a #GError or NULL * * Runs the coldplug routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_coldplug (FuPlugin *self, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginStartupFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_coldplug", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("coldplug(%s)", fu_plugin_get_name (self)); if (!func (self, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in coldplug(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to coldplug using %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_recoldplug: * @self: a #FuPlugin * @error: a #GError or NULL * * Runs the recoldplug routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.0.4 **/ gboolean fu_plugin_runner_recoldplug (FuPlugin *self, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginStartupFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_recoldplug", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("recoldplug(%s)", fu_plugin_get_name (self)); if (!func (self, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in recoldplug(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to recoldplug using %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_coldplug_prepare: * @self: a #FuPlugin * @error: a #GError or NULL * * Runs the coldplug_prepare routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_coldplug_prepare (FuPlugin *self, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginStartupFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_coldplug_prepare", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("coldplug_prepare(%s)", fu_plugin_get_name (self)); if (!func (self, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in coldplug_prepare(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to coldplug_prepare using %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_coldplug_cleanup: * @self: a #FuPlugin * @error: a #GError or NULL * * Runs the coldplug_cleanup routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_coldplug_cleanup (FuPlugin *self, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginStartupFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_coldplug_cleanup", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("coldplug_cleanup(%s)", fu_plugin_get_name (self)); if (!func (self, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in coldplug_cleanup(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to coldplug_cleanup using %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_composite_prepare: * @self: a #FuPlugin * @devices: (element-type FuDevice): a #GPtrArray of devices * @error: a #GError or NULL * * Runs the composite_prepare routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.0.9 **/ gboolean fu_plugin_runner_composite_prepare (FuPlugin *self, GPtrArray *devices, GError **error) { return fu_plugin_runner_device_array_generic (self, devices, "fu_plugin_composite_prepare", error); } /** * fu_plugin_runner_composite_cleanup: * @self: a #FuPlugin * @devices: (element-type FuDevice): a #GPtrArray of devices * @error: a #GError or NULL * * Runs the composite_cleanup routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.0.9 **/ gboolean fu_plugin_runner_composite_cleanup (FuPlugin *self, GPtrArray *devices, GError **error) { return fu_plugin_runner_device_array_generic (self, devices, "fu_plugin_composite_cleanup", error); } /** * fu_plugin_runner_update_prepare: * @self: a #FuPlugin * @flags: #FwupdInstallFlags * @device: a #FuDevice * @error: a #GError or NULL * * Runs the update_prepare routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.1.2 **/ gboolean fu_plugin_runner_update_prepare (FuPlugin *self, FwupdInstallFlags flags, FuDevice *device, GError **error) { return fu_plugin_runner_flagged_device_generic (self, flags, device, "fu_plugin_update_prepare", error); } /** * fu_plugin_runner_update_cleanup: * @self: a #FuPlugin * @flags: #FwupdInstallFlags * @device: a #FuDevice * @error: a #GError or NULL * * Runs the update_cleanup routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.1.2 **/ gboolean fu_plugin_runner_update_cleanup (FuPlugin *self, FwupdInstallFlags flags, FuDevice *device, GError **error) { return fu_plugin_runner_flagged_device_generic (self, flags, device, "fu_plugin_update_cleanup", error); } /** * fu_plugin_runner_update_attach: * @self: a #FuPlugin * @device: a #FuDevice * @error: a #GError or NULL * * Runs the update_attach routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.1.2 **/ gboolean fu_plugin_runner_update_attach (FuPlugin *self, FuDevice *device, GError **error) { return fu_plugin_runner_device_generic (self, device, "fu_plugin_update_attach", fu_plugin_device_attach, error); } /** * fu_plugin_runner_update_detach: * @self: a #FuPlugin * @device: A #FuDevice * @error: a #GError or NULL * * Runs the update_detach routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.1.2 **/ gboolean fu_plugin_runner_update_detach (FuPlugin *self, FuDevice *device, GError **error) { return fu_plugin_runner_device_generic (self, device, "fu_plugin_update_detach", fu_plugin_device_detach, error); } /** * fu_plugin_runner_update_reload: * @self: a #FuPlugin * @device: A #FuDevice * @error: a #GError or NULL * * Runs reload routine for a device * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.1.2 **/ gboolean fu_plugin_runner_update_reload (FuPlugin *self, FuDevice *device, GError **error) { g_autoptr(FuDeviceLocker) locker = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ locker = fu_device_locker_new (device, error); if (locker == NULL) return FALSE; return fu_device_reload (device, error); } /** * fu_plugin_runner_add_security_attrs: * @self: a #FuPlugin * @attrs: a #FuSecurityAttrs * * Runs the `add_security_attrs()` routine for the plugin * * Since: 1.5.0 **/ void fu_plugin_runner_add_security_attrs (FuPlugin *self, FuSecurityAttrs *attrs) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginSecurityAttrsFunc func = NULL; const gchar *symbol_name = "fu_plugin_add_security_attrs"; /* no object loaded */ if (priv->module == NULL) return; /* optional, but gets called even for disabled plugins */ g_module_symbol (priv->module, symbol_name, (gpointer *) &func); if (func == NULL) return; g_debug ("%s(%s)", symbol_name + 10, fu_plugin_get_name (self)); func (self, attrs); } /** * fu_plugin_add_udev_subsystem: * @self: a #FuPlugin * @subsystem: a subsystem name, e.g. `pciport` * * Registers the udev subsystem to be watched by the daemon. * * Plugins can use this method only in fu_plugin_init() * * Since: 1.1.2 **/ void fu_plugin_add_udev_subsystem (FuPlugin *self, const gchar *subsystem) { FuPluginPrivate *priv = GET_PRIVATE (self); if (priv->udev_subsystems == NULL) priv->udev_subsystems = g_ptr_array_new_with_free_func (g_free); for (guint i = 0; i < priv->udev_subsystems->len; i++) { const gchar *subsystem_tmp = g_ptr_array_index (priv->udev_subsystems, i); if (g_strcmp0 (subsystem_tmp, subsystem) == 0) return; } g_debug ("added udev subsystem watch of %s", subsystem); g_ptr_array_add (priv->udev_subsystems, g_strdup (subsystem)); } /** * fu_plugin_set_device_gtype: * @self: a #FuPlugin * @device_gtype: a #GType `FU_TYPE_DEVICE` * * Sets the device #GType which is used when creating devices. * * If this method is used then fu_plugin_usb_device_added() is not called, and * instead the object is created in the daemon for the plugin. * * Plugins can use this method only in fu_plugin_init() * * Since: 1.3.3 **/ void fu_plugin_set_device_gtype (FuPlugin *self, GType device_gtype) { FuPluginPrivate *priv = GET_PRIVATE (self); priv->device_gtype = device_gtype; } /** * fu_plugin_add_firmware_gtype: * @self: a #FuPlugin * @id: A string describing the type * @gtype: a #GType `FU_TYPE_DEVICE` * * Adds a firmware #GType which is used when creating devices. * * * Plugins can use this method only in fu_plugin_init() * * Since: 1.3.3 **/ void fu_plugin_add_firmware_gtype (FuPlugin *self, const gchar *id, GType gtype) { g_signal_emit (self, signals[SIGNAL_ADD_FIRMWARE_GTYPE], 0, id, gtype); } static gboolean fu_plugin_check_supported_device (FuPlugin *self, FuDevice *device) { GPtrArray *instance_ids = fu_device_get_instance_ids (device); for (guint i = 0; i < instance_ids->len; i++) { const gchar *instance_id = g_ptr_array_index (instance_ids, i); g_autofree gchar *guid = fwupd_guid_hash_string (instance_id); if (fu_plugin_check_supported (self, guid)) return TRUE; } return FALSE; } static gboolean fu_plugin_usb_device_added (FuPlugin *self, FuUsbDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); GType device_gtype = fu_device_get_specialized_gtype (FU_DEVICE (device)); g_autoptr(FuDevice) dev = NULL; g_autoptr(FuDeviceLocker) locker = NULL; /* fall back to plugin default */ if (device_gtype == G_TYPE_INVALID) device_gtype = priv->device_gtype; /* create new device and incorporate existing properties */ dev = g_object_new (device_gtype, NULL); fu_device_incorporate (dev, FU_DEVICE (device)); if (!fu_plugin_runner_device_created (self, dev, error)) return FALSE; /* there are a lot of different devices that match, but not all respond * well to opening -- so limit some ones with issued updates */ if (fu_device_has_flag (dev, FWUPD_DEVICE_FLAG_ONLY_SUPPORTED)) { if (!fu_device_probe (dev, error)) return FALSE; fu_device_convert_instance_ids (dev); if (!fu_plugin_check_supported_device (self, dev)) { g_autofree gchar *guids = fu_device_get_guids_as_str (dev); g_debug ("%s has no updates, so ignoring device", guids); return TRUE; } } /* open and add */ locker = fu_device_locker_new (dev, error); if (locker == NULL) return FALSE; fu_plugin_device_add (self, dev); fu_plugin_runner_device_added (self, dev); return TRUE; } static gboolean fu_plugin_udev_device_added (FuPlugin *self, FuUdevDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); GType device_gtype = fu_device_get_specialized_gtype (FU_DEVICE (device)); g_autoptr(FuDevice) dev = NULL; g_autoptr(FuDeviceLocker) locker = NULL; /* fall back to plugin default */ if (device_gtype == G_TYPE_INVALID) device_gtype = priv->device_gtype; /* create new device and incorporate existing properties */ dev = g_object_new (device_gtype, NULL); fu_device_incorporate (FU_DEVICE (dev), FU_DEVICE (device)); if (!fu_plugin_runner_device_created (self, dev, error)) return FALSE; /* there are a lot of different devices that match, but not all respond * well to opening -- so limit some ones with issued updates */ if (fu_device_has_flag (dev, FWUPD_DEVICE_FLAG_ONLY_SUPPORTED)) { if (!fu_device_probe (dev, error)) return FALSE; fu_device_convert_instance_ids (dev); if (!fu_plugin_check_supported_device (self, dev)) { g_autofree gchar *guids = fu_device_get_guids_as_str (dev); g_debug ("%s has no updates, so ignoring device", guids); return TRUE; } } /* open and add */ locker = fu_device_locker_new (dev, error); if (locker == NULL) return FALSE; fu_plugin_device_add (self, FU_DEVICE (dev)); fu_plugin_runner_device_added (self, dev); return TRUE; } /** * fu_plugin_runner_usb_device_added: * @self: a #FuPlugin * @device: a #FuUsbDevice * @error: a #GError or NULL * * Call the usb_device_added routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.0.2 **/ gboolean fu_plugin_runner_usb_device_added (FuPlugin *self, FuUsbDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginUsbDeviceAddedFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_usb_device_added", (gpointer *) &func); if (func == NULL) { if (priv->device_gtype != G_TYPE_INVALID || fu_device_get_specialized_gtype (FU_DEVICE (device)) != G_TYPE_INVALID) { if (!fu_plugin_usb_device_added (self, device, error)) return FALSE; } return TRUE; } g_debug ("usb_device_added(%s)", fu_plugin_get_name (self)); if (!func (self, device, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in usb_device_added(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to add device using on %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_udev_device_added: * @self: a #FuPlugin * @device: a #FuUdevDevice * @error: a #GError or NULL * * Call the udev_device_added routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.0.2 **/ gboolean fu_plugin_runner_udev_device_added (FuPlugin *self, FuUdevDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginUdevDeviceAddedFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_udev_device_added", (gpointer *) &func); if (func == NULL) { if (priv->device_gtype != G_TYPE_INVALID || fu_device_get_specialized_gtype (FU_DEVICE (device)) != G_TYPE_INVALID) { if (!fu_plugin_udev_device_added (self, device, error)) return FALSE; } return TRUE; } g_debug ("udev_device_added(%s)", fu_plugin_get_name (self)); if (!func (self, device, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in udev_device_added(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to add device using on %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_udev_device_changed: * @self: a #FuPlugin * @device: a #FuUdevDevice * @error: a #GError or NULL * * Call the udev_device_changed routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.0.2 **/ gboolean fu_plugin_runner_udev_device_changed (FuPlugin *self, FuUdevDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginUdevDeviceAddedFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_udev_device_changed", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("udev_device_changed(%s)", fu_plugin_get_name (self)); if (!func (self, device, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in udev_device_changed(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to change device on %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_device_added: * @self: a #FuPlugin * @device: a #FuDevice * * Call the device_added routine for the plugin * * Since: 1.5.0 **/ void fu_plugin_runner_device_added (FuPlugin *self, FuDevice *device) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginDeviceRegisterFunc func = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return; if (priv->module == NULL) return; /* optional */ g_module_symbol (priv->module, "fu_plugin_device_added", (gpointer *) &func); if (func == NULL) return; g_debug ("fu_plugin_device_added(%s)", fu_plugin_get_name (self)); func (self, device); } /** * fu_plugin_runner_device_removed: * @self: a #FuPlugin * @device: a #FuDevice * * Call the device_removed routine for the plugin * * Since: 1.1.2 **/ void fu_plugin_runner_device_removed (FuPlugin *self, FuDevice *device) { g_autoptr(GError) error_local= NULL; if (!fu_plugin_runner_device_generic (self, device, "fu_plugin_device_removed", NULL, &error_local)) g_warning ("%s", error_local->message); } /** * fu_plugin_runner_device_register: * @self: a #FuPlugin * @device: a #FuDevice * * Call the device_registered routine for the plugin * * Since: 0.9.7 **/ void fu_plugin_runner_device_register (FuPlugin *self, FuDevice *device) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginDeviceRegisterFunc func = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return; if (priv->module == NULL) return; /* don't notify plugins on their own devices */ if (g_strcmp0 (fu_device_get_plugin (device), fu_plugin_get_name (self)) == 0) return; /* optional */ g_module_symbol (priv->module, "fu_plugin_device_registered", (gpointer *) &func); if (func != NULL) { g_debug ("fu_plugin_device_registered(%s)", fu_plugin_get_name (self)); func (self, device); } } /** * fu_plugin_runner_device_created: * @self: a #FuPlugin * @device: a #FuDevice * @error: a #GError or NULL * * Call the device_created routine for the plugin * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.4.0 **/ gboolean fu_plugin_runner_device_created (FuPlugin *self, FuDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginDeviceFunc func = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_device_created", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("fu_plugin_device_created(%s)", fu_plugin_get_name (self)); return func (self, device, error); } /** * fu_plugin_runner_verify: * @self: a #FuPlugin * @device: a #FuDevice * @flags: #FuPluginVerifyFlags * @error: A #GError or NULL * * Call into the plugin's verify routine * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_verify (FuPlugin *self, FuDevice *device, FuPluginVerifyFlags flags, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginVerifyFunc func = NULL; GPtrArray *checksums; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_verify", (gpointer *) &func); if (func == NULL) { return fu_plugin_device_read_firmware (self, device, error); } /* clear any existing verification checksums */ checksums = fu_device_get_checksums (device); g_ptr_array_set_size (checksums, 0); /* run additional detach */ if (!fu_plugin_runner_device_generic (self, device, "fu_plugin_update_detach", fu_plugin_device_detach, error)) return FALSE; /* run vfunc */ g_debug ("verify(%s)", fu_plugin_get_name (self)); if (!func (self, device, flags, &error_local)) { g_autoptr(GError) error_attach = NULL; if (error_local == NULL) { g_critical ("unset plugin error in verify(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to verify using %s: ", fu_plugin_get_name (self)); /* make the device "work" again, but don't prefix the error */ if (!fu_plugin_runner_device_generic (self, device, "fu_plugin_update_attach", fu_plugin_device_attach, &error_attach)) { g_warning ("failed to attach whilst aborting verify(): %s", error_attach->message); } return FALSE; } /* run optional attach */ if (!fu_plugin_runner_device_generic (self, device, "fu_plugin_update_attach", fu_plugin_device_attach, error)) return FALSE; /* success */ return TRUE; } /** * fu_plugin_runner_activate: * @self: a #FuPlugin * @device: a #FuDevice * @error: A #GError or NULL * * Call into the plugin's activate routine * * Returns: #TRUE for success, #FALSE for failure * * Since: 1.2.6 **/ gboolean fu_plugin_runner_activate (FuPlugin *self, FuDevice *device, GError **error) { guint64 flags; /* final check */ flags = fu_device_get_flags (device); if ((flags & FWUPD_DEVICE_FLAG_NEEDS_ACTIVATION) == 0) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED, "Device %s does not need activation", fu_device_get_id (device)); return FALSE; } /* run vfunc */ if (!fu_plugin_runner_device_generic (self, device, "fu_plugin_activate", fu_plugin_device_activate, error)) return FALSE; /* update with correct flags */ fu_device_remove_flag (device, FWUPD_DEVICE_FLAG_NEEDS_ACTIVATION); fu_device_set_modified (device, (guint64) g_get_real_time () / G_USEC_PER_SEC); return TRUE; } /** * fu_plugin_runner_unlock: * @self: a #FuPlugin * @device: a #FuDevice * @error: A #GError or NULL * * Call into the plugin's unlock routine * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_unlock (FuPlugin *self, FuDevice *device, GError **error) { guint64 flags; /* final check */ flags = fu_device_get_flags (device); if ((flags & FWUPD_DEVICE_FLAG_LOCKED) == 0) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED, "Device %s is not locked", fu_device_get_id (device)); return FALSE; } /* run vfunc */ if (!fu_plugin_runner_device_generic (self, device, "fu_plugin_unlock", NULL, error)) return FALSE; /* update with correct flags */ flags = fu_device_get_flags (device); fu_device_set_flags (device, flags &= ~FWUPD_DEVICE_FLAG_LOCKED); fu_device_set_modified (device, (guint64) g_get_real_time () / G_USEC_PER_SEC); return TRUE; } /** * fu_plugin_runner_update: * @self: a #FuPlugin * @device: a #FuDevice * @blob_fw: A #GBytes * @flags: A #FwupdInstallFlags * @error: A #GError or NULL * * Call into the plugin's update routine * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_update (FuPlugin *self, FuDevice *device, GBytes *blob_fw, FwupdInstallFlags flags, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginUpdateFunc update_func; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) { g_debug ("plugin not enabled, skipping"); return TRUE; } /* no object loaded */ if (priv->module == NULL) { g_debug ("module not enabled, skipping"); return TRUE; } /* optional */ g_module_symbol (priv->module, "fu_plugin_update", (gpointer *) &update_func); if (update_func == NULL) { g_debug ("superclassed write_firmware(%s)", fu_plugin_get_name (self)); return fu_plugin_device_write_firmware (self, device, blob_fw, flags, error); } /* online */ if (!update_func (self, device, blob_fw, flags, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in update(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); return FALSE; } fu_device_set_update_error (device, error_local->message); g_propagate_error (error, g_steal_pointer (&error_local)); return FALSE; } /* no longer valid */ if (!fu_device_has_flag (device, FWUPD_DEVICE_FLAG_NEEDS_REBOOT) && !fu_device_has_flag (device, FWUPD_DEVICE_FLAG_NEEDS_SHUTDOWN)) { GPtrArray *checksums = fu_device_get_checksums (device); g_ptr_array_set_size (checksums, 0); } /* success */ return TRUE; } /** * fu_plugin_runner_clear_results: * @self: a #FuPlugin * @device: a #FuDevice * @error: A #GError or NULL * * Call into the plugin's clear results routine * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_clear_results (FuPlugin *self, FuDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginDeviceFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_clear_results", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("clear_result(%s)", fu_plugin_get_name (self)); if (!func (self, device, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in clear_result(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to clear_result using %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_runner_get_results: * @self: a #FuPlugin * @device: a #FuDevice * @error: A #GError or NULL * * Call into the plugin's get results routine * * Returns: #TRUE for success, #FALSE for failure * * Since: 0.8.0 **/ gboolean fu_plugin_runner_get_results (FuPlugin *self, FuDevice *device, GError **error) { FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginDeviceFunc func = NULL; g_autoptr(GError) error_local = NULL; /* not enabled */ if (fu_plugin_has_flag (self, FWUPD_PLUGIN_FLAG_DISABLED)) return TRUE; /* no object loaded */ if (priv->module == NULL) return TRUE; /* optional */ g_module_symbol (priv->module, "fu_plugin_get_results", (gpointer *) &func); if (func == NULL) return TRUE; g_debug ("get_results(%s)", fu_plugin_get_name (self)); if (!func (self, device, &error_local)) { if (error_local == NULL) { g_critical ("unset plugin error in get_results(%s)", fu_plugin_get_name (self)); g_set_error_literal (&error_local, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "unspecified error"); } g_propagate_prefixed_error (error, g_steal_pointer (&error_local), "failed to get_results using %s: ", fu_plugin_get_name (self)); return FALSE; } return TRUE; } /** * fu_plugin_get_order: * @self: a #FuPlugin * * Gets the plugin order, where higher numbers are run after lower * numbers. * * Returns: the integer value * * Since: 1.0.0 **/ guint fu_plugin_get_order (FuPlugin *self) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); return priv->order; } /** * fu_plugin_set_order: * @self: a #FuPlugin * @order: a integer value * * Sets the plugin order, where higher numbers are run after lower * numbers. * * Since: 1.0.0 **/ void fu_plugin_set_order (FuPlugin *self, guint order) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); priv->order = order; } /** * fu_plugin_get_priority: * @self: a #FuPlugin * * Gets the plugin priority, where higher numbers are better. * * Returns: the integer value * * Since: 1.1.1 **/ guint fu_plugin_get_priority (FuPlugin *self) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); return priv->priority; } /** * fu_plugin_set_priority: * @self: a #FuPlugin * @priority: a integer value * * Sets the plugin priority, where higher numbers are better. * * Since: 1.0.0 **/ void fu_plugin_set_priority (FuPlugin *self, guint priority) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); priv->priority = priority; } /** * fu_plugin_add_rule: * @self: a #FuPlugin * @rule: a #FuPluginRule, e.g. %FU_PLUGIN_RULE_CONFLICTS * @name: a plugin name, e.g. `upower` * * If the plugin name is found, the rule will be used to sort the plugin list, * for example the plugin specified by @name will be ordered after this plugin * when %FU_PLUGIN_RULE_RUN_AFTER is used. * * NOTE: The depsolver is iterative and may not solve overly-complicated rules; * If depsolving fails then fwupd will not start. * * Since: 1.0.0 **/ void fu_plugin_add_rule (FuPlugin *self, FuPluginRule rule, const gchar *name) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); if (priv->rules[rule] == NULL) priv->rules[rule] = g_ptr_array_new_with_free_func (g_free); g_ptr_array_add (priv->rules[rule], g_strdup (name)); g_signal_emit (self, signals[SIGNAL_RULES_CHANGED], 0); } /** * fu_plugin_get_rules: * @self: a #FuPlugin * @rule: a #FuPluginRule, e.g. %FU_PLUGIN_RULE_CONFLICTS * * Gets the plugin IDs that should be run after this plugin. * * Returns: (element-type utf8) (transfer none) (nullable): the list of plugin names, e.g. ['appstream'] * * Since: 1.0.0 **/ GPtrArray * fu_plugin_get_rules (FuPlugin *self, FuPluginRule rule) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); g_return_val_if_fail (rule < FU_PLUGIN_RULE_LAST, NULL); return priv->rules[rule]; } /** * fu_plugin_has_rule: * @self: a #FuPlugin * @rule: a #FuPluginRule, e.g. %FU_PLUGIN_RULE_CONFLICTS * @name: a plugin name, e.g. `upower` * * Gets the plugin IDs that should be run after this plugin. * * Returns: %TRUE if the name exists for the specific rule * * Since: 1.0.0 **/ gboolean fu_plugin_has_rule (FuPlugin *self, FuPluginRule rule, const gchar *name) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); if (priv->rules[rule] == NULL) return FALSE; for (guint i = 0; i < priv->rules[rule]->len; i++) { const gchar *tmp = g_ptr_array_index (priv->rules[rule], i); if (g_strcmp0 (tmp, name) == 0) return TRUE; } return FALSE; } /** * fu_plugin_add_report_metadata: * @self: a #FuPlugin * @key: a string, e.g. `FwupdateVersion` * @value: a string, e.g. `10` * * Sets any additional metadata to be included in the firmware report to aid * debugging problems. * * Any data included here will be sent to the metadata server after user * confirmation. * * Since: 1.0.4 **/ void fu_plugin_add_report_metadata (FuPlugin *self, const gchar *key, const gchar *value) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); if (priv->report_metadata == NULL) { priv->report_metadata = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); } g_hash_table_insert (priv->report_metadata, g_strdup (key), g_strdup (value)); } /** * fu_plugin_get_report_metadata: * @self: a #FuPlugin * * Returns the list of additional metadata to be added when filing a report. * * Returns: (transfer none) (nullable): the map of report metadata * * Since: 1.0.4 **/ GHashTable * fu_plugin_get_report_metadata (FuPlugin *self) { FuPluginPrivate *priv = fu_plugin_get_instance_private (self); return priv->report_metadata; } /** * fu_plugin_get_config_value: * @self: a #FuPlugin * @key: A settings key * * Return the value of a key if it's been configured * * Since: 1.0.6 **/ gchar * fu_plugin_get_config_value (FuPlugin *self, const gchar *key) { g_autofree gchar *conf_dir = NULL; g_autofree gchar *conf_file = NULL; g_autofree gchar *conf_path = NULL; g_autoptr(GKeyFile) keyfile = NULL; const gchar *plugin_name; conf_dir = fu_common_get_path (FU_PATH_KIND_SYSCONFDIR_PKG); plugin_name = fu_plugin_get_name (self); conf_file = g_strdup_printf ("%s.conf", plugin_name); conf_path = g_build_filename (conf_dir, conf_file, NULL); if (!g_file_test (conf_path, G_FILE_TEST_IS_REGULAR)) return NULL; keyfile = g_key_file_new (); if (!g_key_file_load_from_file (keyfile, conf_path, G_KEY_FILE_NONE, NULL)) return NULL; return g_key_file_get_string (keyfile, plugin_name, key, NULL); } /** * fu_plugin_get_config_value_boolean: * @self: a #FuPlugin * @key: A settings key * * Return the boolean value of a key if it's been configured * * Returns: %TRUE if the value is `true` (case insensitive), %FALSE otherwise * * Since: 1.4.0 **/ gboolean fu_plugin_get_config_value_boolean (FuPlugin *self, const gchar *key) { g_autofree gchar *tmp = fu_plugin_get_config_value (self, key); if (tmp == NULL) return FALSE; return g_ascii_strcasecmp (tmp, "true") == 0; } /** * fu_plugin_name_compare: * @plugin1: first #FuPlugin to compare. * @plugin2: second #FuPlugin to compare. * * Compares two plugins by their names. * * Returns: 1, 0 or -1 if @plugin1 is greater, equal, or less than @plugin2. * * Since: 1.0.8 **/ gint fu_plugin_name_compare (FuPlugin *plugin1, FuPlugin *plugin2) { return g_strcmp0 (fu_plugin_get_name (plugin1), fu_plugin_get_name (plugin2)); } /** * fu_plugin_order_compare: * @plugin1: first #FuPlugin to compare. * @plugin2: second #FuPlugin to compare. * * Compares two plugins by their depsolved order. * * Returns: 1, 0 or -1 if @plugin1 is greater, equal, or less than @plugin2. * * Since: 1.0.8 **/ gint fu_plugin_order_compare (FuPlugin *plugin1, FuPlugin *plugin2) { FuPluginPrivate *priv1 = fu_plugin_get_instance_private (plugin1); FuPluginPrivate *priv2 = fu_plugin_get_instance_private (plugin2); if (priv1->order < priv2->order) return -1; if (priv1->order > priv2->order) return 1; return 0; } static void fu_plugin_class_init (FuPluginClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->finalize = fu_plugin_finalize; signals[SIGNAL_DEVICE_ADDED] = g_signal_new ("device-added", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, device_added), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, FU_TYPE_DEVICE); signals[SIGNAL_DEVICE_REMOVED] = g_signal_new ("device-removed", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, device_removed), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, FU_TYPE_DEVICE); signals[SIGNAL_DEVICE_REGISTER] = g_signal_new ("device-register", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, device_register), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, FU_TYPE_DEVICE); signals[SIGNAL_RECOLDPLUG] = g_signal_new ("recoldplug", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, recoldplug), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[SIGNAL_SECURITY_CHANGED] = g_signal_new ("security-changed", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, security_changed), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[SIGNAL_SET_COLDPLUG_DELAY] = g_signal_new ("set-coldplug-delay", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, set_coldplug_delay), NULL, NULL, g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT); signals[SIGNAL_CHECK_SUPPORTED] = g_signal_new ("check-supported", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, check_supported), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_BOOLEAN, 1, G_TYPE_STRING); signals[SIGNAL_RULES_CHANGED] = g_signal_new ("rules-changed", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, rules_changed), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[SIGNAL_ADD_FIRMWARE_GTYPE] = g_signal_new ("add-firmware-gtype", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (FuPluginClass, add_firmware_gtype), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_GTYPE); } static void fu_plugin_init (FuPlugin *self) { FuPluginPrivate *priv = GET_PRIVATE (self); g_rw_lock_init (&priv->devices_mutex); } static void fu_plugin_finalize (GObject *object) { FuPlugin *self = FU_PLUGIN (object); FuPluginPrivate *priv = GET_PRIVATE (self); FuPluginInitFunc func = NULL; g_rw_lock_clear (&priv->devices_mutex); /* optional */ if (priv->module != NULL) { g_module_symbol (priv->module, "fu_plugin_destroy", (gpointer *) &func); if (func != NULL) { g_debug ("destroy(%s)", fu_plugin_get_name (self)); func (self); } } for (guint i = 0; i < FU_PLUGIN_RULE_LAST; i++) { if (priv->rules[i] != NULL) g_ptr_array_unref (priv->rules[i]); } if (priv->usb_ctx != NULL) g_object_unref (priv->usb_ctx); if (priv->hwids != NULL) g_object_unref (priv->hwids); if (priv->quirks != NULL) g_object_unref (priv->quirks); if (priv->udev_subsystems != NULL) g_ptr_array_unref (priv->udev_subsystems); if (priv->smbios != NULL) g_object_unref (priv->smbios); if (priv->runtime_versions != NULL) g_hash_table_unref (priv->runtime_versions); if (priv->compile_versions != NULL) g_hash_table_unref (priv->compile_versions); if (priv->report_metadata != NULL) g_hash_table_unref (priv->report_metadata); if (priv->devices != NULL) g_hash_table_unref (priv->devices); g_free (priv->build_hash); g_free (priv->data); /* Must happen as the last step to avoid prematurely * freeing memory held by the plugin */ #ifdef RUNNING_ON_VALGRIND if (priv->module != NULL && RUNNING_ON_VALGRIND == 0) #else if (priv->module != NULL) #endif g_module_close (priv->module); G_OBJECT_CLASS (fu_plugin_parent_class)->finalize (object); } /** * fu_plugin_new: * * Creates a new #FuPlugin * * Since: 0.8.0 **/ FuPlugin * fu_plugin_new (void) { return FU_PLUGIN (g_object_new (FU_TYPE_PLUGIN, NULL)); }