static void update_block (StoragedLinuxBlockObject *block_object, StoragedLinuxVolumeGroupObject *group_object, GHashTable *new_lvs, GHashTable *new_pvs) { StoragedBlock *block; GVariant *pv_info; block = storaged_object_peek_block (STORAGED_OBJECT (block_object)); if (block == NULL) return; // XXX - move this elsewhere? { StoragedLinuxDevice *device; StoragedLinuxLogicalVolumeObject *lv_object; const gchar *block_vg_name; const gchar *block_lv_name; device = storaged_linux_block_object_get_device (block_object); if (device) { block_vg_name = g_udev_device_get_property (device->udev_device, "DM_VG_NAME"); block_lv_name = g_udev_device_get_property (device->udev_device, "DM_LV_NAME"); if (g_strcmp0 (block_vg_name, storaged_linux_volume_group_object_get_name (group_object)) == 0 && (lv_object = g_hash_table_lookup (new_lvs, block_lv_name))) { block_object_update_lvm_iface (block_object, g_dbus_object_get_object_path (G_DBUS_OBJECT (lv_object))); } } } pv_info = g_hash_table_lookup (new_pvs, storaged_block_get_device (block)); if (!pv_info) { const gchar *const *symlinks; int i; symlinks = storaged_block_get_symlinks (block); for (i = 0; symlinks[i]; i++) { pv_info = g_hash_table_lookup (new_pvs, symlinks[i]); if (pv_info) break; } } if (pv_info) { storaged_linux_block_object_update_lvm_pv (block_object, group_object, pv_info); } else { StoragedPhysicalVolume *pv = storaged_object_peek_physical_volume (STORAGED_OBJECT (block_object)); if (pv && g_strcmp0 (storaged_physical_volume_get_volume_group (pv), g_dbus_object_get_object_path (G_DBUS_OBJECT (group_object))) == 0) storaged_linux_block_object_update_lvm_pv (block_object, NULL, NULL); } }
static void handle_block_uevent_for_mdraid (UDisksLinuxProvider *provider, const gchar *action, UDisksLinuxDevice *device) { const gchar *uuid; const gchar *member_uuid; /* For nested RAID levels, a device can be both a member of one * array and the RAID device for another. Therefore we need to * consider both UUIDs. * * For removal, we also need to consider the case where there is no * UUID. */ uuid = g_udev_device_get_property (device->udev_device, "UDISKS_MD_UUID"); member_uuid = g_udev_device_get_property (device->udev_device, "UDISKS_MD_MEMBER_UUID"); if (uuid != NULL) handle_block_uevent_for_mdraid_with_uuid (provider, action, device, uuid, FALSE); if (member_uuid != NULL) handle_block_uevent_for_mdraid_with_uuid (provider, action, device, member_uuid, TRUE); if (uuid == NULL && member_uuid == NULL) handle_block_uevent_for_mdraid_with_uuid (provider, action, device, NULL, FALSE); }
/** * cd_sensor_client_add: **/ static gboolean cd_sensor_client_add (CdSensorClient *sensor_client, GUdevDevice *device) { CdSensor *sensor = NULL; const gchar *device_file; const gchar *tmp; gboolean ret = FALSE; GError *error = NULL; /* interesting device? */ tmp = g_udev_device_get_property (device, "COLORD_SENSOR_KIND"); if (tmp == NULL) goto out; tmp = g_udev_device_get_property (device, "COLORD_IGNORE"); if (tmp != NULL) goto out; /* actual device? */ device_file = g_udev_device_get_device_file (device); if (device_file == NULL) goto out; /* get data */ g_debug ("adding color management device: %s [%s]", g_udev_device_get_sysfs_path (device), device_file); sensor = cd_sensor_new (); ret = cd_sensor_set_from_device (sensor, device, &error); if (!ret) { g_warning ("CdSensorClient: failed to set CM sensor: %s", error->message); g_error_free (error); goto out; } /* set the index */ cd_sensor_set_index (sensor, sensor_client->priv->idx); /* load the sensor */ ret = cd_sensor_load (sensor, &error); if (!ret) { /* not fatal, non-native devices are still useable */ g_debug ("CdSensorClient: failed to load native sensor: %s", error->message); g_clear_error (&error); } /* signal the addition */ g_debug ("emit: added"); g_signal_emit (sensor_client, signals[SIGNAL_SENSOR_ADDED], 0, sensor); sensor_client->priv->idx++; /* keep track so we can remove with the same device */ g_ptr_array_add (sensor_client->priv->array_sensors, g_object_ref (sensor)); out: if (sensor != NULL) g_object_unref (sensor); return ret; }
static gchar * check_for_vpd (GUdevDevice *device) { gchar *ret = NULL; const gchar *serial; const gchar *wwn; const gchar *path; g_return_val_if_fail (G_UDEV_IS_DEVICE (device), FALSE); /* order of preference: WWN_serial, WWN, serial, path */ serial = g_udev_device_get_property (device, "ID_SERIAL"); wwn = g_udev_device_get_property (device, "ID_WWN_WITH_EXTENSION"); path = g_udev_device_get_property (device, "ID_PATH"); if (wwn != NULL && strlen (wwn) > 0 && !is_wwn_black_listed (wwn)) { if (serial != NULL && strlen (serial) > 0) ret = g_strdup_printf ("%s_%s", wwn, serial); else ret = g_strdup (wwn); } else if (serial != NULL && strlen (serial) > 0) { ret = g_strdup (serial); } else if (path != NULL && strlen (path) > 0) { ret = g_strdup (path); } return ret; }
static gboolean input_accel_open (GUdevDevice *device, ReadingsUpdateFunc callback_func, gpointer user_data) { const gchar * const subsystems[] = { "input", NULL }; const char *mount_matrix; drv_data = g_new0 (DrvData, 1); drv_data->dev = g_object_ref (device); drv_data->parent = g_udev_device_get_parent (drv_data->dev); drv_data->dev_path = g_udev_device_get_device_file (device); drv_data->name = g_udev_device_get_property (device, "NAME"); drv_data->client = g_udev_client_new (subsystems); mount_matrix = g_udev_device_get_property (device, "ACCEL_MOUNT_MATRIX"); if (!parse_mount_matrix (mount_matrix, &drv_data->mount_matrix)) { g_warning ("Invalid mount-matrix ('%s'), falling back to identity", mount_matrix); parse_mount_matrix (NULL, &drv_data->mount_matrix); } drv_data->callback_func = callback_func; drv_data->user_data = user_data; g_signal_connect (drv_data->client, "uevent", G_CALLBACK (uevent_received), NULL); g_idle_add (first_values, NULL); return TRUE; }
char * g_vfs_get_volume_name (GUdevDevice *device, const char *device_id) { const char *gphoto_name; const char *product = NULL; const char *vendor; const char *model; /* our preference: device_id > ID_MEDIA_PLAYER_{VENDOR,PRODUCT} > product > * ID_{VENDOR,MODEL} */ gphoto_name = g_udev_device_get_property (device, device_id); if (gphoto_name != NULL && strcmp (gphoto_name, "1") != 0) return g_strdup (gphoto_name); vendor = g_udev_device_get_property (device, "ID_MEDIA_PLAYER_VENDOR"); if (vendor == NULL) vendor = g_udev_device_get_property (device, "ID_VENDOR_ENC"); model = g_udev_device_get_property (device, "ID_MEDIA_PLAYER_MODEL"); if (model == NULL) { model = g_udev_device_get_property (device, "ID_MODEL_ENC"); product = g_udev_device_get_sysfs_attr (device, "product"); } if (product != NULL && strlen (product) > 0) return g_strdup (udev_decode_string (product)); else if (vendor == NULL) { if (model != NULL) return g_strdup (udev_decode_string (model)); } else { if (model != NULL) { /* we can't call udev_decode_string() twice in one g_strdup_printf(), * it returns a static buffer */ gchar *temp = g_strconcat (vendor, " ", model, NULL); gchar *name = g_strdup (udev_decode_string (temp)); g_free (temp); return name; } else { if (g_udev_device_has_property (device, "ID_MEDIA_PLAYER")) { /* Translators: %s is the device vendor */ return g_strdup_printf (_("%s Audio Player"), udev_decode_string (vendor)); } else { /* Translators: %s is the device vendor */ return g_strdup_printf (_("%s Camera"), udev_decode_string (vendor)); } } } return g_strdup (_("Camera")); }
gboolean mm_plugin_base_get_device_ids (MMPluginBase *self, const char *subsys, const char *name, guint16 *vendor, guint16 *product) { MMPluginBasePrivate *priv; GUdevDevice *device = NULL; const char *vid, *pid; gboolean success = FALSE; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (MM_IS_PLUGIN_BASE (self), FALSE); g_return_val_if_fail (subsys != NULL, FALSE); g_return_val_if_fail (name != NULL, FALSE); if (vendor) g_return_val_if_fail (*vendor == 0, FALSE); if (product) g_return_val_if_fail (*product == 0, FALSE); priv = MM_PLUGIN_BASE_GET_PRIVATE (self); device = g_udev_client_query_by_subsystem_and_name (priv->client, subsys, name); if (!device) goto out; vid = g_udev_device_get_property (device, "ID_VENDOR_ID"); if (!vid || (strlen (vid) != 4)) goto out; if (vendor) { *vendor = (guint16) (hex2byte (vid + 2) & 0xFF); *vendor |= (guint16) ((hex2byte (vid) & 0xFF) << 8); } pid = g_udev_device_get_property (device, "ID_MODEL_ID"); if (!pid || (strlen (pid) != 4)) { *vendor = 0; goto out; } if (product) { *product = (guint16) (hex2byte (pid + 2) & 0xFF); *product |= (guint16) ((hex2byte (pid) & 0xFF) << 8); } success = TRUE; out: if (device) g_object_unref (device); return success; }
void storage_volume_group_update_block (StorageVolumeGroup *self, StorageBlock *block) { GUdevDevice *device; StorageLogicalVolume *volume; const gchar *block_vg_name; const gchar *block_lv_name; GVariant *pv_info; device = storage_block_get_udev (block); if (device) { block_vg_name = g_udev_device_get_property (device, "DM_VG_NAME"); block_lv_name = g_udev_device_get_property (device, "DM_LV_NAME"); if (g_strcmp0 (block_vg_name, storage_volume_group_get_name (self)) == 0) { volume = g_hash_table_lookup (self->logical_volumes, block_lv_name); storage_block_update_lv (block, volume); } g_object_unref (device); } pv_info = g_hash_table_lookup (self->physical_volumes, storage_block_get_device (block)); if (!pv_info) { const gchar *const *symlinks; int i; symlinks = storage_block_get_symlinks (block); for (i = 0; symlinks[i]; i++) { pv_info = g_hash_table_lookup (self->physical_volumes, symlinks[i]); if (pv_info) break; } } if (pv_info) { storage_block_update_pv (block, self, pv_info); } else { LvmPhysicalVolumeBlock *pv = storage_block_get_physical_volume_block (block); if (pv && g_strcmp0 (lvm_physical_volume_block_get_volume_group (pv), storage_volume_group_get_object_path (self)) == 0) storage_block_update_pv (block, NULL, NULL); } }
static void empathy_camera_device_monitor_removed (EmpathyCameraDeviceMonitor *monitor, GUdevDevice *udevice) { g_signal_emit (monitor, monitor_signals[REMOVED], 0, g_udev_device_get_property (udevice, "DEVPATH")); }
static void impl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { RBAndroidSourcePrivate *priv = GET_PRIVATE (object); switch (prop_id) { case PROP_IGNORE_ENTRY_TYPE: g_value_set_object (value, priv->ignore_type); break; case PROP_ERROR_ENTRY_TYPE: g_value_set_object (value, priv->error_type); break; case PROP_DEVICE_INFO: g_value_set_object (value, priv->device_info); break; case PROP_MOUNT: g_value_set_object (value, priv->mount); break; case PROP_GUDEV_DEVICE: g_value_set_object (value, priv->gudev_device); break; case PROP_DEVICE_SERIAL: g_value_set_string (value, g_udev_device_get_property (priv->gudev_device, "ID_SERIAL")); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static char * get_decoded_property (GUdevDevice *device, const char *property) { const char *orig, *p; char *unescaped, *n; guint len; p = orig = g_udev_device_get_property (device, property); if (!orig) return NULL; len = strlen (orig); n = unescaped = g_malloc0 (len + 1); while (*p) { if ((len >= 4) && (*p == '\\') && (*(p+1) == 'x')) { *n++ = (char) hex2byte (p + 2); p += 4; len -= 4; } else { *n++ = *p++; len--; } } return unescaped; }
static gboolean iio_buffer_light_open (GUdevDevice *device, ReadingsUpdateFunc callback_func, gpointer user_data) { char *trigger_name; drv_data = g_new0 (DrvData, 1); /* Get the trigger name, and build the channels from that */ trigger_name = get_trigger_name (device); if (!trigger_name) { g_clear_pointer (&drv_data, g_free); return FALSE; } drv_data->buffer_data = buffer_drv_data_new (device, trigger_name); g_free (trigger_name); if (!drv_data->buffer_data) { g_clear_pointer (&drv_data, g_free); return FALSE; } drv_data->dev = g_object_ref (device); drv_data->dev_path = g_udev_device_get_device_file (device); drv_data->name = g_udev_device_get_property (device, "NAME"); if (!drv_data->name) drv_data->name = g_udev_device_get_name (device); drv_data->callback_func = callback_func; drv_data->user_data = user_data; return TRUE; }
static Killswitch * killswitch_new (GUdevDevice *device, RfKillType rtype) { Killswitch *ks; GUdevDevice *parent = NULL, *grandparent = NULL; const char *driver, *subsys, *parent_subsys = NULL; ks = g_malloc0 (sizeof (Killswitch)); ks->name = g_strdup (g_udev_device_get_name (device)); ks->seqnum = g_udev_device_get_seqnum (device); ks->path = g_strdup (g_udev_device_get_sysfs_path (device)); ks->rtype = rtype; driver = g_udev_device_get_property (device, "DRIVER"); subsys = g_udev_device_get_subsystem (device); /* Check parent for various attributes */ parent = g_udev_device_get_parent (device); if (parent) { parent_subsys = g_udev_device_get_subsystem (parent); if (!driver) driver = g_udev_device_get_property (parent, "DRIVER"); if (!driver) { /* Sigh; try the grandparent */ grandparent = g_udev_device_get_parent (parent); if (grandparent) driver = g_udev_device_get_property (grandparent, "DRIVER"); } } if (!driver) driver = "(unknown)"; ks->driver = g_strdup (driver); if ( g_strcmp0 (subsys, "platform") == 0 || g_strcmp0 (parent_subsys, "platform") == 0 || g_strcmp0 (subsys, "acpi") == 0 || g_strcmp0 (parent_subsys, "acpi") == 0) ks->platform = TRUE; if (grandparent) g_object_unref (grandparent); if (parent) g_object_unref (parent); return ks; }
static gboolean hwmon_light_discover (GUdevDevice *device) { if (g_strcmp0 (g_udev_device_get_property (device, "IIO_SENSOR_PROXY_TYPE"), "hwmon-als") != 0) return FALSE; g_debug ("Found HWMon light at %s", g_udev_device_get_sysfs_path (device)); return TRUE; }
static void device_dump_config(GUdevDevice * device) { gchar *device_name, *name; device_name = g_strdup_printf("/dev/%s", g_udev_device_get_name(device)); if (device_is_serial(device)) { name = g_strdup_printf(_("Phone on serial port %s"), g_udev_device_get_number(device)); } else if (device_is_usb_serial(device)) { name = g_strdup_printf(_("Phone on USB serial port %s %s"), g_udev_device_get_property(device, "ID_VENDOR"), g_udev_device_get_property(device, "ID_MODEL")); } else if (device_is_acm(device)) { name = g_strdup_printf("%s %s", g_udev_device_get_property(device, "ID_VENDOR"), g_udev_device_get_property(device, "ID_MODEL")); } else { name = NULL; } print_config(device_name, name, "at"); g_free(device_name); g_free(name); }
static gboolean iio_buffer_light_discover (GUdevDevice *device) { if (g_strcmp0 (g_udev_device_get_property (device, "IIO_SENSOR_PROXY_TYPE"), "iio-buffer-als") != 0) return FALSE; g_debug ("Found IIO buffer ALS at %s", g_udev_device_get_sysfs_path (device)); return TRUE; }
char * g_vfs_get_volume_icon (GUdevDevice *device) { if (g_udev_device_has_property (device, "ID_MEDIA_PLAYER_ICON_NAME")) return g_strdup (g_udev_device_get_property (device, "ID_MEDIA_PLAYER_ICON_NAME")); else if (g_udev_device_has_property (device, "ID_MEDIA_PLAYER")) return g_strdup ("phone"); else return g_strdup ("camera-photo"); }
char * g_vfs_get_volume_symbolic_icon (GUdevDevice *device) { if (g_udev_device_has_property (device, "ID_MEDIA_PLAYER_ICON_NAME")) return g_strconcat (g_udev_device_get_property (device, "ID_MEDIA_PLAYER_ICON_NAME"), "-symbolic", NULL); else if (g_udev_device_has_property (device, "ID_MEDIA_PLAYER")) return g_strdup ("phone-symbolic"); else return g_strdup ("camera-photo-symbolic"); }
/** * rb_removable_media_manager_device_is_android: * @manager: the #RBRemovableMediaManager * @device: the #GUdevDevice to query * * Determines whether the specified device looks like an Android device. * * Return value: %TRUE if the device appears to be Android-based */ gboolean rb_removable_media_manager_device_is_android (RBRemovableMediaManager *manager, GObject *device) { #if defined(HAVE_GUDEV) gboolean match; const char *model; const char *vendor; int i; const char *androids[] = { "Android", "Nexus" }; const char *android_vendors[] = { "motorola", "OnePlus" }; match = FALSE; model = g_udev_device_get_property (G_UDEV_DEVICE (device), "ID_MODEL"); if (model != NULL) { for (i = 0; i < G_N_ELEMENTS (androids); i++) { if (strstr (model, androids[i])) match = TRUE; } } vendor = g_udev_device_get_property (G_UDEV_DEVICE (device), "ID_VENDOR"); if (vendor != NULL) { for (i = 0; i < G_N_ELEMENTS (android_vendors); i++) { if (strstr (vendor, android_vendors[i])) match = TRUE; } } return match; #else return FALSE; #endif }
static int get_property_as_int (GUdevDevice *device, const char *property, int base) { const char *strvalue; strvalue = g_udev_device_get_property (device, property); if (strvalue == NULL) { return 0; } return strtol (strvalue, NULL, base); }
/** * cd_plugin_get_scanner_id_for_udev_device: **/ static gchar * cd_plugin_get_scanner_id_for_udev_device (GUdevDevice *udev_device) { GString *string; const gchar *tmp; /* get id */ string = g_string_new ("sysfs"); tmp = g_udev_device_get_property (udev_device, "ID_VENDOR"); if (tmp != NULL) g_string_append_printf (string, "-%s", tmp); tmp = g_udev_device_get_property (udev_device, "ID_MODEL"); if (tmp != NULL) g_string_append_printf (string, "-%s", tmp); /* fallback */ if (string->len == 5) { tmp = g_udev_device_get_device_file (udev_device); g_string_append_printf (string, "-%s", tmp); } return g_string_free (string, FALSE); }
static gboolean partition_table_check (StoragedObject *object) { StoragedLinuxBlockObject *block_object = STORAGED_LINUX_BLOCK_OBJECT (object); gboolean ret = FALSE; /* only consider whole disks, never partitions */ if (g_strcmp0 (g_udev_device_get_devtype (block_object->device->udev_device), "disk") != 0) goto out; /* if blkid(8) already identified the device as a partition table, it's all good */ if (g_udev_device_has_property (block_object->device->udev_device, "ID_PART_TABLE_TYPE")) { /* however, if blkid(8) also think that we're a filesystem... then don't * mark us as a partition table ... except if we are partitioned by the * kernel * * (see filesystem_check() for the similar case where we don't pretend * to be a filesystem) */ if (g_strcmp0 (g_udev_device_get_property (block_object->device->udev_device, "ID_FS_USAGE"), "filesystem") == 0) { if (!disk_is_partitioned_by_kernel (block_object->device->udev_device)) { goto out; } } ret = TRUE; goto out; } /* Note that blkid(8) might not detect all partition table * formats that the kernel knows about.... so we need to * double check... * * Fortunately, note that the kernel guarantees that all children * block devices that are partitions are created before the uevent * for the parent block device.... so if the parent block device has * children... then it must be partitioned by the kernel, hence it * must contain a partition table. */ if (disk_is_partitioned_by_kernel (block_object->device->udev_device)) { ret = TRUE; goto out; } out: return ret; }
static gboolean btrfs_block_check (StoragedObject *object) { const gchar *fs_type = NULL; StoragedLinuxDevice *device = NULL; g_return_val_if_fail (STORAGED_IS_LINUX_BLOCK_OBJECT (object), FALSE); /* Check filesystem type from udev property. */ device = storaged_linux_block_object_get_device (STORAGED_LINUX_BLOCK_OBJECT (object)); fs_type = g_udev_device_get_property (device->udev_device, "ID_FS_TYPE"); return g_strcmp0 (fs_type, "btrfs") == 0; }
/** * storaged_linux_partition_table_update: * @table: A #StoragedLinuxPartitionTable. * @object: The enclosing #StoragedLinuxBlockObject instance. * * Updates the interface. */ void storaged_linux_partition_table_update (StoragedLinuxPartitionTable *table, StoragedLinuxBlockObject *object) { const gchar *type = NULL; StoragedLinuxDevice *device = NULL;; device = storaged_linux_block_object_get_device (object); if (device != NULL) type = g_udev_device_get_property (device->udev_device, "ID_PART_TABLE_TYPE"); storaged_partition_table_set_type_ (STORAGED_PARTITION_TABLE (table), type); g_clear_object (&device); }
static gboolean fake_compass_discover (GUdevDevice *device) { if (g_getenv ("FAKE_COMPASS") == NULL) return FALSE; if (g_strcmp0 (g_udev_device_get_subsystem (device), "input") != 0) return FALSE; /* "Lid switch" is a random input device to latch onto */ if (g_strcmp0 (g_udev_device_get_property (device, "NAME"), "\"Lid Switch\"") != 0) return FALSE; g_debug ("Found fake compass at %s", g_udev_device_get_sysfs_path (device)); return TRUE; }
static gboolean input_accel_discover (GUdevDevice *device) { const char *path; if (g_strcmp0 (g_udev_device_get_property (device, "IIO_SENSOR_PROXY_TYPE"), "input-accel") != 0) return FALSE; path = g_udev_device_get_device_file (device); if (!path) return FALSE; if (strstr (path, "/event") == NULL) return FALSE; g_debug ("Found input accel at %s", g_udev_device_get_sysfs_path (device)); return TRUE; }
static void dump_device_and_parent(GUdevDevice * device, guint indent) { const gchar *const *list; const gchar *const *iter; GUdevDevice *parent; char propstr[500]; guint32 namelen = 0, i; println(indent, "------------------------------------------------------"); println(indent, "%-20s %s", _("Name:"), g_udev_device_get_name(device)); println(indent, "%-20s %s", _("Type:"), g_udev_device_get_devtype(device)); println(indent, "%-20s %s", _("Subsystem:"), g_udev_device_get_subsystem(device)); println(indent, "%-20s %s", _("Number:"), g_udev_device_get_number(device)); println(indent, "%-20s %s", _("Path:"), g_udev_device_get_sysfs_path(device)); println(indent, "%-20s %s", _("Driver:"), g_udev_device_get_driver(device)); println(indent, "%-20s %lld", _("Sequential Number:"), (long long int)g_udev_device_get_seqnum(device)); println(indent, "%-20s %s", _("Device File:"), g_udev_device_get_device_file(device)); println(indent, " "); println(indent, _("Properties:")); /* Get longest property name length for alignment */ list = g_udev_device_get_property_keys(device); for (iter = list; iter && *iter; iter++) { if (strlen(*iter) > namelen) namelen = strlen(*iter); } namelen++; for (iter = list; iter && *iter; iter++) { strcpy(propstr, *iter); strcat(propstr, ":"); for (i = 0; i < namelen - strlen(*iter); i++) strcat(propstr, " "); strcat(propstr, g_udev_device_get_property(device, *iter)); println(indent + 2, "%s", propstr); } println(indent, " "); parent = g_udev_device_get_parent(device); if (parent) { dump_device_and_parent(parent, indent + 4); g_object_unref(parent); } }
/** * fu_provider_udev_client_remove: **/ static void fu_provider_udev_client_remove (FuProviderUdev *provider_udev, GUdevDevice *device) { FuProviderUdevPrivate *priv = GET_PRIVATE (provider_udev); FuDevice *dev; g_autofree gchar *id = NULL; /* interesting device? */ if (g_udev_device_get_property (device, "FWUPD_GUID") == NULL) return; /* already in database */ id = fu_provider_udev_get_id (device); dev = g_hash_table_lookup (priv->devices, id); if (dev == NULL) return; fu_provider_device_remove (FU_PROVIDER (provider_udev), dev); }
/** * cd_sensor_client_remove: **/ static void cd_sensor_client_remove (CdSensorClient *sensor_client, GUdevDevice *device) { CdSensor *sensor; const gchar *device_file; const gchar *device_path; const gchar *tmp; guint i; /* interesting device? */ tmp = g_udev_device_get_property (device, "COLORD_SENSOR_KIND"); if (tmp == NULL) goto out; /* actual device? */ device_file = g_udev_device_get_device_file (device); if (device_file == NULL) goto out; /* get data */ device_path = g_udev_device_get_sysfs_path (device); g_debug ("removing color management device: %s [%s]", device_path, device_file); for (i = 0; i < sensor_client->priv->array_sensors->len; i++) { sensor = g_ptr_array_index (sensor_client->priv->array_sensors, i); if (g_strcmp0 (cd_sensor_get_device_path (sensor), device_path) == 0) { g_debug ("emit: removed"); g_signal_emit (sensor_client, signals[SIGNAL_SENSOR_REMOVED], 0, sensor); g_ptr_array_remove_index_fast (sensor_client->priv->array_sensors, i); goto out; } } /* nothing found */ g_warning ("removed CM sensor that was never added"); out: return; }
static void telit_custom_init_step (TelitCustomInitContext *ctx) { GUdevDevice *port; /* If cancelled, end */ if (g_cancellable_is_cancelled (ctx->cancellable)) { mm_dbg ("telit: no need to keep on running custom init in (%s)", mm_port_get_device (MM_PORT (ctx->port))); goto out; } /* Try to get a port configuration from the modem: usb interface 00 * is always linked to an AT port */ port = mm_port_probe_peek_port (ctx->probe); if (!ctx->getportcfg_done && g_strcmp0 (g_udev_device_get_property (port, "ID_USB_INTERFACE_NUM"), "00") == 0) { if (ctx->getportcfg_retries == 0) goto out; ctx->getportcfg_retries--; mm_port_serial_at_command ( ctx->port, "AT#PORTCFG?", 2, FALSE, /* raw */ FALSE, /* allow_cached */ ctx->cancellable, (GAsyncReadyCallback)getportcfg_ready, ctx); return; } out: g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); telit_custom_init_context_complete_and_free (ctx); }