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); }
static gboolean handle_empty_device (CockpitStorageVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_objpath) { StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object); GError *error = NULL; const gchar *block_path = "/"; if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN)) return TRUE; StorageProvider *provider = storage_object_get_provider (group->object); Daemon *daemon = storage_provider_get_daemon (provider); GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon); GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server); StorageObject *block_object = STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_objpath)); UDisksBlock *udisks_block = storage_object_get_udisks_block (block_object); if (udisks_block) block_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (udisks_block)); g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group), G_MAXINT); if (!lvm_volume_group_call_empty_device_sync (group->lvm_volume_group, block_path, null_asv (), NULL, &error)) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); g_error_free (error); } else cockpit_storage_volume_group_complete_empty_device (object, invocation); g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group), -1); return TRUE; }
static gboolean handle_create_thin_volume (CockpitStorageVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_name, guint64 arg_size, const gchar *arg_pool) { StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object); GError *error = NULL; gs_free gchar *result = NULL; const gchar *pool_path = "/"; if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN)) return TRUE; StorageProvider *provider = storage_object_get_provider (group->object); Daemon *daemon = storage_provider_get_daemon (provider); GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon); GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server); StorageObject *pool_object = STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_pool)); LvmLogicalVolume *lvm_pool_lvol = storage_object_get_lvm_logical_volume (pool_object); if (lvm_pool_lvol) pool_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (lvm_pool_lvol)); if (!lvm_volume_group_call_create_thin_volume_sync (group->lvm_volume_group, arg_name, arg_size, pool_path, null_asv (), &result, NULL, &error)) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); g_error_free (error); } else cockpit_storage_volume_group_complete_create_thin_pool_volume (object, invocation); return TRUE; }
/** * 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; }
/** * 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 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); }
/** * 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 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 gboolean on_handle_create_object (TestFrobber *object, GDBusMethodInvocation *invocation, const gchar *at_path, gpointer user_data) { MockData *data = user_data; GDBusObject *previous; previous = g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (data->object_manager), at_path); if (previous != NULL) { g_dbus_method_invocation_return_error (invocation, G_IO_ERROR, G_IO_ERROR_FAILED, "Sorry, object already exists at %s", at_path); g_object_unref (previous); } else { TestObjectSkeleton *new_object; TestFrobber *frobber; new_object = test_object_skeleton_new (at_path); frobber = test_frobber_skeleton_new (); test_object_skeleton_set_frobber (new_object, frobber); g_dbus_object_manager_server_export (data->object_manager, G_DBUS_OBJECT_SKELETON (new_object)); g_object_unref (frobber); g_object_unref (new_object); g_signal_connect (frobber, "handle-request-property-mods", G_CALLBACK (on_handle_request_property_mods), NULL); test_frobber_complete_create_object (object, invocation); } return TRUE; }
static void g_dbus_object_manager_server_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GDBusObjectManagerServer *manager = G_DBUS_OBJECT_MANAGER_SERVER (object); switch (prop_id) { case PROP_CONNECTION: g_value_set_object (value, manager->priv->connection); break; case PROP_OBJECT_PATH: g_value_set_string (value, g_dbus_object_manager_get_object_path (G_DBUS_OBJECT_MANAGER (manager))); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gboolean handle_volume_group_create (CockpitStorageManager *object, GDBusMethodInvocation *invocation, const gchar *arg_name, const gchar *const *arg_blocks) { StorageManager *storage_manager = STORAGE_MANAGER(object); GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (storage_manager->daemon); GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server); if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN)) return TRUE; GError *error = NULL; int n_blocks = 0; for (int i = 0; arg_blocks[i]; i++) n_blocks += 1; const gchar *udisks_blocks[n_blocks + 1]; for (int i = 0; arg_blocks[i]; i++) { StorageObject *stobj = STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_blocks[i])); UDisksBlock *block = storage_object_get_udisks_block (stobj); if (block) udisks_blocks[i] = g_dbus_proxy_get_object_path (G_DBUS_PROXY(block)); else udisks_blocks[i] = "XXX"; } udisks_blocks[n_blocks] = NULL; if (storage_manager->lvm_manager == NULL) { g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "storaged daemon is not running"); return TRUE; } if (!lvm_manager_call_volume_group_create_sync (storage_manager->lvm_manager, arg_name, udisks_blocks, null_asv (), NULL, NULL, &error)) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); g_error_free (error); return TRUE; } cockpit_storage_manager_complete_volume_group_create (object, invocation); return TRUE; }
static void _setup_agent_and_adapters(GTlmNfc* self) { GError *error = NULL; /* Introspection data for the agent object we are exporting */ const gchar introspection_xml[] = "<node>" " <interface name='org.neard.NDEFAgent'>" " <method name='GetNDEF'>" " <arg type='a{sv}' name='values' direction='in'/>" " </method>" " <method name='Release'>" " </method>" " </interface>" "</node>"; const GDBusInterfaceVTable interface_vtable = { _handle_agent_method_call, _handle_agent_get_property, _handle_agent_set_property }; self->system_bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); if (self->system_bus == NULL) { g_debug ("Error getting a system bus: %s", error->message); g_error_free (error); return; } GDBusNodeInfo *introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL); self->agent_registration_id = g_dbus_connection_register_object (self->system_bus, "/org/tlmnfc/agent", introspection_data->interfaces[0], &interface_vtable, self, NULL, &error); if (self->agent_registration_id <= 0) { g_debug ("Error registering an agent object: %s", error->message); g_dbus_node_info_unref (introspection_data); g_error_free (error); return; } g_dbus_node_info_unref (introspection_data); GVariant* agent_register_response = g_dbus_connection_call_sync (self->system_bus, "org.neard", "/org/neard", "org.neard.AgentManager", "RegisterNDEFAgent", g_variant_new("(os)", "/org/tlmnfc/agent", "application/gtlm-nfc"), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (agent_register_response == NULL) { g_debug ("Error registering an agent with neard: %s", error->message); g_error_free (error); return; } g_variant_unref(agent_register_response); self->neard_manager = g_dbus_object_manager_client_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, "org.neard", "/", NULL, NULL, NULL, NULL, &error); if (self->neard_manager == NULL) { g_debug ("Error creating neard object manager: %s", error->message); g_error_free (error); return ; } // subscribe to interface added/removed signals g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager), "interface-added", G_CALLBACK (_on_interface_added), self); g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager), "interface-removed", G_CALLBACK (_on_interface_removed), self); g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager), "object-added", G_CALLBACK (_on_object_added), self); g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager), "object-removed", G_CALLBACK (_on_object_removed), self); g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager), "interface-proxy-properties-changed", G_CALLBACK (_on_property_changed), self); _setup_nfc_adapters(self); return; }
MMBearer * mmcli_get_bearer_sync (GDBusConnection *connection, const gchar *path_or_index, MMManager **o_manager, MMObject **o_object) { MMManager *manager; GList *modems; GList *l; MMBearer *found = NULL; gchar *bearer_path; bearer_path = get_bearer_path (path_or_index); manager = mmcli_get_manager_sync (connection); modems = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (manager)); if (!modems) { g_printerr ("error: couldn't find bearer at '%s': 'no modems found'\n", bearer_path); exit (EXIT_FAILURE); } for (l = modems; !found && l; l = g_list_next (l)) { GError *error = NULL; MMObject *object; MMModem *modem; GList *bearers; object = MM_OBJECT (l->data); modem = mm_object_get_modem (object); /* Don't look for bearers in modems which are not fully initialized */ if (mm_modem_get_state (modem) < MM_MODEM_STATE_DISABLED) { g_debug ("Skipping modem '%s' when looking for bearers " "(not fully initialized)", mm_object_get_path (object)); g_object_unref (modem); continue; } bearers = mm_modem_list_bearers_sync (modem, NULL, &error); if (error) { g_printerr ("error: couldn't list bearers at '%s': '%s'\n", mm_modem_get_path (modem), error->message); exit (EXIT_FAILURE); } found = find_bearer_in_list (bearers, bearer_path); g_list_free_full (bearers, (GDestroyNotify) g_object_unref); if (found && o_object) *o_object = g_object_ref (object); g_object_unref (modem); } if (!found) { g_printerr ("error: couldn't find bearer at '%s': 'not found in any modem'\n", bearer_path); exit (EXIT_FAILURE); } g_list_free_full (modems, (GDestroyNotify) g_object_unref); g_free (bearer_path); if (o_manager) *o_manager = manager; else g_object_unref (manager); return found; }
static gboolean handle_mdraid_create (CockpitStorageManager *object, GDBusMethodInvocation *invocation, const gchar *const *arg_blocks, const gchar *arg_level, const gchar *arg_name, guint64 arg_chunk) { StorageManager *storage_manager = STORAGE_MANAGER(object); GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (storage_manager->daemon); GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server); if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN)) return TRUE; GError *error = NULL; int n_blocks = 0; for (int i = 0; arg_blocks[i]; i++) n_blocks += 1; const gchar *udisks_blocks[n_blocks + 1]; for (int i = 0; arg_blocks[i]; i++) { StorageObject *stobj = STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_blocks[i])); UDisksBlock *block = storage_object_get_udisks_block (stobj); if (block) udisks_blocks[i] = g_dbus_proxy_get_object_path (G_DBUS_PROXY(block)); else udisks_blocks[i] = "XXX"; } udisks_blocks[n_blocks] = NULL; UDisksManager *manager = udisks_client_get_manager (storage_manager->udisks); if (manager == NULL) { g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "UDisks daemon is not running"); return TRUE; } GVariantBuilder options; g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}")); if (!udisks_manager_call_mdraid_create_sync (manager, udisks_blocks, arg_level, arg_name, arg_chunk, null_asv (), NULL, NULL, &error)) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); g_error_free (error); return TRUE; } cockpit_storage_manager_complete_mdraid_create (object, invocation); return TRUE; }
MMSms * mmcli_get_sms_sync (GDBusConnection *connection, const gchar *path_or_index, MMManager **o_manager, MMObject **o_object) { MMManager *manager; GList *modems; GList *l; MMSms *found = NULL; gchar *sms_path; sms_path = get_sms_path (path_or_index); manager = mmcli_get_manager_sync (connection); modems = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (manager)); if (!modems) { g_printerr ("error: couldn't find sms at '%s': 'no modems found'\n", sms_path); exit (EXIT_FAILURE); } for (l = modems; !found && l; l = g_list_next (l)) { GError *error = NULL; MMObject *object; MMModemMessaging *modem; GList *sms_list; object = MM_OBJECT (l->data); modem = mm_object_get_modem_messaging (object); /* If this modem doesn't implement messaging, continue to next one */ if (!modem) continue; sms_list = mm_modem_messaging_list_sync (modem, NULL, &error); if (error) { g_printerr ("error: couldn't list SMS at '%s': '%s'\n", mm_modem_messaging_get_path (modem), error->message); exit (EXIT_FAILURE); } found = find_sms_in_list (sms_list, sms_path); g_list_free_full (sms_list, (GDestroyNotify) g_object_unref); if (found && o_object) *o_object = g_object_ref (object); g_object_unref (modem); } if (!found) { g_printerr ("error: couldn't find SMS at '%s': 'not found in any modem'\n", sms_path); exit (EXIT_FAILURE); } g_list_free_full (modems, (GDestroyNotify) g_object_unref); g_free (sms_path); if (o_manager) *o_manager = manager; else g_object_unref (manager); return found; }
MMSim * mmcli_get_sim_sync (GDBusConnection *connection, const gchar *path_or_index, MMManager **o_manager, MMObject **o_object) { MMManager *manager; GList *modems; GList *l; MMSim *found = NULL; gchar *sim_path; sim_path = get_sim_path (path_or_index); manager = mmcli_get_manager_sync (connection); modems = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (manager)); if (!modems) { g_printerr ("error: couldn't find sim at '%s': 'no modems found'\n", sim_path); exit (EXIT_FAILURE); } for (l = modems; !found && l; l = g_list_next (l)) { GError *error = NULL; MMObject *object; MMModem *modem; object = MM_OBJECT (l->data); modem = mm_object_get_modem (object); if (g_str_equal (sim_path, mm_modem_get_sim_path (modem))) { found = mm_modem_get_sim_sync (modem, NULL, &error); if (error) { g_printerr ("error: couldn't get sim '%s' in modem '%s': '%s'\n", sim_path, mm_modem_get_path (modem), error->message); exit (EXIT_FAILURE); } if (found && o_object) *o_object = g_object_ref (object); } g_object_unref (modem); } if (!found) { g_printerr ("error: couldn't find sim at '%s'\n", sim_path); exit (EXIT_FAILURE); } g_list_free_full (modems, (GDestroyNotify) g_object_unref); g_free (sim_path); if (o_manager) *o_manager = manager; else g_object_unref (manager); return found; }
static void goa_daemon_update_notifications (GoaDaemon *daemon) { gboolean show_notification; GList *objects; GList *l; show_notification = FALSE; objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (daemon->object_manager)); for (l = objects; l != NULL; l = l->next) { GoaObject *object = GOA_OBJECT (l->data); GoaAccount *account; account = goa_object_peek_account (object); if (account != NULL) { if (goa_account_get_attention_needed (account)) { show_notification = TRUE; break; } } } if (show_notification) { if (daemon->notification == NULL) { GError *error; daemon->notification = notify_notification_new (_("An online account needs attention"), NULL, NULL); notify_notification_set_timeout (daemon->notification, NOTIFY_EXPIRES_NEVER); g_object_set (daemon->notification, "icon-name", "gtk-dialog-error", NULL); notify_notification_add_action (daemon->notification, "open-online-accounts", _("Open Online Accounts..."), notification_cb, daemon, NULL); /* GFreeFunc */ error = NULL; if (!notify_notification_show (daemon->notification, &error)) { goa_warning ("Error showing notification: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); g_object_unref (daemon->notification); daemon->notification = NULL; } else { g_signal_connect (daemon->notification, "closed", G_CALLBACK (on_notification_closed), daemon); } } } else { if (daemon->notification != NULL) { GError *error; error = NULL; if (!notify_notification_close (daemon->notification, &error)) { goa_warning ("Error closing notification: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); } g_signal_handlers_disconnect_by_func (daemon->notification, G_CALLBACK (on_notification_closed), daemon); g_object_unref (daemon->notification); daemon->notification = NULL; } } g_list_foreach (objects, (GFunc) g_object_unref, NULL); g_list_free (objects); }
/** * @brief find function by name handler * @param[in] object * @param[in] invocation * @param[in] function_name * @return true if metod handled */ static gboolean handle_find_function_by_name(GadgetdGadgetFunctionManager *object, GDBusMethodInvocation *invocation, const gchar *type, const gchar *instance) { const gchar *path = NULL; const gchar *msg; gchar _cleanup_g_free_ *function_name = NULL; GadgetDaemon *daemon; GDBusObjectManager *object_manager; GList *objects; GList *l; struct gd_function *gd_func; GadgetFunctionManager *func_manager = GADGET_FUNCTION_MANAGER(object); INFO("find function by name handler"); daemon = gadget_function_manager_get_daemon(GADGET_FUNCTION_MANAGER(object)); if (daemon == NULL) { msg = "Failed to get daemon"; goto out2; } object_manager = G_DBUS_OBJECT_MANAGER(gadget_daemon_get_object_manager(daemon)); if (object_manager == NULL) { ERROR("Failed to get object manager"); goto out2; } msg = "Failed to find function"; objects = g_dbus_object_manager_get_objects(object_manager); for (l = objects; l != NULL; l = l->next) { GadgetdObject *gobj = GADGETD_OBJECT (l->data); path = g_dbus_object_get_object_path(G_DBUS_OBJECT(gobj)); if (!GADGETD_IS_FUNCTION_OBJECT(G_DBUS_OBJECT(gobj)) || !g_str_has_prefix(path, func_manager->gadget_path)) continue; gd_func = gadgetd_function_object_get_function(GADGETD_FUNCTION_OBJECT(gobj)); if (gd_func == NULL) { msg = "Failed to get function"; break; } if (g_strcmp0(gd_func->type, type) == 0 && (strcmp(gd_func->instance, instance)== 0)) { path = g_dbus_object_get_object_path(G_DBUS_OBJECT(gobj)); msg = NULL; goto out; } } if (path == NULL) msg = "Failed to find function"; g_list_foreach(objects, (GFunc)g_object_unref, NULL); g_list_free(objects); out2: if (msg != NULL) { ERROR("%s", msg); g_dbus_method_invocation_return_dbus_error(invocation, func_manager_iface, msg); return TRUE; } out: /* send gadget path */ g_dbus_method_invocation_return_value(invocation, g_variant_new("(o)", path)); return TRUE; }
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); }
/** * 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; }
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); }