/**
* fu_provider_udev_coldplug:
**/
static gboolean
fu_provider_udev_coldplug (FuProvider *provider, GError **error)
{
FuProviderUdev *provider_udev = FU_PROVIDER_UDEV (provider);
FuProviderUdevPrivate *priv = GET_PRIVATE (provider_udev);
GList *devices;
GList *l;
GUdevDevice *udev_device;
const gchar *devclass[] = { "usb", "pci", NULL };
guint i;
g_autoptr(AsProfile) profile = as_profile_new ();
/* get all devices of class */
for (i = 0; devclass[i] != NULL; i++) {
g_autoptr(AsProfileTask) ptask = NULL;
ptask = as_profile_start (profile, "FuProviderUdev:coldplug{%s}", devclass[i]);
devices = g_udev_client_query_by_subsystem (priv->gudev_client,
devclass[i]);
for (l = devices; l != NULL; l = l->next) {
udev_device = l->data;
fu_provider_udev_client_add (provider_udev, udev_device);
}
g_list_foreach (devices, (GFunc) g_object_unref, NULL);
g_list_free (devices);
}
return TRUE;
}
/**
* gs_plugin_xdg_app_refine_app:
*/
static gboolean
gs_plugin_xdg_app_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
g_autoptr(AsProfileTask) ptask = NULL;
/* only process this app if was created by this plugin */
if (g_strcmp0 (gs_app_get_management_plugin (app),
gs_plugin_get_name (plugin)) != 0)
return TRUE;
/* profile */
ptask = as_profile_start (gs_plugin_get_profile (plugin),
"xdg-app::refine{%s}",
gs_app_get_id (app));
/* AppStream sets the source to appname/arch/branch */
if (!gs_plugin_refine_item_metadata (plugin, app, cancellable, error))
return FALSE;
/* check the installed state */
if (!gs_plugin_refine_item_state (plugin, app, cancellable, error))
return FALSE;
/* version fallback */
if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_VERSION) {
if (gs_app_get_version (app) == NULL) {
const gchar *branch;
branch = gs_app_get_xdgapp_branch (app);
gs_app_set_version (app, branch);
}
}
/* size */
if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SIZE) {
if (!gs_plugin_refine_item_size (plugin, app, cancellable, error))
return FALSE;
}
/* origin */
if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN) {
if (!gs_plugin_refine_item_origin_ui (plugin, app, cancellable, error))
return FALSE;
}
return TRUE;
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
LiPkgInfo *pki;
g_autoptr(GError) error_local = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
/* not us */
if (g_strcmp0 (gs_app_get_management_plugin (app),
gs_plugin_get_name (plugin)) != 0)
return TRUE;
/* profile */
ptask = as_profile_start (gs_plugin_get_profile (plugin),
"limba::refine{%s}",
gs_app_get_id (app));
/* sanity check */
if (gs_app_get_source_default (app) == NULL)
return TRUE;
pki = li_manager_get_software_by_pkid (priv->mgr,
gs_app_get_source_default (app),
&error_local);
if (error_local != NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Unable to refine metadata: %s",
error_local->message);
return FALSE;
}
if (pki == NULL)
return TRUE;
if (li_pkg_info_has_flag (pki, LI_PACKAGE_FLAG_INSTALLED))
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
else
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
gs_app_set_version (app, li_pkg_info_get_version (pki));
return TRUE;
}
/**
* fu_provider_udev_client_add:
**/
static void
fu_provider_udev_client_add (FuProviderUdev *provider_udev, GUdevDevice *device)
{
FuProviderUdevPrivate *priv = GET_PRIVATE (provider_udev);
FuDevice *dev;
const gchar *display_name;
const gchar *guid;
const gchar *product;
const gchar *vendor;
g_autofree gchar *guid_new = NULL;
g_autofree gchar *id = NULL;
g_autofree gchar *rom_fn = NULL;
g_autofree gchar *version = NULL;
g_auto(GStrv) split = NULL;
g_autoptr(AsProfile) profile = as_profile_new ();
g_autoptr(AsProfileTask) ptask = NULL;
/* interesting device? */
guid = g_udev_device_get_property (device, "FWUPD_GUID");
if (guid == NULL)
return;
/* get data */
ptask = as_profile_start (profile, "FuProviderUdev:client-add{%s}", guid);
g_debug ("adding udev device: %s", g_udev_device_get_sysfs_path (device));
/* is already in database */
id = fu_provider_udev_get_id (device);
dev = g_hash_table_lookup (priv->devices, id);
if (dev != NULL) {
g_debug ("ignoring duplicate %s", id);
return;
}
/* get the FW version from the BCD device revision */
product = g_udev_device_get_property (device, "PRODUCT");
if (product != NULL) {
split = g_strsplit (product, "/", -1);
if (g_strv_length (split) != 3) {
g_warning ("env{PRODUCT} is invalid: %s", product);
return;
}
version = g_strdup (split[2]);
}
/* no GUID from the ROM, so fix up the VID:PID */
if (!as_utils_guid_is_valid (guid)) {
guid_new = as_utils_guid_from_string (guid);
g_debug ("fixing GUID %s->%s", guid, guid_new);
} else {
guid_new = g_strdup (guid);
}
/* did we get enough data */
dev = fu_device_new ();
fu_device_add_flag (dev, FU_DEVICE_FLAG_INTERNAL);
fu_device_set_id (dev, id);
fu_device_set_guid (dev, guid_new);
display_name = g_udev_device_get_property (device, "FWUPD_MODEL");
if (display_name == NULL)
display_name = g_udev_device_get_property (device, "ID_MODEL_FROM_DATABASE");
if (display_name != NULL)
fu_device_set_name (dev, display_name);
vendor = g_udev_device_get_property (device, "FWUPD_VENDOR");
if (vendor == NULL)
vendor = g_udev_device_get_property (device, "ID_VENDOR_FROM_DATABASE");
if (vendor != NULL)
fu_device_set_vendor (dev, vendor);
if (version != NULL)
fu_device_set_version (dev, version);
/* get the FW version from the rom when unlocked */
rom_fn = g_build_filename (g_udev_device_get_sysfs_path (device), "rom", NULL);
if (g_file_test (rom_fn, G_FILE_TEST_EXISTS)) {
fu_device_set_metadata (dev, "RomFilename", rom_fn);
fu_device_add_flag (dev, FU_DEVICE_FLAG_LOCKED);
}
/* insert to hash */
g_hash_table_insert (priv->devices, g_strdup (id), dev);
fu_provider_device_add (FU_PROVIDER (provider_udev), dev);
}
