static void
on_name_lost(GDBusConnection *connection,
const gchar *name,
gpointer object)
{
g_dbus_object_manager_server_unexport(manager, dbus_object_path);
}
static void
remove_modem (MMManager *manager,
MMBaseModem *modem)
{
gchar *path;
gchar *device;
device = g_strdup (mm_base_modem_get_device (modem));
path = g_strdup (g_dbus_object_get_object_path (G_DBUS_OBJECT (modem)));
/* If we get DBus object path, modem was exported */
if (path) {
g_dbus_object_manager_server_unexport (manager->priv->object_manager, path);
g_object_set (modem,
MM_BASE_MODEM_CONNECTION, NULL,
NULL);
mm_dbg ("Unexported modem '%s' from path '%s'", device, path);
g_free (path);
} else {
mm_dbg ("Removing modem '%s', which wasn't exported yet", device);
}
/* Run dispose before unref-ing, in order to cleanup the SIM object,
* if any (which also holds a reference to the modem object) */
g_object_run_dispose (G_OBJECT (modem));
g_hash_table_remove (manager->priv->modems, device);
g_free (device);
}
static void
terminal_app_dbus_unregister (GApplication *application,
GDBusConnection *connection,
const gchar *object_path)
{
TerminalApp *app = TERMINAL_APP (application);
if (app->object_manager) {
g_dbus_object_manager_server_unexport (app->object_manager, TERMINAL_FACTORY_OBJECT_PATH);
g_object_unref (app->object_manager);
app->object_manager = NULL;
}
#ifdef ENABLE_SEARCH_PROVIDER
if (app->search_provider) {
terminal_search_provider_dbus_unregister (app->search_provider, connection, TERMINAL_SEARCH_PROVIDER_PATH);
g_object_unref (app->search_provider);
app->search_provider = NULL;
}
#endif /* ENABLE_SEARCH_PROVIDER */
G_APPLICATION_CLASS (terminal_app_parent_class)->dbus_unregister (application,
connection,
object_path);
}
static void
on_job_completed (UDisksJob *job,
gboolean success,
const gchar *message,
gpointer user_data)
{
StorageDaemon *self = STORAGE_DAEMON (user_data);
GDBusObject *object;
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (job));
g_assert (object != NULL);
/* Unexport job */
g_dbus_object_manager_server_unexport (self->object_manager,
g_dbus_object_get_object_path (object));
/* free the allocated job object */
g_object_unref (job);
/* returns the reference we took when connecting to the
* UDisksJob::completed signal in storage_daemon_launch_{spawned,threaded}_job()
* below
*/
g_object_unref (self);
g_assert (self->num_jobs > 0);
self->num_jobs--;
maybe_finished (self);
}
static gboolean
on_handle_delete_object (TestFrobber *object,
GDBusMethodInvocation *invocation,
const gchar *path,
gpointer user_data)
{
MockData *data = user_data;
GDBusObject *previous;
previous = g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (data->object_manager), path);
if (previous != NULL)
{
g_warn_if_fail (g_dbus_object_manager_server_unexport (data->object_manager, path));
test_frobber_complete_delete_object (object, invocation);
g_object_unref (previous);
}
else
{
g_dbus_method_invocation_return_error (invocation,
G_IO_ERROR, G_IO_ERROR_FAILED,
"Sorry, there is no object at %s",
path);
}
return TRUE;
}
/*
** DBus event: An instance bus vanished
** - Create a timeout watch
** - Unwatch the instance bus
*/
static void on_instance_name_vanished(GDBusConnection *conn,
const gchar *name,
gpointer user_data)
{
struct watch_instance *watch = user_data;
gchar *service_path = NULL;
gboolean service_exists = FALSE;
g_print("Instance vanished: %s\n", watch->name);
g_dbus_object_manager_server_unexport(manager, watch->path);
service_path = get_service_file_path(watch->name);
service_exists = g_file_test(service_path, G_FILE_TEST_EXISTS);
g_free(service_path);
if (service_exists == FALSE)
{
g_print("No more service file: %s\n", watch->name);
watch_instance_free(watch);
}
else
{
g_print("Trying to restart: %s\n", name);
watch->timeout_id = g_timeout_add_seconds(
300,
on_instance_timeout,
watch);
autolaunch_process_by_busname(watch->name);
}
}
static gboolean neardal_agent_prv_remove(gchar *objPath)
{
g_assert(objPath != NULL);
NEARDAL_TRACEIN();
return g_dbus_object_manager_server_unexport(neardalMgr.agentMgr
, objPath);
}
void
storage_daemon_unpublish (StorageDaemon *self,
const gchar *path,
gpointer thing)
{
GDBusObject *object;
gboolean unexport = FALSE;
GList *interfaces, *l;
g_return_if_fail (STORAGE_IS_DAEMON (self));
g_return_if_fail (path != NULL);
object = g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (self->object_manager), path);
if (object == NULL)
return;
path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object));
if (G_IS_DBUS_INTERFACE (thing))
{
g_debug ("unpublishing interface: %s %s", path,
g_dbus_interface_get_info(thing)->name);
unexport = TRUE;
interfaces = g_dbus_object_get_interfaces (object);
for (l = interfaces; l != NULL; l = g_list_next (l))
{
if (G_DBUS_INTERFACE (l->data) != G_DBUS_INTERFACE (thing))
unexport = FALSE;
}
g_list_free_full (interfaces, g_object_unref);
/*
* HACK: GDBusObjectManagerServer is broken ... and sends InterfaceRemoved
* too many times, if you remove all interfaces manually, and then unexport
* a GDBusObject. So only do it here if we're not unexporting the object.
*/
if (!unexport)
g_dbus_object_skeleton_remove_interface (G_DBUS_OBJECT_SKELETON (object), thing);
else
g_debug ("(unpublishing object, too)");
}
else if (thing == NULL)
{
unexport = TRUE;
}
else
{
g_critical ("Unsupported type to unpublish: %s", G_OBJECT_TYPE_NAME (thing));
}
if (unexport)
g_dbus_object_manager_server_unexport (self->object_manager, path);
g_object_unref (object);
}
static void
on_device_removed (ClutterDeviceManager *device_manager,
ClutterInputDevice *device,
GDBusObjectManagerServer *manager)
{
int device_id;
char *path;
device_id = clutter_input_device_get_device_id (device);
path = g_strdup_printf ("/org/gnome/Mutter/IdleMonitor/Device%d", device_id);
g_dbus_object_manager_server_unexport (manager, path);
g_free (path);
}
void
storaged_linux_volume_group_object_destroy (StoragedLinuxVolumeGroupObject *object)
{
GHashTableIter volume_iter;
gpointer key, value;
g_hash_table_iter_init (&volume_iter, object->logical_volumes);
while (g_hash_table_iter_next (&volume_iter, &key, &value))
{
StoragedLinuxLogicalVolumeObject *volume = value;
g_dbus_object_manager_server_unexport (storaged_daemon_get_object_manager (object->daemon),
g_dbus_object_get_object_path (G_DBUS_OBJECT (volume)));
}
}
void
setting_unexport (Setting *setting)
{
g_return_if_fail (IS_SETTING (setting));
GDBusObjectManagerServer *object_manager;
GDBusObject *object;
object_manager = daemon_get_object_manager (setting->daemon);
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (setting));
if (object != NULL)
g_dbus_object_manager_server_unexport (object_manager,
g_dbus_object_get_object_path (object));
}
static void
user_removed (ActUserManager *um,
ActUser *user,
Accounts *accounts)
{
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon_get ());
Account *acc = g_hash_table_lookup (accounts->act_user_to_account, user);
if (acc)
{
account_update (acc, NULL);
g_dbus_object_manager_server_unexport (object_manager_server,
g_dbus_object_get_object_path (g_dbus_interface_get_object (G_DBUS_INTERFACE (acc))));
g_hash_table_remove (accounts->act_user_to_account, user);
}
}
static void
terminal_app_dbus_unregister (GApplication *application,
GDBusConnection *connection,
const gchar *object_path)
{
TerminalApp *app = TERMINAL_APP (application);
if (app->object_manager) {
g_dbus_object_manager_server_unexport (app->object_manager, TERMINAL_FACTORY_OBJECT_PATH);
g_object_unref (app->object_manager);
app->object_manager = NULL;
}
G_APPLICATION_CLASS (terminal_app_parent_class)->dbus_unregister (application,
connection,
object_path);
}
static void
screen_destroy_cb (GObject *screen,
gpointer user_data)
{
GDBusObjectManagerServer *object_manager;
GDBusObjectSkeleton *skeleton;
const char *object_path;
skeleton = g_object_get_data (screen, RECEIVER_IMPL_SKELETON_DATA_KEY);
if (skeleton == NULL)
return;
object_manager = terminal_app_get_object_manager (terminal_app_get ());
object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (skeleton));
g_dbus_object_manager_server_unexport (object_manager, object_path);
g_object_set_data (screen, RECEIVER_IMPL_SKELETON_DATA_KEY, NULL);
}
static void
maybe_remove_mdraid_object (UDisksLinuxProvider *provider,
UDisksLinuxMDRaidObject *object)
{
gchar *object_uuid = NULL;
UDisksDaemon *daemon = NULL;
/* remove the object only if there are no devices left */
if (udisks_linux_mdraid_object_have_devices (object))
goto out;
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
object_uuid = g_strdup (udisks_linux_mdraid_object_get_uuid (object));
g_dbus_object_manager_server_unexport (udisks_daemon_get_object_manager (daemon),
g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
g_warn_if_fail (g_hash_table_remove (provider->uuid_to_mdraid, object_uuid));
out:
g_free (object_uuid);
}
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;
}
/* called with lock held */
static void
handle_block_uevent_for_block (UDisksLinuxProvider *provider,
const gchar *action,
UDisksLinuxDevice *device)
{
const gchar *sysfs_path;
UDisksLinuxBlockObject *object;
UDisksDaemon *daemon;
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
sysfs_path = g_udev_device_get_sysfs_path (device->udev_device);
if (g_strcmp0 (action, "remove") == 0)
{
object = g_hash_table_lookup (provider->sysfs_to_block, sysfs_path);
if (object != NULL)
{
g_dbus_object_manager_server_unexport (udisks_daemon_get_object_manager (daemon),
g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
g_warn_if_fail (g_hash_table_remove (provider->sysfs_to_block, sysfs_path));
}
}
else
{
object = g_hash_table_lookup (provider->sysfs_to_block, sysfs_path);
if (object != NULL)
{
udisks_linux_block_object_uevent (object, action, device);
}
else
{
object = udisks_linux_block_object_new (daemon, device);
g_dbus_object_manager_server_export_uniquely (udisks_daemon_get_object_manager (daemon),
G_DBUS_OBJECT_SKELETON (object));
g_hash_table_insert (provider->sysfs_to_block, g_strdup (sysfs_path), object);
}
}
}
/**
* g_dbus_object_manager_server_export:
* @manager: A #GDBusObjectManagerServer.
* @object: A #GDBusObjectSkeleton.
*
* Exports @object on @manager.
*
* If there is already a #GDBusObject exported at the object path,
* then the old object is removed.
*
* The object path for @object must be in the hierarchy rooted by the
* object path for @manager.
*
* Note that @manager will take a reference on @object for as long as
* it is exported.
*
* Since: 2.30
*/
void
g_dbus_object_manager_server_export (GDBusObjectManagerServer *manager,
GDBusObjectSkeleton *object)
{
RegistrationData *data;
GList *existing_interfaces;
GList *l;
GPtrArray *interface_names;
const gchar *object_path;
object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object));
g_return_if_fail (G_IS_DBUS_OBJECT_MANAGER_SERVER (manager));
g_return_if_fail (G_IS_DBUS_OBJECT (object));
g_return_if_fail (g_str_has_prefix (object_path, manager->priv->object_path_ending_in_slash));
interface_names = g_ptr_array_new ();
data = g_hash_table_lookup (manager->priv->map_object_path_to_data, object_path);
if (data != NULL)
g_dbus_object_manager_server_unexport (manager, object_path);
data = g_new0 (RegistrationData, 1);
data->object = g_object_ref (object);
data->manager = manager;
data->map_iface_name_to_iface = g_hash_table_new_full (g_str_hash,
g_str_equal,
NULL,
(GDestroyNotify) g_object_unref);
g_signal_connect (object,
"interface-added",
G_CALLBACK (on_interface_added),
data);
g_signal_connect (object,
"interface-removed",
G_CALLBACK (on_interface_removed),
data);
/* Register all known interfaces - note that data->exported is FALSE so
* we don't emit any InterfacesAdded signals.
*/
existing_interfaces = g_dbus_object_get_interfaces (G_DBUS_OBJECT (object));
for (l = existing_interfaces; l != NULL; l = l->next)
{
GDBusInterfaceSkeleton *interface_skeleton = G_DBUS_INTERFACE_SKELETON (l->data);
registration_data_export_interface (data, interface_skeleton);
g_ptr_array_add (interface_names, g_dbus_interface_skeleton_get_info (interface_skeleton)->name);
}
g_list_foreach (existing_interfaces, (GFunc) g_object_unref, NULL);
g_list_free (existing_interfaces);
g_ptr_array_add (interface_names, NULL);
data->exported = TRUE;
/* now emit InterfacesAdded() for all the interfaces */
g_dbus_object_manager_server_emit_interfaces_added (manager, data, (const gchar *const *) interface_names->pdata);
g_ptr_array_unref (interface_names);
g_hash_table_insert (manager->priv->map_object_path_to_data,
g_strdup (object_path),
data);
}
static void
provider_update_objects (StorageProvider *provider)
{
GDBusObjectManagerServer *object_manager;
GList *udisks_objects;
GList *lvm_objects;
GList *wanted;
GList *added, *removed;
GList *l;
object_manager = G_DBUS_OBJECT_MANAGER_SERVER (daemon_get_object_manager (provider->daemon));
udisks_objects = g_dbus_object_manager_get_objects (udisks_client_get_object_manager (provider->udisks_client));
lvm_objects = g_dbus_object_manager_get_objects (provider->lvm_objman);
wanted = NULL;
for (l = udisks_objects; l != NULL; l = l->next)
{
GDBusInterface *iface = get_udisk_iface (UDISKS_OBJECT (l->data));
if (iface == NULL)
continue;
wanted = g_list_prepend (wanted, g_object_ref (iface));
}
for (l = lvm_objects; l != NULL; l = l->next)
{
if (!LVM_IS_OBJECT (l->data))
continue;
GDBusInterface *iface = get_lvm_iface (LVM_OBJECT (l->data));
if (iface == NULL)
continue;
wanted = g_list_prepend (wanted, g_object_ref (iface));
}
wanted = g_list_sort (wanted, (GCompareFunc)udisks_iface_compare_func);
provider->ifaces = g_list_sort (provider->ifaces, (GCompareFunc)udisks_iface_compare_func);
diff_sorted_lists (provider->ifaces, wanted, (GCompareFunc)udisks_iface_compare_func,
&added, &removed, NULL);
for (l = removed; l != NULL; l = l->next)
{
GDBusInterface *iface = G_DBUS_INTERFACE (l->data);
StorageObject *object;
object = g_hash_table_lookup (provider->hash_interface_to_storage_object, iface);
g_warn_if_fail (object != NULL);
if (object)
{
g_warn_if_fail (g_dbus_object_manager_server_unexport (object_manager,
g_dbus_object_get_object_path (G_DBUS_OBJECT (object))));
}
g_hash_table_remove (provider->hash_interface_to_storage_object, iface);
provider->ifaces = g_list_remove (provider->ifaces, iface);
g_object_unref (iface);
}
for (l = added; l != NULL; l = l->next)
{
GDBusInterface *iface = G_DBUS_INTERFACE (l->data);
StorageObject *object = make_storage_object (provider, iface);
g_warn_if_fail (g_hash_table_lookup (provider->hash_interface_to_storage_object, iface) == NULL);
g_hash_table_insert (provider->hash_interface_to_storage_object,
g_object_ref (iface),
object);
gs_free gchar *object_path = storage_object_make_object_path (object);
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), object_path);
g_dbus_object_manager_server_export_uniquely (object_manager, G_DBUS_OBJECT_SKELETON (object));
provider->ifaces = g_list_prepend (provider->ifaces, g_object_ref (iface));
}
g_list_free (added);
g_list_free (removed);
g_list_free_full (udisks_objects, g_object_unref);
g_list_free_full (lvm_objects, g_object_unref);
g_list_free_full (wanted, g_object_unref);
}
static void
provider_update_jobs (StorageProvider *provider)
{
GDBusObjectManagerServer *object_manager;
GList *udisks_objects;
GList *lvm_objects;
GList *all_objects;
GList *wanted;
GList *added, *removed;
GList *l;
object_manager = G_DBUS_OBJECT_MANAGER_SERVER (daemon_get_object_manager (provider->daemon));
udisks_objects = g_dbus_object_manager_get_objects (udisks_client_get_object_manager (provider->udisks_client));
lvm_objects = g_dbus_object_manager_get_objects (provider->lvm_objman);
all_objects = g_list_concat (udisks_objects, lvm_objects);
wanted = NULL;
for (l = all_objects; l != NULL; l = l->next)
{
if (!UDISKS_IS_OBJECT (l->data))
continue;
UDisksObject *object = UDISKS_OBJECT (l->data);
UDisksJob *job;
job = udisks_object_peek_job (object);
if (job == NULL)
continue;
const gchar *operation = udisks_job_get_operation (job);
if (strcmp (operation, "format-mkfs") != 0
&& strcmp (operation, "format-erase") != 0
&& strcmp (operation, "lvm-vg-empty-device") != 0)
continue;
wanted = g_list_prepend (wanted, g_object_ref (job));
}
wanted = g_list_sort (wanted, (GCompareFunc)_udisks_job_compare_func);
provider->jobs = g_list_sort (provider->jobs, (GCompareFunc)_udisks_job_compare_func);
diff_sorted_lists (provider->jobs, wanted, (GCompareFunc)_udisks_job_compare_func,
&added, &removed, NULL);
for (l = removed; l != NULL; l = l->next)
{
UDisksJob *job = UDISKS_JOB (l->data);
CockpitJob *object;
object = g_hash_table_lookup (provider->hash_job_to_storage_job, job);
if (object == NULL)
{
g_warning ("No object for job %p", job);
}
else
{
g_warn_if_fail (g_dbus_object_manager_server_unexport (object_manager,
g_dbus_object_get_object_path (G_DBUS_OBJECT (object))));
g_hash_table_remove (provider->hash_job_to_storage_job, job);
}
provider->jobs = g_list_remove (provider->jobs, job);
g_object_unref (job);
}
for (l = added; l != NULL; l = l->next)
{
UDisksJob *job = UDISKS_JOB (l->data);
CockpitObjectSkeleton *object;
CockpitJob *cockpit_job;
gchar *object_path;
object_path = utils_generate_object_path ("/com/redhat/Cockpit/Jobs",
udisks_job_get_operation (job));
cockpit_job = storage_job_new (provider, job);
object = cockpit_object_skeleton_new (object_path);
cockpit_object_skeleton_set_job (object, cockpit_job);
g_object_unref (cockpit_job);
g_free (object_path);
g_warn_if_fail (g_hash_table_lookup (provider->hash_job_to_storage_job, job) == NULL);
g_hash_table_insert (provider->hash_job_to_storage_job,
g_object_ref (job),
object);
g_dbus_object_manager_server_export_uniquely (object_manager, G_DBUS_OBJECT_SKELETON (object));
provider->jobs = g_list_prepend (provider->jobs, g_object_ref (job));
}
g_list_free (added);
g_list_free (removed);
g_list_free_full (all_objects, g_object_unref);
g_list_free_full (wanted, g_object_unref);
}
static void
lvm_update_vgs (GObject *source_obj,
GAsyncResult *result,
gpointer user_data)
{
UDisksLVM2State *state;
UDisksDaemon *daemon = UDISKS_DAEMON (source_obj);
GDBusObjectManagerServer *manager;
GTask *task = G_TASK (result);
GError *error = NULL;
VGsPVsData *data = g_task_propagate_pointer (task, &error);
BDLVMVGdata **vgs = NULL;
BDLVMPVdata **pvs = NULL;
GHashTableIter vg_name_iter;
gpointer key, value;
const gchar *vg_name;
if (!data)
{
if (error)
udisks_warning ("LVM2 plugin: %s", error->message);
else
/* this should never happen */
udisks_warning ("LVM2 plugin: failure but no error when getting VGs!");
return;
}
vgs = data->vgs;
pvs = data->pvs;
/* free the data container (but not 'vgs' and 'pvs') */
g_free (data);
manager = udisks_daemon_get_object_manager (daemon);
state = get_module_state (daemon);
/* Remove obsolete groups */
g_hash_table_iter_init (&vg_name_iter,
udisks_lvm2_state_get_name_to_volume_group (state));
while (g_hash_table_iter_next (&vg_name_iter, &key, &value))
{
UDisksLinuxVolumeGroupObject *group;
gboolean found = FALSE;
vg_name = key;
group = value;
for (BDLVMVGdata **vgs_p=vgs; !found && (*vgs_p); vgs_p++)
found = g_strcmp0 ((*vgs_p)->name, vg_name) == 0;
if (!found)
{
udisks_linux_volume_group_object_destroy (group);
g_dbus_object_manager_server_unexport (manager,
g_dbus_object_get_object_path (G_DBUS_OBJECT (group)));
g_hash_table_iter_remove (&vg_name_iter);
}
}
/* Add new groups and update existing groups */
for (BDLVMVGdata **vgs_p=vgs; *vgs_p; vgs_p++)
{
UDisksLinuxVolumeGroupObject *group;
GSList *vg_pvs = NULL;
vg_name = (*vgs_p)->name;
group = g_hash_table_lookup (udisks_lvm2_state_get_name_to_volume_group (state),
vg_name);
if (group == NULL)
{
group = udisks_linux_volume_group_object_new (daemon, vg_name);
g_hash_table_insert (udisks_lvm2_state_get_name_to_volume_group (state),
g_strdup (vg_name), group);
}
for (BDLVMPVdata **pvs_p=pvs; *pvs_p; pvs_p++)
if (g_strcmp0 ((*pvs_p)->vg_name, vg_name) == 0)
vg_pvs = g_slist_prepend (vg_pvs, *pvs_p);
udisks_linux_volume_group_object_update (group, *vgs_p, vg_pvs);
}
/* this is safe to do -- all BDLVMPVdata objects are still existing because
the function that frees them is scheduled in main loop by the
udisks_linux_volume_group_object_update() call above */
for (BDLVMPVdata **pvs_p=pvs; *pvs_p; pvs_p++)
if ((*pvs_p)->vg_name == NULL)
bd_lvm_pvdata_free (*pvs_p);
/* only free the containers, the contents were passed further */
g_free (vgs);
g_free (pvs);
}
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 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);
}
/* called with lock held */
static void
handle_block_uevent_for_drive (UDisksLinuxProvider *provider,
const gchar *action,
UDisksLinuxDevice *device)
{
UDisksLinuxDriveObject *object;
UDisksDaemon *daemon;
const gchar *sysfs_path;
gchar *vpd;
vpd = NULL;
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
sysfs_path = g_udev_device_get_sysfs_path (device->udev_device);
if (g_strcmp0 (action, "remove") == 0)
{
object = g_hash_table_lookup (provider->sysfs_path_to_drive, sysfs_path);
if (object != NULL)
{
GList *devices;
udisks_linux_drive_object_uevent (object, action, device);
g_warn_if_fail (g_hash_table_remove (provider->sysfs_path_to_drive, sysfs_path));
devices = udisks_linux_drive_object_get_devices (object);
if (devices == NULL)
{
const gchar *existing_vpd;
existing_vpd = g_object_get_data (G_OBJECT (object), "x-vpd");
g_dbus_object_manager_server_unexport (udisks_daemon_get_object_manager (daemon),
g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
g_warn_if_fail (g_hash_table_remove (provider->vpd_to_drive, existing_vpd));
}
g_list_foreach (devices, (GFunc) g_object_unref, NULL);
g_list_free (devices);
}
}
else
{
if (!udisks_linux_drive_object_should_include_device (provider->gudev_client, device, &vpd))
goto out;
if (vpd == NULL)
{
udisks_debug ("Ignoring block device %s with no serial or WWN",
g_udev_device_get_sysfs_path (device->udev_device));
goto out;
}
object = g_hash_table_lookup (provider->vpd_to_drive, vpd);
if (object != NULL)
{
if (g_hash_table_lookup (provider->sysfs_path_to_drive, sysfs_path) == NULL)
g_hash_table_insert (provider->sysfs_path_to_drive, g_strdup (sysfs_path), object);
udisks_linux_drive_object_uevent (object, action, device);
}
else
{
object = udisks_linux_drive_object_new (daemon, device);
if (object != NULL)
{
g_object_set_data_full (G_OBJECT (object), "x-vpd", g_strdup (vpd), g_free);
g_dbus_object_manager_server_export_uniquely (udisks_daemon_get_object_manager (daemon),
G_DBUS_OBJECT_SKELETON (object));
g_hash_table_insert (provider->vpd_to_drive, g_strdup (vpd), object);
g_hash_table_insert (provider->sysfs_path_to_drive, g_strdup (sysfs_path), object);
/* schedule initial housekeeping for the drive unless coldplugging */
if (!provider->coldplug)
{
g_io_scheduler_push_job (perform_initial_housekeeping_for_drive,
g_object_ref (object),
(GDestroyNotify) g_object_unref,
G_PRIORITY_DEFAULT,
NULL);
}
}
}
}
out:
g_free (vpd);
}
