/* * Copyright (C) 2021 Ricardo Cañuelo * * SPDX-License-Identifier: LGPL-2.1+ */ #define G_LOG_DOMAIN "FuBluezDevice" #include "config.h" #include #include "fu-bluez-device.h" #include "fu-common.h" #include "fu-device-private.h" #include "fu-firmware-common.h" #define DEFAULT_PROXY_TIMEOUT 5000 /** * FuBluezDevice: * * A BlueZ Bluetooth device. * * See also: [class@FuDevice] */ typedef struct { GDBusObjectManager *object_manager; GDBusProxy *proxy; GHashTable *uuids; /* utf8 : FuBluezDeviceUuidHelper */ } FuBluezDevicePrivate; typedef struct { FuBluezDevice *self; gchar *uuid; gchar *path; gulong signal_id; GDBusProxy *proxy; } FuBluezDeviceUuidHelper; enum { PROP_0, PROP_OBJECT_MANAGER, PROP_PROXY, PROP_LAST }; enum { SIGNAL_CHANGED, SIGNAL_LAST }; static guint signals[SIGNAL_LAST] = { 0 }; G_DEFINE_TYPE_WITH_PRIVATE (FuBluezDevice, fu_bluez_device, FU_TYPE_DEVICE) #define GET_PRIVATE(o) (fu_bluez_device_get_instance_private (o)) static void fu_bluez_uuid_free (FuBluezDeviceUuidHelper *uuid_helper) { if (uuid_helper->path != NULL) g_free (uuid_helper->path); if (uuid_helper->proxy != NULL) g_object_unref (uuid_helper->proxy); g_free (uuid_helper->uuid); g_object_unref (uuid_helper->self); g_free (uuid_helper); } /* * Looks up a UUID in the FuBluezDevice uuids table. */ static FuBluezDeviceUuidHelper * fu_bluez_device_get_uuid_helper (FuBluezDevice *self, const gchar *uuid, GError **error) { FuBluezDevicePrivate *priv = GET_PRIVATE (self); FuBluezDeviceUuidHelper *uuid_helper; uuid_helper = g_hash_table_lookup (priv->uuids, uuid); if (uuid_helper == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "UUID %s not supported", uuid); return NULL; } return uuid_helper; } static void fu_bluez_device_signal_cb (GDBusProxy *proxy, GVariant *changed_properties, GStrv invalidated_properties, FuBluezDeviceUuidHelper *uuid_helper) { g_signal_emit (uuid_helper->self, signals[SIGNAL_CHANGED], 0, uuid_helper->uuid); } /* * Builds the GDBusProxy of the BlueZ object identified by a UUID * string. If the object doesn't have a dedicated proxy yet, this * creates it and saves it in the FuBluezDeviceUuidHelper object. * * NOTE: Currently limited to GATT characteristics. */ static gboolean fu_bluez_device_ensure_uuid_helper_proxy (FuBluezDeviceUuidHelper *uuid_helper, GError **error) { if (uuid_helper->proxy != NULL) return TRUE; uuid_helper->proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, "org.bluez", uuid_helper->path, "org.bluez.GattCharacteristic1", NULL, error); if (uuid_helper->proxy == NULL) { g_prefix_error (error, "Failed to create GDBusProxy for uuid_helper: "); return FALSE; } g_dbus_proxy_set_default_timeout (uuid_helper->proxy, DEFAULT_PROXY_TIMEOUT); uuid_helper->signal_id = g_signal_connect (uuid_helper->proxy, "g-properties-changed", G_CALLBACK (fu_bluez_device_signal_cb), uuid_helper); if (uuid_helper->signal_id <= 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "cannot connect to signal of UUID %s", uuid_helper->uuid); return FALSE; } return TRUE; } static void fu_bluez_device_add_uuid_path (FuBluezDevice *self, const gchar *uuid, const gchar *path) { FuBluezDevicePrivate *priv = GET_PRIVATE (self); FuBluezDeviceUuidHelper *uuid_helper; g_return_if_fail (FU_IS_BLUEZ_DEVICE (self)); g_return_if_fail (uuid != NULL); g_return_if_fail (path != NULL); uuid_helper = g_new0 (FuBluezDeviceUuidHelper, 1); uuid_helper->self = g_object_ref (self); uuid_helper->uuid = g_strdup (uuid); uuid_helper->path = g_strdup (path); g_hash_table_insert (priv->uuids, g_strdup (uuid), uuid_helper); } static void fu_bluez_device_set_modalias (FuBluezDevice *self, const gchar *modalias) { gsize modaliaslen = strlen (modalias); guint16 vid = 0x0; guint16 pid = 0x0; guint16 rev = 0x0; g_return_if_fail (modalias != NULL); /* usb:v0461p4EEFd0001 */ if (g_str_has_prefix (modalias, "usb:")) { fu_firmware_strparse_uint16_safe (modalias, modaliaslen, 5, &vid, NULL); fu_firmware_strparse_uint16_safe (modalias, modaliaslen, 10, &pid, NULL); fu_firmware_strparse_uint16_safe (modalias, modaliaslen, 15, &rev, NULL); /* bluetooth:v000ApFFFFdFFFF */ } else if (g_str_has_prefix (modalias, "bluetooth:")) { fu_firmware_strparse_uint16_safe (modalias, modaliaslen, 11, &vid, NULL); fu_firmware_strparse_uint16_safe (modalias, modaliaslen, 16, &pid, NULL); fu_firmware_strparse_uint16_safe (modalias, modaliaslen, 21, &rev, NULL); } if (vid != 0x0 && pid != 0x0 && rev != 0x0) { g_autofree gchar *devid = NULL; devid = g_strdup_printf ("BLUETOOTH\\VID_%04X&PID_%04X&REV_%04X", vid, pid, rev); fu_device_add_instance_id (FU_DEVICE (self), devid); } if (vid != 0x0 && pid != 0x0) { g_autofree gchar *devid = NULL; devid = g_strdup_printf ("BLUETOOTH\\VID_%04X&PID_%04X", vid, pid); fu_device_add_instance_id (FU_DEVICE (self), devid); } if (vid != 0x0) { g_autofree gchar *devid = NULL; g_autofree gchar *vendor_id = NULL; devid = g_strdup_printf ("BLUETOOTH\\VID_%04X", vid); fu_device_add_instance_id_full (FU_DEVICE (self), devid, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); vendor_id = g_strdup_printf ("BLUETOOTH:%04X", vid); fu_device_add_vendor_id (FU_DEVICE (self), vendor_id); } } static void fu_bluez_device_to_string (FuDevice *device, guint idt, GString *str) { FuBluezDevice *self = FU_BLUEZ_DEVICE (device); FuBluezDevicePrivate *priv = GET_PRIVATE (self); if (priv->uuids != NULL) { GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, priv->uuids); while (g_hash_table_iter_next (&iter, &key, &value)) { FuBluezDeviceUuidHelper *uuid_helper = (FuBluezDeviceUuidHelper *) value; fu_common_string_append_kv (str, idt + 1, (const gchar *) key, uuid_helper->path); } } } /* * Returns the value of a property of an object specified by its path as * a GVariant, or NULL if the property wasn't found. */ static GVariant * fu_bluez_device_get_ble_property (const gchar *obj_path, const gchar *iface, const gchar *prop_name, GError **error) { g_autoptr(GDBusProxy) proxy = NULL; g_autoptr(GVariant) val = NULL; proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, "org.bluez", obj_path, iface, NULL, error); if (proxy == NULL) { g_prefix_error (error, "failed to connect to %s: ", iface); return NULL; } g_dbus_proxy_set_default_timeout (proxy, DEFAULT_PROXY_TIMEOUT); val = g_dbus_proxy_get_cached_property (proxy, prop_name); if (val == NULL) { g_prefix_error (error, "property %s not found in %s: ", prop_name, obj_path); return NULL; } return g_steal_pointer (&val); } /* * Returns the value of the string property of an object specified by * its path, or NULL if the property wasn't found. * * The returned string must be freed using g_free(). */ static gchar * fu_bluez_device_get_ble_string_property (const gchar *obj_path, const gchar *iface, const gchar *prop_name, GError **error) { g_autoptr(GVariant) val = NULL; val = fu_bluez_device_get_ble_property (obj_path, iface, prop_name, error); if (val == NULL) return NULL; return g_variant_dup_string (val, NULL); } /* * Populates the {uuid_helper : object_path} entries of a device for all its * characteristics. * * TODO: Extend to services and descriptors too? */ static void fu_bluez_device_add_device_uuids (FuBluezDevice *self) { FuBluezDevicePrivate *priv = GET_PRIVATE (self); g_autolist(GDBusObject) obj_list = NULL; obj_list = g_dbus_object_manager_get_objects (priv->object_manager); for (GList *l = obj_list; l != NULL; l = l->next) { GDBusObject *obj = G_DBUS_OBJECT (l->data); g_autoptr(GDBusInterface) iface = NULL; g_autoptr(GError) error_local = NULL; g_autofree gchar *obj_uuid = NULL; const gchar *obj_path = g_dbus_object_get_object_path (obj); /* not us */ if (!g_str_has_prefix (g_dbus_object_get_object_path (obj), g_dbus_proxy_get_object_path (priv->proxy))) continue; /* * TODO: Currently restricted to getting UUIDs for * characteristics only, as the only use case we're * going to need for now is reading/writing * characteristics. */ iface = g_dbus_object_get_interface (obj, "org.bluez.GattCharacteristic1"); if (iface == NULL) continue; obj_uuid = fu_bluez_device_get_ble_string_property (obj_path, "org.bluez.GattCharacteristic1", "UUID", &error_local); if (obj_uuid == NULL) { g_debug ("failed to get property: %s", error_local->message); continue; } fu_bluez_device_add_uuid_path (self, obj_uuid, obj_path); } } static gboolean fu_bluez_device_setup (FuDevice *device, GError **error) { FuBluezDevice *self = FU_BLUEZ_DEVICE (device); fu_bluez_device_add_device_uuids (self); return TRUE; } static gboolean fu_bluez_device_probe (FuDevice *device, GError **error) { FuBluezDevice *self = FU_BLUEZ_DEVICE (device); FuBluezDevicePrivate *priv = GET_PRIVATE (self); g_autoptr(GVariant) val_adapter = NULL; g_autoptr(GVariant) val_address = NULL; g_autoptr(GVariant) val_icon = NULL; g_autoptr(GVariant) val_modalias = NULL; g_autoptr(GVariant) val_name = NULL; val_address = g_dbus_proxy_get_cached_property (priv->proxy, "Address"); if (val_address == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "No required BLE address"); return FALSE; } fu_device_set_logical_id (device, g_variant_get_string (val_address, NULL)); val_adapter = g_dbus_proxy_get_cached_property (priv->proxy, "Adapter"); if (val_adapter != NULL) fu_device_set_physical_id (device, g_variant_get_string (val_adapter, NULL)); val_name = g_dbus_proxy_get_cached_property (priv->proxy, "Name"); if (val_name != NULL) fu_device_set_name (device, g_variant_get_string (val_name, NULL)); val_icon = g_dbus_proxy_get_cached_property (priv->proxy, "Icon"); if (val_icon != NULL) fu_device_add_icon (device, g_variant_get_string (val_name, NULL)); val_modalias = g_dbus_proxy_get_cached_property (priv->proxy, "Modalias"); if (val_modalias != NULL) fu_bluez_device_set_modalias (self, g_variant_get_string (val_modalias, NULL)); /* success */ return TRUE; } /** * fu_bluez_device_read: * @self: a #FuBluezDevice * @uuid: the UUID, e.g. `00cde35c-7062-11eb-9439-0242ac130002` * @error: (nullable): optional return location for an error * * Reads from a UUID on the device. * * Returns: (transfer full): data, or %NULL for error * * Since: 1.5.7 **/ GByteArray * fu_bluez_device_read (FuBluezDevice *self, const gchar *uuid, GError **error) { FuBluezDeviceUuidHelper *uuid_helper; guint8 byte; g_autoptr(GByteArray) buf = g_byte_array_new (); g_autoptr(GVariantBuilder) builder = NULL; g_autoptr(GVariantIter) iter = NULL; g_autoptr(GVariant) val = NULL; uuid_helper = fu_bluez_device_get_uuid_helper (self, uuid, error); if (uuid_helper == NULL) return NULL; if (!fu_bluez_device_ensure_uuid_helper_proxy (uuid_helper, error)) return NULL; /* * Call the "ReadValue" method through the proxy synchronously. * * The method takes one argument: an array of dicts of * {string:value} specifying the options (here the option is * "offset":0. * The result is a byte array. */ builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (builder, "{sv}", "offset", g_variant_new("q", 0)); val = g_dbus_proxy_call_sync (uuid_helper->proxy, "ReadValue", g_variant_new ("(a{sv})", builder), G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); if (val == NULL) { g_prefix_error (error, "Failed to read GattCharacteristic1: "); return NULL; } g_variant_get(val, "(ay)", &iter); while (g_variant_iter_loop (iter, "y", &byte)) g_byte_array_append (buf, &byte, 1); /* success */ return g_steal_pointer (&buf); } /** * fu_bluez_device_read_string: * @self: a #FuBluezDevice * @uuid: the UUID, e.g. `00cde35c-7062-11eb-9439-0242ac130002` * @error: (nullable): optional return location for an error * * Reads a string from a UUID on the device. * * Returns: (transfer full): data, or %NULL for error * * Since: 1.5.7 **/ gchar * fu_bluez_device_read_string (FuBluezDevice *self, const gchar *uuid, GError **error) { GByteArray *buf = fu_bluez_device_read (self, uuid, error); if (buf == NULL) return NULL; return (gchar *) g_byte_array_free (buf, FALSE); } /** * fu_bluez_device_write: * @self: a #FuBluezDevice * @uuid: the UUID, e.g. `00cde35c-7062-11eb-9439-0242ac130002` * @buf: data array * @error: (nullable): optional return location for an error * * Writes to a UUID on the device. * * Returns: %TRUE if all the data was written * * Since: 1.5.7 **/ gboolean fu_bluez_device_write (FuBluezDevice *self, const gchar *uuid, GByteArray *buf, GError **error) { FuBluezDeviceUuidHelper *uuid_helper; g_autoptr(GVariantBuilder) opt_builder = NULL; g_autoptr(GVariantBuilder) val_builder = NULL; g_autoptr(GVariant) ret = NULL; GVariant *opt_variant = NULL; GVariant *val_variant = NULL; uuid_helper = fu_bluez_device_get_uuid_helper (self, uuid, error); if (uuid_helper == NULL) return FALSE; if (!fu_bluez_device_ensure_uuid_helper_proxy (uuid_helper, error)) return FALSE; /* build the value variant */ val_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay")); for (gsize i = 0; i < buf->len; i++) g_variant_builder_add (val_builder, "y", buf->data[i]); val_variant = g_variant_new ("ay", val_builder); /* build the options variant (offset = 0) */ opt_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); g_variant_builder_add (opt_builder, "{sv}", "offset", g_variant_new_uint16 (0)); opt_variant = g_variant_new("a{sv}", opt_builder); ret = g_dbus_proxy_call_sync (uuid_helper->proxy, "WriteValue", g_variant_new ("(@ay@a{sv})", val_variant, opt_variant), G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); if (ret == NULL) { g_prefix_error (error, "Failed to write GattCharacteristic1: "); return FALSE; } /* success */ return TRUE; } /** * fu_bluez_device_notify_start: * @self: a #FuBluezDevice * @uuid: the UUID, e.g. `00cde35c-7062-11eb-9439-0242ac130002` * @error: (nullable): optional return location for an error * * Enables notifications for property changes in a UUID (StartNotify * method). * * Returns: %TRUE if the method call completed successfully. * * Since: 1.5.8 **/ gboolean fu_bluez_device_notify_start (FuBluezDevice *self, const gchar *uuid, GError **error) { FuBluezDeviceUuidHelper *uuid_helper; g_autoptr(GVariant) retval = NULL; uuid_helper = fu_bluez_device_get_uuid_helper (self, uuid, error); if (uuid_helper == NULL) return FALSE; if (!fu_bluez_device_ensure_uuid_helper_proxy (uuid_helper, error)) return FALSE; retval = g_dbus_proxy_call_sync (uuid_helper->proxy, "StartNotify", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); if (retval == NULL) { g_prefix_error (error, "Failed to enable notifications: "); return FALSE; } return TRUE; } /** * fu_bluez_device_notify_stop: * @self: a #FuBluezDevice * @uuid: the UUID, e.g. `00cde35c-7062-11eb-9439-0242ac130002` * @error: (nullable): optional return location for an error * * Disables notifications for property changes in a UUID (StopNotify * method). * * Returns: %TRUE if the method call completed successfully. * * Since: 1.5.8 **/ gboolean fu_bluez_device_notify_stop (FuBluezDevice *self, const gchar *uuid, GError **error) { FuBluezDeviceUuidHelper *uuid_helper; g_autoptr(GVariant) retval = NULL; uuid_helper = fu_bluez_device_get_uuid_helper (self, uuid, error); if (uuid_helper == NULL) return FALSE; if (!fu_bluez_device_ensure_uuid_helper_proxy (uuid_helper, error)) return FALSE; retval = g_dbus_proxy_call_sync (uuid_helper->proxy, "StopNotify", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); if (retval == NULL) { g_prefix_error (error, "Failed to enable notifications: "); return FALSE; } return TRUE; } static void fu_bluez_device_incorporate (FuDevice *self, FuDevice *donor) { FuBluezDevice *uself = FU_BLUEZ_DEVICE (self); FuBluezDevice *udonor = FU_BLUEZ_DEVICE (donor); FuBluezDevicePrivate *priv = GET_PRIVATE (uself); FuBluezDevicePrivate *privdonor = GET_PRIVATE (udonor); if (g_hash_table_size (priv->uuids) == 0) { GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, privdonor->uuids); while (g_hash_table_iter_next (&iter, &key, &value)) { FuBluezDeviceUuidHelper *uuid_helper = (FuBluezDeviceUuidHelper *) value; fu_bluez_device_add_uuid_path (uself, (const gchar *) key, uuid_helper->path); } } if (priv->object_manager == NULL) priv->object_manager = g_object_ref (privdonor->object_manager); if (priv->proxy == NULL) priv->proxy = g_object_ref (privdonor->proxy); } static void fu_bluez_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { FuBluezDevice *self = FU_BLUEZ_DEVICE (object); FuBluezDevicePrivate *priv = GET_PRIVATE (self); switch (prop_id) { case PROP_OBJECT_MANAGER: g_value_set_object (value, priv->object_manager); break; case PROP_PROXY: g_value_set_object (value, priv->proxy); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void fu_bluez_device_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { FuBluezDevice *self = FU_BLUEZ_DEVICE (object); FuBluezDevicePrivate *priv = GET_PRIVATE (self); switch (prop_id) { case PROP_OBJECT_MANAGER: priv->object_manager = g_value_dup_object (value); break; case PROP_PROXY: priv->proxy = g_value_dup_object (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void fu_bluez_device_finalize (GObject *object) { FuBluezDevice *self = FU_BLUEZ_DEVICE (object); FuBluezDevicePrivate *priv = GET_PRIVATE (self); g_hash_table_unref (priv->uuids); g_object_unref (priv->proxy); g_object_unref (priv->object_manager); G_OBJECT_CLASS (fu_bluez_device_parent_class)->finalize (object); } static void fu_bluez_device_init (FuBluezDevice *self) { FuBluezDevicePrivate *priv = GET_PRIVATE (self); priv->uuids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) fu_bluez_uuid_free); } static void fu_bluez_device_class_init (FuBluezDeviceClass *klass) { FuDeviceClass *device_class = FU_DEVICE_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass); GParamSpec *pspec; object_class->get_property = fu_bluez_device_get_property; object_class->set_property = fu_bluez_device_set_property; object_class->finalize = fu_bluez_device_finalize; device_class->probe = fu_bluez_device_probe; device_class->setup = fu_bluez_device_setup; device_class->to_string = fu_bluez_device_to_string; device_class->incorporate = fu_bluez_device_incorporate; signals[SIGNAL_CHANGED] = g_signal_new ("changed", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); pspec = g_param_spec_object ("object-manager", NULL, NULL, G_TYPE_DBUS_OBJECT_MANAGER, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_NAME); g_object_class_install_property (object_class, PROP_OBJECT_MANAGER, pspec); pspec = g_param_spec_object ("proxy", NULL, NULL, G_TYPE_DBUS_PROXY, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_NAME); g_object_class_install_property (object_class, PROP_PROXY, pspec); }