static StoragedObject * lookup_object_for_block (StoragedClient *client, dev_t block_device) { StoragedObject *ret; GList *objects; GList *l; ret = NULL; objects = g_dbus_object_manager_get_objects (storaged_client_get_object_manager (client)); for (l = objects; l != NULL; l = l->next) { StoragedObject *object = STORAGED_OBJECT (l->data); StoragedBlock *block; block = storaged_object_peek_block (object); if (block != NULL) { if (block_device == storaged_block_get_device_number (block)) { ret = g_object_ref (object); goto out; } } } out: g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); return ret; }
static MMObject * find_modem (MMManager *manager, const gchar *modem_path) { GList *modems; GList *l; MMObject *found = NULL; modems = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (manager)); for (l = modems; l; l = g_list_next (l)) { MMObject *modem = MM_OBJECT (l->data); if (g_str_equal (mm_object_get_path (modem), modem_path)) { found = g_object_ref (modem); break; } } g_list_free_full (modems, (GDestroyNotify) g_object_unref); if (!found) { g_printerr ("error: couldn't find modem at '%s'\n", modem_path); exit (EXIT_FAILURE); } g_debug ("Modem found at '%s'\n", modem_path); return found; }
static UDisksObject * lookup_object_for_block (UDisksClient *client, dev_t block_device) { UDisksObject *ret; GList *objects; GList *l; ret = NULL; objects = g_dbus_object_manager_get_objects (udisks_client_get_object_manager (client)); for (l = objects; l != NULL; l = l->next) { UDisksObject *object = UDISKS_OBJECT (l->data); UDisksBlock *block; block = udisks_object_peek_block (object); if (block != NULL) { if (block_device == udisks_block_get_device_number (block)) { ret = g_object_ref (object); goto out; } } } out: g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); return ret; }
static void on_sequence_complete(GIO_ASYNCSEQ_HANDLE async_seq_handle, gpointer previous_result) { CONNECT_CONTEXT* context = (CONNECT_CONTEXT*)GIO_Async_Seq_GetContext(async_seq_handle); context->handle_data->state = BLEIO_GATT_STATE_CONNECTED; // fetch list of objects on the object manager GList* objects_list = g_dbus_object_manager_get_objects( (GDBusObjectManager*)context->handle_data->object_manager ); if (objects_list == NULL) { on_sequence_error(async_seq_handle, NULL); } else { // iterate through each object and add each characteristic // that is a child of the device object path to the map g_list_foreach(objects_list, process_object, context); g_list_free(objects_list); /*Codes_SRS_BLEIO_GATT_13_011: [ When the connect operation to the device has been completed, the callback function pointed at by on_bleio_gatt_connect_complete shall be invoked. ]*/ /*Codes_SRS_BLEIO_GATT_13_012: [ When on_bleio_gatt_connect_complete is invoked the value passed in callback_context to BLEIO_gatt_connect shall be passed along to on_bleio_gatt_connect_complete. ]*/ /*Codes_SRS_BLEIO_GATT_13_013: [ The connect_result parameter of the on_bleio_gatt_connect_complete callback shall indicate the status of the connect operation. ]*/ // invoke the user's callback context->on_connect_complete( (BLEIO_GATT_HANDLE)context->handle_data, context->callback_context, BLEIO_GATT_CONNECT_OK ); free_context(context); } }
UDisksBlock * udisks_client_get_block_for_dev (UDisksClient *client, dev_t block_device_number) { UDisksBlock *ret = NULL; GList *l, *object_proxies = NULL; g_return_val_if_fail (UDISKS_IS_CLIENT (client), NULL); object_proxies = g_dbus_object_manager_get_objects (client->object_manager); for (l = object_proxies; l != NULL; l = l->next) { UDisksObject *object = UDISKS_OBJECT (l->data); UDisksBlock *block; block = udisks_object_get_block (object); if (block == NULL) continue; if (udisks_block_get_device_number (block) == block_device_number) { ret = block; goto out; } g_object_unref (block); } out: g_list_foreach (object_proxies, (GFunc) g_object_unref, NULL); g_list_free (object_proxies); return ret; }
static void _setup_nfc_adapters(GTlmNfc *self) { GList* objects = g_dbus_object_manager_get_objects(self->neard_manager); GList* objects_iter = objects; while (objects_iter != NULL) { GList* interfaces = g_dbus_object_get_interfaces(objects_iter->data); GList* interfaces_iter = interfaces; while (interfaces_iter != NULL) { g_debug("Checking managed object %s, interface %s", g_dbus_object_get_object_path (objects_iter->data), g_dbus_proxy_get_interface_name (interfaces_iter->data)); if (g_strcmp0(g_dbus_proxy_get_interface_name (interfaces_iter->data), "org.neard.Adapter") == 0) { _setup_nfc_adapter(self, interfaces_iter->data); } g_object_unref(interfaces_iter->data); interfaces_iter = interfaces_iter->next; } g_list_free(interfaces); g_object_unref(objects_iter->data); objects_iter = objects_iter->next; } g_list_free(objects); }
static bool CALESetUpBlueZObjects(CALEContext * context) { bool success = false; // Get the list of BlueZ D-Bus objects. GList * const objects = g_dbus_object_manager_get_objects(context->object_manager); if (objects == NULL) { OIC_LOG(ERROR, TAG, "Unable to get objects from ObjectManager."); return success; } ca_mutex_lock(context->lock); context->objects = objects; ca_mutex_unlock(context->lock); /* Create a proxies to the org.bluez.Adapter1 D-Bus objects that will later be used to obtain local bluetooth adapter properties, as well as by the BLE central code to discover peripherals. */ GList * adapters = NULL; success = CAGetBlueZManagedObjectProxies(&adapters, BLUEZ_ADAPTER_INTERFACE, context, NULL); // An empty adapters list is NULL. if (success && adapters != NULL) { ca_mutex_lock(context->lock); context->adapters = adapters; ca_mutex_unlock(context->lock); } /* Create a proxies to the org.bluez.Device1 D-Bus objects that will later be used to establish connections. */ GList * devices = NULL; success = CAGetBlueZManagedObjectProxies(&devices, BLUEZ_DEVICE_INTERFACE, context, CALEDeviceFilter); // An empty device list is NULL. if (success && devices != NULL) { ca_mutex_lock(context->lock); context->devices = devices; ca_mutex_unlock(context->lock); } return success; }
static void storage_remove_config (StorageProvider *provider, UDisksBlock *block, GVariant *config) { GVariantIter iter; GVariant *item; GError *error = NULL; gs_unref_object UDisksBlock *block_to_use = NULL; if (block == NULL) { /* Any block can be used to add/remove any configuration item. Let's hope we have at least one... XXX - UDisks should offer a method for manipulating fstab and crypttab on the Manager. */ UDisksClient *client = storage_provider_get_udisks_client (provider); GDBusObjectManager *manager = udisks_client_get_object_manager (client); GList *objects = g_dbus_object_manager_get_objects (manager); for (GList *l = objects; l; l = l->next) { UDisksObject *object = l->data; block_to_use = udisks_object_get_block (object); if (block_to_use) break; } g_list_free_full (objects, g_object_unref); if (block_to_use == NULL) { g_warning ("Can't remove config: no block object found."); return; } } else block_to_use = g_object_ref (block); g_variant_iter_init (&iter, config); while ((item = g_variant_iter_next_value (&iter)) != NULL) { if (!udisks_block_call_remove_configuration_item_sync (block_to_use, item, g_variant_new ("a{sv}", NULL), NULL, &error)) { gs_free gchar *config_text = g_variant_print (config, FALSE); g_warning ("Can't remove storage configuration '%s': %s", config_text, error->message); g_clear_error (&error); } } }
static bool uninstall_application(GDBusObjectManager* installed, const char* appid) { GList* objects = g_dbus_object_manager_get_objects(installed); GList* l; bool ret = false; for (l = objects; l; l = l->next) { GDBusObject* object = l->data; GDBusInterface* iface = g_dbus_object_get_interface( object, xwalk_installed_app_iface); if (!iface) continue; GDBusProxy* proxy = G_DBUS_PROXY(iface); GVariant* value = g_dbus_proxy_get_cached_property(proxy, "AppID"); if (!value) { g_object_unref(iface); continue; } const char* id; g_variant_get(value, "s", &id); if (g_strcmp0(appid, id)) { g_object_unref(iface); continue; } GError* error = NULL; GVariant* result = g_dbus_proxy_call_sync(proxy, "Uninstall", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (!result) { g_print("Uninstalling application failed: %s\n", error->message); g_error_free(error); g_object_unref(iface); ret = false; goto done; } g_object_unref(iface); ret = true; goto done; } g_print("Application ID '%s' could not be found\n", appid); done: g_list_free_full(objects, g_object_unref); return ret; }
static void update_progress_for_device (StoragedDaemon *daemon, const gchar *operation, const gchar *dev, double progress) { GDBusObjectManager *object_manager; GList *objects, *l; object_manager = G_DBUS_OBJECT_MANAGER (storaged_daemon_get_object_manager (daemon)); objects = g_dbus_object_manager_get_objects (object_manager); for (l = objects; l; l = l->next) { StoragedObject *object = STORAGED_OBJECT (l->data); StoragedJob *job; const gchar *const *job_objects; int i; job = storaged_object_peek_job (object); if (job == NULL) continue; if (g_strcmp0 (storaged_job_get_operation (job), operation) != 0) continue; job_objects = storaged_job_get_objects (job); for (i = 0; job_objects[i]; i++) { StoragedBlock *block = STORAGED_BLOCK (g_dbus_object_manager_get_interface (object_manager, job_objects[i], "org.storaged.Storaged.Block")); if (block) { const gchar *const *symlinks; int j; if (g_strcmp0 (storaged_block_get_device (block), dev) == 0) goto found; symlinks = storaged_block_get_symlinks (block); for (j = 0; symlinks[j]; j++) if (g_strcmp0 (symlinks[j], dev) == 0) goto found; continue; found: storaged_job_set_progress (job, progress); storaged_job_set_progress_valid (job, TRUE); } } } g_list_free_full (objects, g_object_unref); }
static gboolean have_partition_in_range (StoragedPartitionTable *table, StoragedObject *object, guint64 start, guint64 end, gboolean ignore_container) { gboolean ret = FALSE; StoragedDaemon *daemon = NULL; GDBusObjectManager *object_manager = NULL; const gchar *table_object_path; GList *objects = NULL, *l; daemon = storaged_linux_block_object_get_daemon (STORAGED_LINUX_BLOCK_OBJECT (object)); object_manager = G_DBUS_OBJECT_MANAGER (storaged_daemon_get_object_manager (daemon)); table_object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object)); objects = g_dbus_object_manager_get_objects (object_manager); for (l = objects; l != NULL; l = l->next) { StoragedObject *i_object = STORAGED_OBJECT (l->data); StoragedPartition *i_partition = NULL; i_partition = storaged_object_get_partition (i_object); if (i_partition == NULL) goto cont; if (g_strcmp0 (storaged_partition_get_table (i_partition), table_object_path) != 0) goto cont; if (ignore_container && storaged_partition_get_is_container (i_partition)) goto cont; if (!ranges_overlap (start, end - start, storaged_partition_get_offset (i_partition), storaged_partition_get_size (i_partition))) goto cont; ret = TRUE; g_clear_object (&i_partition); goto out; cont: g_clear_object (&i_partition); } out: g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); return ret; }
static void get_sms_manager_ready (GDBusConnection *connection, GAsyncResult *res, GetSmsContext *ctx) { ctx->manager = mmcli_get_manager_finish (res); ctx->modems = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (ctx->manager)); if (!ctx->modems) { g_printerr ("error: couldn't find SMS at '%s': 'no modems found'\n", ctx->sms_path); exit (EXIT_FAILURE); } look_for_sms_in_modem (ctx); }
/** * udisks_linux_drive_object_get_block: * @object: A #UDisksLinuxDriveObject. * @get_hw: If the drive is multipath, set to %TRUE to get a path device instead of the multipath device. * * Gets a #UDisksLinuxBlockObject representing a block device associated with @object. * * Returns: A #UDisksLinuxBlockObject or %NULL. The returned object * must be freed with g_object_unref(). */ UDisksLinuxBlockObject * udisks_linux_drive_object_get_block (UDisksLinuxDriveObject *object, gboolean get_hw) { GDBusObjectManagerServer *object_manager; UDisksLinuxBlockObject *ret; GList *objects; GList *l; /* TODO: actually look at @get_hw */ ret = NULL; object_manager = udisks_daemon_get_object_manager (object->daemon); objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (object_manager)); for (l = objects; l != NULL; l = l->next) { GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data); UDisksBlock *block; UDisksLinuxDevice *device; gboolean is_disk; if (!UDISKS_IS_LINUX_BLOCK_OBJECT (iter_object)) continue; device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (iter_object)); is_disk = (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") == 0); g_object_unref (device); if (!is_disk) continue; block = udisks_object_peek_block (UDISKS_OBJECT (iter_object)); if (g_strcmp0 (udisks_block_get_drive (block), g_dbus_object_get_object_path (G_DBUS_OBJECT (object))) == 0) { ret = g_object_ref (iter_object); goto out; } } out: g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); return ret; }
GList * storage_daemon_get_jobs (StorageDaemon *self) { GList *objects, *l; GList *jobs = NULL; objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (self->object_manager)); for (l = objects; l != NULL; l = g_list_next (l)) { StorageJob *job = STORAGE_JOB (g_dbus_object_get_interface (l->data, "org.freedesktop.UDisks2.Job")); if (job) jobs = g_list_prepend (jobs, job); } g_list_free_full (objects, g_object_unref); return jobs; }
static void update_problems (GduSdMonitor *monitor, GList **problem_list, CheckProblemFunc check_func) { GList *want = NULL; GList *added = NULL; GList *removed = NULL; GList *objects; GList *l; objects = g_dbus_object_manager_get_objects (udisks_client_get_object_manager (monitor->client)); for (l = objects; l != NULL; l = l->next) { UDisksObject *object = UDISKS_OBJECT (l->data); if (check_func (monitor, object)) want = g_list_prepend (want, object); } want = g_list_sort (want, ptr_compare); *problem_list = g_list_sort (*problem_list, ptr_compare); diff_sorted_lists (*problem_list, want, ptr_compare, &added, &removed); for (l = removed; l != NULL; l = l->next) { UDisksObject *object = UDISKS_OBJECT (l->data); *problem_list = g_list_remove (*problem_list, object); g_object_unref (object); } for (l = added; l != NULL; l = l->next) { UDisksObject *object = UDISKS_OBJECT (l->data); *problem_list = g_list_prepend (*problem_list, g_object_ref (object)); } g_list_free (removed); g_list_free (added); g_list_free (want); g_list_free_full (objects, g_object_unref); }
/** * storaged_linux_drive_object_get_block: * @object: A #StoragedLinuxDriveObject. * @get_hw: If the drive is multipath, set to %TRUE to get a path device instead of the multipath device. * * Gets a #StoragedLinuxBlockObject representing a block device associated with @object. * * Returns: A #StoragedLinuxBlockObject or %NULL. The returned object * must be freed with g_object_unref(). */ StoragedLinuxBlockObject * storaged_linux_drive_object_get_block (StoragedLinuxDriveObject *object, gboolean get_hw) { GDBusObjectManagerServer *object_manager; StoragedLinuxBlockObject *ret; GList *objects; GList *l; ret = NULL; object_manager = storaged_daemon_get_object_manager (object->daemon); objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (object_manager)); for (l = objects; l != NULL; l = l->next) { GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data); StoragedBlock *block; StoragedLinuxDevice *device; gboolean skip; if (!STORAGED_IS_LINUX_BLOCK_OBJECT (iter_object)) continue; device = storaged_linux_block_object_get_device (STORAGED_LINUX_BLOCK_OBJECT (iter_object)); skip = (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") != 0 || (get_hw && is_dm_multipath (device))); g_object_unref (device); if (skip) continue; block = storaged_object_peek_block (STORAGED_OBJECT (iter_object)); if (g_strcmp0 (storaged_block_get_drive (block), g_dbus_object_get_object_path (G_DBUS_OBJECT (object))) == 0) { ret = g_object_ref (iter_object); goto out; } } out: g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); return ret; }
GList * um_realm_manager_get_realms (UmRealmManager *self) { GList *objects; GList *realms = NULL; GList *l; g_return_val_if_fail (UM_IS_REALM_MANAGER (self), NULL); objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (self)); for (l = objects; l != NULL; l = g_list_next (l)) { if (is_realm_with_kerberos_and_membership (l->data)) realms = g_list_prepend (realms, g_object_ref (l->data)); } g_list_free_full (objects, g_object_unref); return realms; }
static void print_objects (GDBusObjectManager *manager) { GList *objects; GList *l; g_print ("Object manager at %s\n", g_dbus_object_manager_get_object_path (manager)); objects = g_dbus_object_manager_get_objects (manager); for (l = objects; l != NULL; l = l->next) { ExampleObject *object = EXAMPLE_OBJECT (l->data); GList *interfaces; GList *ll; g_print (" - Object at %s\n", g_dbus_object_get_object_path (G_DBUS_OBJECT (object))); interfaces = g_dbus_object_get_interfaces (G_DBUS_OBJECT (object)); for (ll = interfaces; ll != NULL; ll = ll->next) { GDBusInterface *interface = G_DBUS_INTERFACE (ll->data); g_print (" - Interface %s\n", g_dbus_interface_get_info (interface)->name); /* Note that @interface is really a GDBusProxy instance - and additionally also * an ExampleAnimal or ExampleCat instance - either of these can be used to * invoke methods on the remote object. For example, the generated function * * void example_animal_call_poke_sync (ExampleAnimal *proxy, * gboolean make_sad, * gboolean make_happy, * GCancellable *cancellable, * GError **error); * * can be used to call the Poke() D-Bus method on the .Animal interface. * Additionally, the generated function * * const gchar *example_animal_get_mood (ExampleAnimal *object); * * can be used to get the value of the :Mood property. */ } g_list_free_full (interfaces, g_object_unref); } g_list_free_full (objects, g_object_unref); }
static void get_sim_manager_ready (GDBusConnection *connection, GAsyncResult *res, GetSimContext *ctx) { GList *l; GList *modems; ctx->manager = mmcli_get_manager_finish (res); modems = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (ctx->manager)); if (!modems) { g_printerr ("error: couldn't find sim at '%s': 'no modems found'\n", ctx->sim_path); exit (EXIT_FAILURE); } for (l = modems; l; l = g_list_next (l)) { MMObject *object; MMModem *modem; object = MM_OBJECT (l->data); modem = mm_object_get_modem (object); if (g_str_equal (ctx->sim_path, mm_modem_get_sim_path (modem))) { ctx->modem = g_object_ref (object); mm_modem_get_sim (modem, ctx->cancellable, (GAsyncReadyCallback)get_sim_ready, ctx); break; } g_object_unref (modem); } if (!ctx->modem) { g_printerr ("error: couldn't find sim at '%s'\n", ctx->sim_path); exit (EXIT_FAILURE); } g_list_free_full (modems, (GDestroyNotify) g_object_unref); }
static void on_manager_new_ready (GObject *source_object, GAsyncResult *res, gpointer user_data) { GClueModemSourcePrivate *priv = GCLUE_MODEM_SOURCE (user_data)->priv; GList *objects, *node; GError *error = NULL; priv->manager = mm_manager_new_finish (res, &error); if (priv->manager == NULL) { g_warning ("Failed to connect to ModemManager: %s", error->message); g_error_free (error); return; } objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (priv->manager)); for (node = objects; node != NULL; node = node->next) { on_mm_object_added (G_DBUS_OBJECT_MANAGER (priv->manager), G_DBUS_OBJECT (node->data), user_data); /* FIXME: Currently we only support 1 modem device */ if (priv->modem != NULL) break; } g_list_free_full (objects, g_object_unref); g_signal_connect (G_OBJECT (priv->manager), "object-added", G_CALLBACK (on_mm_object_added), user_data); g_signal_connect (G_OBJECT (priv->manager), "object-removed", G_CALLBACK (on_mm_object_removed), user_data); }
/** * storaged_linux_drive_object_get_siblings: * @object: A #StoragedLinuxDriveObject. * * Gets the siblings for @object, if any. * * Returns: (transfer full) (element-type StoragedLinuxDriveObject): A list of #StoragedLinuxDriveObject * instances. The returned list should be freed with g_list_free() after each element has been * freed with g_object_unref(). */ GList * storaged_linux_drive_object_get_siblings (StoragedLinuxDriveObject *object) { GDBusObjectManagerServer *object_manager; GList *ret = NULL; GList *objects = NULL; GList *l; gchar *sibling_id = NULL; if (object->iface_drive == NULL) goto out; sibling_id = storaged_drive_dup_sibling_id (object->iface_drive); if (sibling_id == NULL || strlen (sibling_id) == 0) goto out; object_manager = storaged_daemon_get_object_manager (object->daemon); objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (object_manager)); for (l = objects; l != NULL; l = l->next) { GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data); StoragedLinuxDriveObject *iter_linux_drive_object; if (!STORAGED_IS_LINUX_DRIVE_OBJECT (iter_object)) continue; iter_linux_drive_object = STORAGED_LINUX_DRIVE_OBJECT (iter_object); if (iter_linux_drive_object->iface_drive != NULL && g_strcmp0 (storaged_drive_get_sibling_id (iter_linux_drive_object->iface_drive), sibling_id) == 0) { ret = g_list_prepend (ret, g_object_ref (iter_object)); } } out: ret = g_list_reverse (ret); g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); g_free (sibling_id); return ret; }
static void list_applications(GDBusObjectManager* installed) { GList* objects = g_dbus_object_manager_get_objects(installed); GList* l; for (l = objects; l; l = l->next) { GDBusObject* object = l->data; GDBusInterface* iface = g_dbus_object_get_interface( object, xwalk_installed_app_iface); if (!iface) continue; GDBusProxy* proxy = G_DBUS_PROXY(iface); GVariant* id_variant; id_variant = g_dbus_proxy_get_cached_property(proxy, "AppID"); if (!id_variant) { g_object_unref(iface); continue; } const char* id; g_variant_get(id_variant, "s", &id); GVariant* name_variant; name_variant = g_dbus_proxy_get_cached_property(proxy, "Name"); if (!name_variant) { g_object_unref(iface); continue; } const char* name; g_variant_get(name_variant, "s", &name); g_print("%s\t%s\n", id, name); g_object_unref(iface); } g_list_free_full(objects, g_object_unref); }
static gboolean on_handle_delete_all_objects (TestFrobber *object, GDBusMethodInvocation *invocation, gpointer user_data) { MockData *data = user_data; const gchar *path; GList *objects; GList *l; objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (data->object_manager)); for (l = objects; l != NULL; l = g_list_next (l)) { path = g_dbus_object_get_object_path (l->data); if (!g_str_has_suffix (path, "/frobber")) g_warn_if_fail (g_dbus_object_manager_server_unexport (data->object_manager, path)); } test_frobber_complete_delete_all_objects (object, invocation); g_list_free_full (objects, g_object_unref); return TRUE; }
static void send_seed (CockpitDBusJson1 *self) { cleanup_unref_object JsonBuilder *builder = json_builder_new (); json_builder_begin_object (builder); json_builder_set_member_name (builder, "command"); json_builder_add_string_value (builder, "seed"); json_builder_set_member_name (builder, "options"); json_builder_begin_object (builder); json_builder_set_member_name (builder, "byteorder"); if (G_BYTE_ORDER == G_LITTLE_ENDIAN) json_builder_add_string_value (builder, "le"); else if (G_BYTE_ORDER == G_BIG_ENDIAN) json_builder_add_string_value (builder, "be"); else json_builder_add_string_value (builder, ""); json_builder_end_object (builder); json_builder_set_member_name (builder, "data"); json_builder_begin_object (builder); GList *objects = g_dbus_object_manager_get_objects (self->object_manager); for (GList *l = objects; l != NULL; l = l->next) { GDBusObject *object = G_DBUS_OBJECT (l->data); json_builder_set_member_name (builder, g_dbus_object_get_object_path (object)); json_builder_begin_object (builder); add_object (builder, object); json_builder_end_object (builder); } g_list_foreach (objects, (GFunc)g_object_unref, NULL); g_list_free (objects); json_builder_end_object (builder); write_builder (self, builder); }
/** * goa_client_get_accounts: * @client: A #GoaClient. * * Gets all accounts that @client knows about. The result is a list of * #GoaObject instances where each object at least has an #GoaAccount * interface (that can be obtained via the goa_object_get_account() * method) but may also implement other interfaces such as * #GoaMail or #GoaFiles. * * Returns: (transfer full) (element-type GoaObject): A list of * #GoaObject instances that must be freed with g_list_free() after * each element has been freed with g_object_unref(). */ GList * goa_client_get_accounts (GoaClient *client) { GList *ret; GList *objects; GList *l; g_return_val_if_fail (GOA_IS_CLIENT (client), NULL); ret = NULL; objects = g_dbus_object_manager_get_objects (client->object_manager); for (l = objects; l != NULL; l = l->next) { GoaObject *object = GOA_OBJECT (l->data); if (goa_object_peek_account (object) != NULL) ret = g_list_prepend (ret, g_object_ref (object)); } g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); return ret; }
static void test_objects (Test *test, gconstpointer data) { GList *objects, *l; const gchar *path; objects = g_dbus_object_manager_get_objects (test->objman); if (g_test_verbose ()) { for (l = objects; l != NULL; l = g_list_next (l)) { path = g_dbus_object_get_object_path (l->data); g_printerr ("%s\n", path); } } /* Some block devices should show up */ g_assert (objects != NULL); g_assert (objects->data != NULL); g_list_free_full (objects, g_object_unref); }
static void process_config_entries (GoaDaemon *daemon, GHashTable *group_name_to_key_file_data) { GHashTableIter iter; const gchar *id; KeyFileData *key_file_data; GList *existing_object_paths; GList *config_object_paths; GList *added; GList *removed; GList *unchanged; GList *l; existing_object_paths = NULL; { GList *existing_objects; existing_objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (daemon->object_manager)); for (l = existing_objects; l != NULL; l = l->next) { GoaObject *object = GOA_OBJECT (l->data); const gchar *object_path; object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object)); if (g_str_has_prefix (object_path, "/org/gnome/OnlineAccounts/Accounts/")) existing_object_paths = g_list_prepend (existing_object_paths, g_strdup (object_path)); } g_list_foreach (existing_objects, (GFunc) g_object_unref, NULL); g_list_free (existing_objects); } config_object_paths = NULL; g_hash_table_iter_init (&iter, group_name_to_key_file_data); while (g_hash_table_iter_next (&iter, (gpointer*) &id, (gpointer*) &key_file_data)) { gchar *object_path; /* create and validate object path */ object_path = g_strdup_printf ("/org/gnome/OnlineAccounts/Accounts/%s", id + sizeof "Account " - 1); if (strstr (id + sizeof "Account " - 1, "/") != NULL || !g_variant_is_object_path (object_path)) { g_warning ("`%s' is not a valid account identifier", id); g_free (object_path); continue; } /* steals object_path variable */ config_object_paths = g_list_prepend (config_object_paths, object_path); } existing_object_paths = g_list_sort (existing_object_paths, (GCompareFunc) g_strcmp0); config_object_paths = g_list_sort (config_object_paths, (GCompareFunc) g_strcmp0); diff_sorted_lists (existing_object_paths, config_object_paths, (GCompareFunc) g_strcmp0, &added, &removed, &unchanged); for (l = removed; l != NULL; l = l->next) { const gchar *object_path = l->data; GoaObject *object; object = GOA_OBJECT (g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (daemon->object_manager), object_path)); g_warn_if_fail (object != NULL); g_signal_handlers_disconnect_by_func (goa_object_peek_account (object), G_CALLBACK (on_account_handle_remove), daemon); g_debug ("removing %s", object_path); g_warn_if_fail (g_dbus_object_manager_server_unexport (daemon->object_manager, object_path)); } for (l = added; l != NULL; l = l->next) { const gchar *object_path = l->data; GoaObjectSkeleton *object; gchar *group; g_debug ("adding %s", object_path); group = object_path_to_group (object_path); key_file_data = g_hash_table_lookup (group_name_to_key_file_data, group); g_warn_if_fail (key_file_data != NULL); object = goa_object_skeleton_new (object_path); if (update_account_object (daemon, object, key_file_data->path, group, key_file_data->key_file, TRUE)) { g_dbus_object_manager_server_export (daemon->object_manager, G_DBUS_OBJECT_SKELETON (object)); g_signal_connect (goa_object_peek_account (GOA_OBJECT (object)), "handle-remove", G_CALLBACK (on_account_handle_remove), daemon); g_signal_connect (goa_object_peek_account (GOA_OBJECT (object)), "handle-ensure-credentials", G_CALLBACK (on_account_handle_ensure_credentials), daemon); } g_object_unref (object); g_free (group); } for (l = unchanged; l != NULL; l = l->next) { const gchar *object_path = l->data; GoaObject *object; gchar *group; g_debug ("unchanged %s", object_path); group = object_path_to_group (object_path); key_file_data = g_hash_table_lookup (group_name_to_key_file_data, group); g_warn_if_fail (key_file_data != NULL); object = GOA_OBJECT (g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (daemon->object_manager), object_path)); g_warn_if_fail (object != NULL); if (!update_account_object (daemon, GOA_OBJECT_SKELETON (object), key_file_data->path, group, key_file_data->key_file, FALSE)) { g_signal_handlers_disconnect_by_func (goa_object_peek_account (object), G_CALLBACK (on_account_handle_remove), daemon); g_signal_handlers_disconnect_by_func (goa_object_peek_account (object), G_CALLBACK (on_account_handle_ensure_credentials), daemon); g_warn_if_fail (g_dbus_object_manager_server_unexport (daemon->object_manager, object_path)); } g_object_unref (object); g_free (group); } g_list_free (removed); g_list_free (added); g_list_free (unchanged); g_list_foreach (existing_object_paths, (GFunc) g_free, NULL); g_list_free (existing_object_paths); g_list_foreach (config_object_paths, (GFunc) g_free, NULL); g_list_free (config_object_paths); }
static void update_with_variant (GPid pid, GVariant *info, GError *error, gpointer user_data) { StoragedLinuxVolumeGroupObject *object = user_data; StoragedDaemon *daemon; GDBusObjectManagerServer *manager; GVariantIter *iter; GHashTableIter volume_iter; gpointer key, value; GHashTable *new_lvs; GHashTable *new_pvs; GList *objects, *l; gboolean needs_polling = FALSE; daemon = storaged_linux_volume_group_object_get_daemon (object); manager = storaged_daemon_get_object_manager (daemon); if (error) { storaged_warning ("Failed to update LVM volume group %s: %s", storaged_linux_volume_group_object_get_name (object), error->message); g_object_unref (object); return; } storaged_linux_volume_group_update (STORAGED_LINUX_VOLUME_GROUP (object->iface_volume_group), info, &needs_polling); if (!g_dbus_object_manager_server_is_exported (manager, G_DBUS_OBJECT_SKELETON (object))) g_dbus_object_manager_server_export_uniquely (manager, G_DBUS_OBJECT_SKELETON (object)); new_lvs = g_hash_table_new (g_str_hash, g_str_equal); if (g_variant_lookup (info, "lvs", "aa{sv}", &iter)) { GVariant *lv_info = NULL; while (g_variant_iter_loop (iter, "@a{sv}", &lv_info)) { const gchar *name; StoragedLinuxLogicalVolumeObject *volume; g_variant_lookup (lv_info, "name", "&s", &name); update_operations (daemon, name, lv_info, &needs_polling); if (lv_is_pvmove_volume (name)) needs_polling = TRUE; if (storaged_daemon_util_lvm2_name_is_reserved (name)) continue; volume = g_hash_table_lookup (object->logical_volumes, name); if (volume == NULL) { volume = storaged_linux_logical_volume_object_new (daemon, object, name); storaged_linux_logical_volume_object_update (volume, lv_info, &needs_polling); storaged_linux_logical_volume_object_update_etctabs (volume); g_dbus_object_manager_server_export_uniquely (manager, G_DBUS_OBJECT_SKELETON (volume)); g_hash_table_insert (object->logical_volumes, g_strdup (name), g_object_ref (volume)); } else storaged_linux_logical_volume_object_update (volume, lv_info, &needs_polling); g_hash_table_insert (new_lvs, (gchar *)name, volume); } g_variant_iter_free (iter); } g_hash_table_iter_init (&volume_iter, object->logical_volumes); while (g_hash_table_iter_next (&volume_iter, &key, &value)) { const gchar *name = key; StoragedLinuxLogicalVolumeObject *volume = value; if (!g_hash_table_contains (new_lvs, name)) { g_dbus_object_manager_server_unexport (manager, g_dbus_object_get_object_path (G_DBUS_OBJECT (volume))); g_hash_table_iter_remove (&volume_iter); g_object_unref (G_OBJECT (volume)); } } storaged_volume_group_set_needs_polling (STORAGED_VOLUME_GROUP (object->iface_volume_group), needs_polling); /* Update block objects. */ new_pvs = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify)g_variant_unref); if (g_variant_lookup (info, "pvs", "aa{sv}", &iter)) { const gchar *name; GVariant *pv_info; while (g_variant_iter_next (iter, "@a{sv}", &pv_info)) { if (g_variant_lookup (pv_info, "device", "&s", &name)) g_hash_table_insert (new_pvs, (gchar *)name, pv_info); else g_variant_unref (pv_info); } } objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (manager)); for (l = objects; l != NULL; l = l->next) { if (STORAGED_IS_LINUX_BLOCK_OBJECT (l->data)) update_block (STORAGED_LINUX_BLOCK_OBJECT (l->data), object, new_lvs, new_pvs); } g_list_free_full (objects, g_object_unref); g_hash_table_destroy (new_lvs); g_hash_table_destroy (new_pvs); g_object_unref (object); }
static gboolean initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { UDisksClient *client = UDISKS_CLIENT (initable); gboolean ret; GList *objects, *l; GList *interfaces, *ll; ret = FALSE; /* This method needs to be idempotent to work with the singleton * pattern. See the docs for g_initable_init(). We implement this by * locking. */ G_LOCK (init_lock); if (client->is_initialized) { if (client->object_manager != NULL) ret = TRUE; else g_assert (client->initialization_error != NULL); goto out; } g_assert (client->initialization_error == NULL); client->context = g_main_context_get_thread_default (); if (client->context != NULL) g_main_context_ref (client->context); client->object_manager = udisks_object_manager_client_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, "org.freedesktop.UDisks2", "/org/freedesktop/UDisks2", cancellable, &client->initialization_error); if (client->object_manager == NULL) goto out; /* init all proxies */ objects = g_dbus_object_manager_get_objects (client->object_manager); for (l = objects; l != NULL; l = l->next) { interfaces = g_dbus_object_get_interfaces (G_DBUS_OBJECT (l->data)); for (ll = interfaces; ll != NULL; ll = ll->next) { init_interface_proxy (client, G_DBUS_PROXY (ll->data)); } g_list_foreach (interfaces, (GFunc) g_object_unref, NULL); g_list_free (interfaces); } g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); g_signal_connect (client->object_manager, "object-added", G_CALLBACK (on_object_added), client); g_signal_connect (client->object_manager, "object-removed", G_CALLBACK (on_object_removed), client); g_signal_connect (client->object_manager, "interface-added", G_CALLBACK (on_interface_added), client); g_signal_connect (client->object_manager, "interface-removed", G_CALLBACK (on_interface_removed), client); g_signal_connect (client->object_manager, "interface-proxy-properties-changed", G_CALLBACK (on_interface_proxy_properties_changed), client); ret = TRUE; out: client->is_initialized = TRUE; if (!ret) { g_assert (client->initialization_error != NULL); g_propagate_error (error, g_error_copy (client->initialization_error)); } G_UNLOCK (init_lock); return ret; }
/** * storaged_linux_drive_object_is_not_in_use: * @object: A #StoragedLinuxDriveObject. * @cancellable: (allow-none): A #GCancellable or %NULL. * @error: A #GError or %NULL. * * Checks if the drive represented by @object is in use and sets * @error if so. * * Returns: %TRUE if @object is not is use, %FALSE if @error is set. */ gboolean storaged_linux_drive_object_is_not_in_use (StoragedLinuxDriveObject *object, GCancellable *cancellable, GError **error) { GDBusObjectManagerServer *object_manager; const gchar *drive_object_path; gboolean ret = TRUE; GList *objects = NULL; GList *l; g_return_val_if_fail (STORAGED_IS_LINUX_DRIVE_OBJECT (object), FALSE); g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); drive_object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object)); object_manager = storaged_daemon_get_object_manager (object->daemon); objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (object_manager)); /* Visit all block devices related to the drive... */ for (l = objects; l != NULL; l = l->next) { GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data); StoragedBlock *block; StoragedFilesystem *filesystem; if (!STORAGED_IS_LINUX_BLOCK_OBJECT (iter_object)) continue; block = storaged_object_peek_block (STORAGED_OBJECT (iter_object)); filesystem = storaged_object_peek_filesystem (STORAGED_OBJECT (iter_object)); if (g_strcmp0 (storaged_block_get_drive (block), drive_object_path) != 0) continue; /* bail if block device is mounted */ if (filesystem != NULL) { if (g_strv_length ((gchar **) storaged_filesystem_get_mount_points (filesystem)) > 0) { g_set_error (error, STORAGED_ERROR, STORAGED_ERROR_DEVICE_BUSY, "Device %s is mounted", storaged_block_get_preferred_device (block)); ret = FALSE; goto out; } } /* bail if block device is unlocked (LUKS) */ if (is_block_unlocked (objects, g_dbus_object_get_object_path (G_DBUS_OBJECT (iter_object)))) { g_set_error (error, STORAGED_ERROR, STORAGED_ERROR_DEVICE_BUSY, "Encrypted device %s is unlocked", storaged_block_get_preferred_device (block)); ret = FALSE; goto out; } } out: g_list_free_full (objects, g_object_unref); return ret; }