static void
update_block (StoragedLinuxBlockObject *block_object,
StoragedLinuxVolumeGroupObject *group_object,
GHashTable *new_lvs,
GHashTable *new_pvs)
{
StoragedBlock *block;
GVariant *pv_info;
block = storaged_object_peek_block (STORAGED_OBJECT (block_object));
if (block == NULL)
return;
// XXX - move this elsewhere?
{
StoragedLinuxDevice *device;
StoragedLinuxLogicalVolumeObject *lv_object;
const gchar *block_vg_name;
const gchar *block_lv_name;
device = storaged_linux_block_object_get_device (block_object);
if (device)
{
block_vg_name = g_udev_device_get_property (device->udev_device, "DM_VG_NAME");
block_lv_name = g_udev_device_get_property (device->udev_device, "DM_LV_NAME");
if (g_strcmp0 (block_vg_name, storaged_linux_volume_group_object_get_name (group_object)) == 0
&& (lv_object = g_hash_table_lookup (new_lvs, block_lv_name)))
{
block_object_update_lvm_iface (block_object, g_dbus_object_get_object_path (G_DBUS_OBJECT (lv_object)));
}
}
}
pv_info = g_hash_table_lookup (new_pvs, storaged_block_get_device (block));
if (!pv_info)
{
const gchar *const *symlinks;
int i;
symlinks = storaged_block_get_symlinks (block);
for (i = 0; symlinks[i]; i++)
{
pv_info = g_hash_table_lookup (new_pvs, symlinks[i]);
if (pv_info)
break;
}
}
if (pv_info)
{
storaged_linux_block_object_update_lvm_pv (block_object, group_object, pv_info);
}
else
{
StoragedPhysicalVolume *pv = storaged_object_peek_physical_volume (STORAGED_OBJECT (block_object));
if (pv && g_strcmp0 (storaged_physical_volume_get_volume_group (pv),
g_dbus_object_get_object_path (G_DBUS_OBJECT (group_object))) == 0)
storaged_linux_block_object_update_lvm_pv (block_object, NULL, NULL);
}
}
static gboolean
teardown_logical_volume (UDisksLogicalVolume *volume,
UDisksDaemon *daemon,
GDBusMethodInvocation *invocation,
GVariant *options,
GError **error)
{
GDBusObject *volume_object;
UDisksObject *group_object;
UDisksVolumeGroup *group;
UDisksLogicalVolume *sibling_volume;
GList *siblings;
GList *l;
if (!udisks_linux_logical_volume_teardown_block (volume,
daemon,
invocation,
options,
error))
return FALSE;
/* Recurse for pool members and snapshots.
*/
volume_object = g_dbus_interface_get_object (G_DBUS_INTERFACE (volume));
group_object = udisks_daemon_find_object (daemon, udisks_logical_volume_get_volume_group (volume));
if (volume_object && group_object)
{
group = udisks_object_peek_volume_group (group_object);
if (group)
{
siblings = udisks_linux_volume_group_get_logical_volumes (group, daemon);
for (l = siblings; l; l = l->next)
{
sibling_volume = UDISKS_LOGICAL_VOLUME (l->data);
if (g_strcmp0 (udisks_logical_volume_get_thin_pool (sibling_volume),
g_dbus_object_get_object_path (volume_object)) == 0 ||
g_strcmp0 (udisks_logical_volume_get_origin (sibling_volume),
g_dbus_object_get_object_path (volume_object)) == 0)
{
if (!teardown_logical_volume (sibling_volume,
daemon,
invocation,
options,
error))
{
g_list_free_full (siblings, g_object_unref);
return FALSE;
}
}
}
g_list_free_full (siblings, g_object_unref);
}
}
return TRUE;
}
void _on_interface_added(GDBusObjectManager *manager,
GDBusObject *object,
GDBusInterface *interface,
gpointer user_data)
{
GTlmNfc* self = GTLM_NFC(user_data);
GDBusProxy* proxy = G_DBUS_PROXY(interface);
g_debug("Object %s added interface %s",
g_dbus_object_get_object_path (object),
g_dbus_proxy_get_interface_name (proxy));
if (g_strcmp0(g_dbus_proxy_get_interface_name (proxy),
"org.neard.Adapter") == 0) {
_setup_nfc_adapter(self, proxy);
return;
}
if (g_strcmp0(g_dbus_proxy_get_interface_name (proxy),
"org.neard.Tag") == 0) {
g_signal_emit(self, signals[SIG_TAG_FOUND], 0, g_dbus_object_get_object_path (object));
return;
}
if (g_strcmp0(g_dbus_proxy_get_interface_name (proxy),
"org.neard.Record") == 0) {
GVariant* type_v = g_dbus_proxy_get_cached_property(proxy, "Type");
if (type_v == NULL || !g_variant_is_of_type(type_v, G_VARIANT_TYPE_STRING)) {
g_debug("Type property is absent on a record");
g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0);
return;
}
const gchar* type = g_variant_get_string(type_v, NULL);
g_debug("Record has type %s", type);
if (g_strcmp0(type, "MIME") != 0) {
g_variant_unref(type_v);
g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0);
return;
}
g_variant_unref(type_v);
GVariant* mimetype_v = g_dbus_proxy_get_cached_property(proxy, "MIME");
if (mimetype_v == NULL || !g_variant_is_of_type(type_v, G_VARIANT_TYPE_STRING)) {
g_debug("MIME property is absent on a record");
g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0);
return;
}
const gchar* mimetype = g_variant_get_string(mimetype_v, NULL);
g_debug("Record has MIME type %s", mimetype);
if (g_strcmp0(mimetype, "application/gtlm-nfc") != 0) {
g_variant_unref(mimetype_v);
g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0);
return;
}
g_variant_unref(mimetype_v);
}
}
static void
ensure_credentials_cb (GoaProvider *provider,
GAsyncResult *res,
gpointer user_data)
{
EnsureData *data = user_data;
gint expires_in;
GError *error;
error= NULL;
if (!goa_provider_ensure_credentials_finish (provider, &expires_in, res, &error))
{
/* Set AttentionNeeded only if the error is an authorization error */
if (is_authorization_error (error))
{
GoaAccount *account;
account = goa_object_peek_account (data->object);
if (!goa_account_get_attention_needed (account))
{
goa_account_set_attention_needed (account, TRUE);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (account));
g_message ("%s: Setting AttentionNeeded to TRUE because EnsureCredentials() failed with: %s (%s, %d)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object)),
error->message, g_quark_to_string (error->domain), error->code);
}
}
g_dbus_method_invocation_return_gerror (data->invocation, error);
g_error_free (error);
}
else
{
GoaAccount *account;
account = goa_object_peek_account (data->object);
/* Clear AttentionNeeded flag if set */
if (goa_account_get_attention_needed (account))
{
goa_account_set_attention_needed (account, FALSE);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (account));
g_message ("%s: Setting AttentionNeeded to FALSE because EnsureCredentials() succeded\n",
g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object)));
}
goa_account_complete_ensure_credentials (goa_object_peek_account (data->object),
data->invocation,
expires_in);
}
ensure_data_unref (data);
}
/* Runs in housekeeping thread - called without lock held */
static void
housekeeping_all_drives (UDisksLinuxProvider *provider,
guint secs_since_last)
{
GList *objects;
GList *l;
G_LOCK (provider_lock);
objects = g_hash_table_get_values (provider->vpd_to_drive);
g_list_foreach (objects, (GFunc) g_object_ref, NULL);
G_UNLOCK (provider_lock);
for (l = objects; l != NULL; l = l->next)
{
UDisksLinuxDriveObject *object = UDISKS_LINUX_DRIVE_OBJECT (l->data);
GError *error;
error = NULL;
if (!udisks_linux_drive_object_housekeeping (object,
secs_since_last,
NULL, /* TODO: cancellable */
&error))
{
udisks_warning ("Error performing housekeeping for drive %s: %s (%s, %d)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (object)),
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
}
}
g_list_foreach (objects, (GFunc) g_object_unref, NULL);
g_list_free (objects);
}
static void
on_interface_proxy_properties_changed (GDBusObjectManager *manager,
GDBusObjectProxy *object_proxy,
GDBusProxy *interface_proxy,
GVariant *changed_properties,
const gchar * const *invalidated_properties,
gpointer user_data)
{
CockpitDBusJson1 *self = user_data;
cleanup_unref_object JsonBuilder *builder = prepare_builder ("interface-properties-changed");
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "objpath");
json_builder_add_string_value (builder, g_dbus_object_get_object_path (G_DBUS_OBJECT (object_proxy)));
json_builder_set_member_name (builder, "iface_name");
json_builder_add_string_value (builder, g_dbus_proxy_get_interface_name (interface_proxy));
/* It's a bit of a waste to send all properties - would be cheaper to just
* send @changed_properties and @invalidated_properties. But this is simpler.
*/
json_builder_set_member_name (builder, "iface");
json_builder_begin_object (builder);
add_interface (builder, G_DBUS_INTERFACE (interface_proxy), changed_properties);
json_builder_end_object (builder);
json_builder_end_object (builder);
write_builder (self, builder);
}
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 void
handle_format_complete (gpointer user_data)
{
struct FormatCompleteData *data = user_data;
storaged_partition_table_complete_create_partition
(data->table, data->invocation, g_dbus_object_get_object_path (G_DBUS_OBJECT (data->partition_object)));
}
/* runs in thread dedicated to handling @invocation */
static gboolean
handle_create_partition (StoragedPartitionTable *table,
GDBusMethodInvocation *invocation,
guint64 offset,
guint64 size,
const gchar *type,
const gchar *name,
GVariant *options)
{
StoragedObject *partition_object =
storaged_linux_partition_table_handle_create_partition (table,
invocation,
offset,
size,
type,
name,
options);
if (partition_object)
{
storaged_partition_table_complete_create_partition
(table, invocation, g_dbus_object_get_object_path (G_DBUS_OBJECT (partition_object)));
g_object_unref (partition_object);
}
return TRUE; /* returning TRUE means that we handled the method invocation */
}
static void
enterprise_add_realm (GisAccountPageEnterprise *page,
UmRealmObject *realm)
{
GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page);
GtkTreeIter iter;
gchar *name;
name = realm_get_name (realm);
/*
* Don't add a second realm if we already have one with this name.
* Sometimes realmd returns two realms for the same name, if it has
* different ways to use that realm. The first one that realmd
* returns is the one it prefers.
*/
if (!model_contains_realm (GTK_TREE_MODEL (priv->realms_model), name)) {
gtk_list_store_append (GTK_LIST_STORE (priv->realms_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (priv->realms_model), &iter,
0, name,
1, realm,
-1);
if (!priv->domain_chosen && um_realm_is_configured (realm))
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->domain), &iter);
g_debug ("added realm to drop down: %s %s", name,
g_dbus_object_get_object_path (G_DBUS_OBJECT (realm)));
}
g_free (name);
}
static gboolean
cleanup_logical_volume_walker (GDBusObjectManager *objman,
LvmLogicalVolume *logical_volume,
gpointer user_data,
GError **error)
{
StorageProvider *provider = user_data;
UDisksBlock *block = lvm_util_peek_block_for_logical_volume (storage_provider_get_lvm_object_manager (provider),
storage_provider_get_udisks_client (provider),
logical_volume);
if (block)
{
/* The logical volume is active, let's clean it up by walking
the tree of block devices hanging off of it.
*/
return cleanup_block (provider, block, error);
}
else
{
/* The logical volume is inactive, let's clean it up by removing
the remembered configs from its children.
*/
LvmObject *object = LVM_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (logical_volume)));
GList *remembered_configs = storage_provider_get_and_forget_remembered_configs
(provider, g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
for (GList *l = remembered_configs; l; l = l->next)
{
GVariant *config = l->data;
storage_remove_config (provider, NULL, config);
}
g_list_free_full (remembered_configs, (GDestroyNotify)g_variant_unref);
return TRUE;
}
}
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
g_dbus_object_manager_server_emit_interfaces_removed (GDBusObjectManagerServer *manager,
RegistrationData *data,
const gchar *const *interfaces)
{
GVariantBuilder array_builder;
GError *error;
guint n;
const gchar *object_path;
if (data->manager->priv->connection == NULL)
goto out;
g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
for (n = 0; interfaces[n] != NULL; n++)
g_variant_builder_add (&array_builder, "s", interfaces[n]);
error = NULL;
object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object));
g_dbus_connection_emit_signal (data->manager->priv->connection,
NULL, /* destination_bus_name */
manager->priv->object_path,
manager_interface_info.name,
"InterfacesRemoved",
g_variant_new ("(oas)",
object_path,
&array_builder),
&error);
g_assert_no_error (error);
out:
;
}
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 UDisksObject *
wait_for_logical_volume_block_object (UDisksDaemon *daemon,
gpointer user_data)
{
UDisksLinuxLogicalVolumeObject *volume_object = user_data;
const gchar *volume_objpath;
GList *objects, *l;
UDisksObject *ret = NULL;
volume_objpath = g_dbus_object_get_object_path (G_DBUS_OBJECT (volume_object));
objects = udisks_daemon_get_objects (daemon);
for (l = objects; l != NULL; l = l->next)
{
UDisksObject *object = UDISKS_OBJECT (l->data);
UDisksBlockLVM2 *block;
block = udisks_object_peek_block_lvm2 (object);
if (block == NULL)
continue;
if (g_strcmp0 (udisks_block_lvm2_get_logical_volume (block), volume_objpath) == 0)
{
ret = g_object_ref (object);
goto out;
}
}
out:
g_list_free_full (objects, g_object_unref);
return ret;
}
static gboolean
handle_add (CockpitMachines *object,
GDBusMethodInvocation *invocation,
const gchar *arg_address,
const gchar *arg_host_key)
{
GError *error = NULL;
Machines *machines = MACHINES (object);
Machine *machine;
if (g_strcmp0 (arg_address, "") == 0)
{
error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
"IP address or host name cannot be empty.");
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
machine = machines_add (machines, arg_address, arg_host_key, &error);
if (machine)
{
GDBusObject *obj = g_dbus_interface_get_object (G_DBUS_INTERFACE (machine));
cockpit_machines_complete_add (object, invocation, g_dbus_object_get_object_path (obj));
}
else
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
static gboolean
walk_logical_volume (GDBusObjectManager *objman,
LvmLogicalVolume *vol,
LogicalVolumeWalker *walker,
gpointer user_data,
GError **error)
{
if (!walker (objman, vol, user_data, error))
return FALSE;
const gchar *vol_objpath = g_dbus_object_get_object_path (g_dbus_interface_get_object (G_DBUS_INTERFACE (vol)));
LvmVolumeGroup *group = lvm_util_get_volume_group_for_logical_volume (objman, vol);
GList *siblings = group ? lvm_util_get_logical_volumes_for_volume_group (objman, group) : NULL;
gboolean ret = TRUE;
for (GList *l = siblings; l; l = l->next)
{
LvmLogicalVolume *s = l->data;
if ((g_strcmp0 (lvm_logical_volume_get_type_ (s), "snapshot") == 0
&& g_strcmp0 (lvm_logical_volume_get_origin (s), vol_objpath) == 0)
|| (g_strcmp0 (lvm_logical_volume_get_type_ (s), "thin") == 0
&& g_strcmp0 (lvm_logical_volume_get_thin_pool (s), vol_objpath) == 0))
{
if (!walk_logical_volume (objman, s, walker, user_data, error))
{
ret = FALSE;
break;
}
}
}
g_list_free_full (siblings, g_object_unref);
return ret;
}
static gboolean
on_update(Flash *flash,
GDBusMethodInvocation *invocation,
gchar* write_file,
gpointer user_data)
{
int rc = 0;
SharedResource *lock = object_get_shared_resource((Object*)user_data);
gboolean locked = shared_resource_get_lock(lock);
flash_set_status(flash,"Flashing");
flash_complete_update(flash,invocation);
if(locked)
{
const gchar* name = shared_resource_get_name(lock);
printf("BIOS Flash is locked: %s\n",name);
}
else
{
printf("Flashing BIOS from: %s\n",write_file);
flash_set_status(flash, "Flashing");
shared_resource_set_lock(lock,true);
shared_resource_set_name(lock,dbus_object_path);
flash_set_filename(flash,write_file);
const gchar* obj_path = g_dbus_object_get_object_path((GDBusObject*)user_data);
rc = update(flash,obj_path);
if(!rc)
{
shared_resource_set_lock(lock,false);
shared_resource_set_name(lock,"");
}
}
return TRUE;
}
static UDisksBlock *
peek_block_for_logical_volume (UDisksLogicalVolume *volume,
UDisksDaemon *daemon)
{
UDisksBlock *ret = NULL;
GDBusObject *object;
GList *l, *objects = NULL;
UDisksBlockLVM2 *block_lvm2;
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (volume));
if (object == NULL)
goto out;
objects = udisks_daemon_get_objects (daemon);
for (l = objects; l != NULL; l = l->next)
{
block_lvm2 = udisks_object_peek_block_lvm2 (UDISKS_OBJECT(l->data));
if (block_lvm2 &&
g_strcmp0 (udisks_block_lvm2_get_logical_volume (block_lvm2),
g_dbus_object_get_object_path (object)) == 0)
{
ret = udisks_object_peek_block (UDISKS_OBJECT(l->data));
goto out;
}
}
out:
g_list_free_full (objects, g_object_unref);
return ret;
}
void _on_interface_removed(GDBusObjectManager *manager,
GDBusObject *object,
GDBusInterface *interface,
gpointer user_data)
{
GTlmNfc* self = GTLM_NFC(user_data);
GDBusProxy* proxy = G_DBUS_PROXY(interface);
g_debug("Object %s removed interface %s",
g_dbus_object_get_object_path (object),
g_dbus_proxy_get_interface_name (proxy));
if (g_strcmp0(g_dbus_proxy_get_interface_name (proxy),
"org.neard.Tag") == 0) {
g_signal_emit(self, signals[SIG_TAG_LOST], 0, g_dbus_object_get_object_path (object));
GVariant* adapter_v = g_dbus_proxy_get_cached_property(proxy, "Adapter");
if (adapter_v == NULL || !g_variant_is_of_type(adapter_v, G_VARIANT_TYPE_OBJECT_PATH)) {
g_debug("Adapter property is absent on a tag");
return;
}
const gchar* adapter_path = g_variant_get_string(adapter_v, NULL);
g_debug("Tag belongs to adapter %s", adapter_path);
GError* error = NULL;
GDBusProxy* adapter = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL, /* GDBusInterfaceInfo */
"org.neard",
adapter_path,
"org.neard.Adapter",
NULL, /* GCancellable */
&error);
if (adapter == NULL) {
g_debug ("Error creating adapter proxy: %s", error->message);
g_error_free(error);
g_variant_unref(adapter_v);
return;
}
// start polling on an adapter
_setup_nfc_adapter(self, adapter);
g_object_unref(adapter);
g_variant_unref(adapter_v);
return;
}
}
const gchar *
setting_get_object_path (Setting *setting)
{
g_return_val_if_fail (IS_SETTING (setting), NULL);
GDBusObject *object = NULL;
object = g_dbus_interface_get_object (G_DBUS_INTERFACE (setting));
return g_dbus_object_get_object_path (object);
}
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);
}
void
storage_mdraid_update (StorageMDRaid *mdraid)
{
UDisksMDRaid *udisks_mdraid = mdraid->udisks_mdraid;
CockpitStorageMDRaid *iface = COCKPIT_STORAGE_MDRAID (mdraid);
StorageProvider *provider = storage_object_get_provider (mdraid->object);
UDisksClient *udisks_client = storage_provider_get_udisks_client (provider);
cockpit_storage_mdraid_set_uuid (iface, udisks_mdraid_get_uuid (udisks_mdraid));
cockpit_storage_mdraid_set_name (iface, udisks_mdraid_get_name (udisks_mdraid));
cockpit_storage_mdraid_set_level (iface, udisks_mdraid_get_level (udisks_mdraid));
cockpit_storage_mdraid_set_num_devices (iface, udisks_mdraid_get_num_devices (udisks_mdraid));
cockpit_storage_mdraid_set_size (iface, udisks_mdraid_get_size (udisks_mdraid));
cockpit_storage_mdraid_set_sync_action (iface, udisks_mdraid_get_sync_action (udisks_mdraid));
cockpit_storage_mdraid_set_sync_completed (iface, udisks_mdraid_get_sync_completed (udisks_mdraid));
cockpit_storage_mdraid_set_sync_rate (iface, udisks_mdraid_get_sync_rate (udisks_mdraid));
cockpit_storage_mdraid_set_sync_remaining_time (iface, udisks_mdraid_get_sync_remaining_time (udisks_mdraid));
cockpit_storage_mdraid_set_degraded (iface, udisks_mdraid_get_degraded (udisks_mdraid));
{
gs_free gchar *loc = g_locale_to_utf8 (udisks_mdraid_get_bitmap_location (udisks_mdraid),
-1, NULL, NULL, NULL);
cockpit_storage_mdraid_set_bitmap_location (iface, loc);
}
cockpit_storage_mdraid_set_chunk_size (iface, udisks_mdraid_get_chunk_size (udisks_mdraid));
GVariantBuilder devices;
g_variant_builder_init (&devices, G_VARIANT_TYPE("a(oiast)"));
GVariantIter iter;
gint disk_slot;
const gchar *disk_block_objpath;
gs_unref_variant GVariant *disk_states = NULL;
guint64 disk_num_errors;
g_variant_iter_init (&iter, udisks_mdraid_get_active_devices (udisks_mdraid));
while (g_variant_iter_next (&iter, "(&oi@asta{sv})",
&disk_block_objpath,
&disk_slot,
&disk_states,
&disk_num_errors,
NULL))
{
UDisksObject *udisks_object;
UDisksBlock *udisks_block;
StorageObject *object;
if ((udisks_object = udisks_client_peek_object (udisks_client, disk_block_objpath))
&& (udisks_block = udisks_object_peek_block (udisks_object))
&& (object = storage_provider_lookup_for_udisks_block (provider, udisks_block)))
{
g_variant_builder_add (&devices, "(oi@ast)",
g_dbus_object_get_object_path (G_DBUS_OBJECT(object)),
disk_slot,
disk_states,
disk_num_errors);
}
}
cockpit_storage_mdraid_set_active_devices (iface, g_variant_builder_end (&devices));
}
static void
on_object_removed (GDBusObjectManager *manager,
GDBusObject *object,
gpointer user_data)
{
gchar *owner;
owner = g_dbus_object_manager_client_get_name_owner (G_DBUS_OBJECT_MANAGER_CLIENT (manager));
g_print ("Removed object at %s (owner %s)\n", g_dbus_object_get_object_path (object), owner);
g_free (owner);
}
static void
manager_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
GDBusObjectManagerServer *manager = G_DBUS_OBJECT_MANAGER_SERVER (user_data);
GVariantBuilder array_builder;
GHashTableIter object_iter;
RegistrationData *data;
if (g_strcmp0 (method_name, "GetManagedObjects") == 0)
{
g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("a{oa{sa{sv}}}"));
g_hash_table_iter_init (&object_iter, manager->priv->map_object_path_to_data);
while (g_hash_table_iter_next (&object_iter, NULL, (gpointer) &data))
{
GVariantBuilder interfaces_builder;
GHashTableIter interface_iter;
GDBusInterfaceSkeleton *iface;
const gchar *iter_object_path;
g_variant_builder_init (&interfaces_builder, G_VARIANT_TYPE ("a{sa{sv}}"));
g_hash_table_iter_init (&interface_iter, data->map_iface_name_to_iface);
while (g_hash_table_iter_next (&interface_iter, NULL, (gpointer) &iface))
{
g_variant_builder_add_value (&interfaces_builder,
g_variant_new ("{s@a{sv}}",
g_dbus_interface_skeleton_get_info (iface)->name,
g_dbus_interface_skeleton_get_properties (iface)));
}
iter_object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object));
g_variant_builder_add (&array_builder,
"{oa{sa{sv}}}",
iter_object_path,
&interfaces_builder);
}
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(a{oa{sa{sv}}})",
&array_builder));
}
else
{
g_dbus_method_invocation_return_error (invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_UNKNOWN_METHOD,
"Unknown method %s - only GetManagedObjects() is supported",
method_name);
}
}
static gboolean
remember_configs (UDisksClient *client,
GDBusObject *object,
gpointer user_data,
GError **error)
{
struct RememberData *data = user_data;
const gchar *parent_path = g_dbus_object_get_object_path (object);
storage_provider_remember_config (data->provider, parent_path, data->child_path, data->config);
return TRUE;
}
static void
manager_add_object (CockpitFakeManager *self,
CockpitObjectProxy *object)
{
const gchar *object_path;
object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object));
g_hash_table_insert (self->path_to_object, (gpointer)object_path,
g_object_ref (object));
g_debug ("fakemanager: object-added: %s", object_path);
g_signal_emit (self, sig_manager__object_added, 0, object);
}
static void
udisks_client_get_object_info_for_loop (UDisksClient *client,
UDisksLoop *loop,
UDisksBlock *block,
UDisksPartition *partition,
UDisksObjectInfo *info)
{
guint64 size = 0;
gchar *size_str = NULL;
gchar *s;
size = udisks_block_get_size (block);
if (size > 0)
size_str = udisks_client_get_size_for_display (client, size, FALSE, FALSE);
info->icon = g_themed_icon_new_with_default_fallbacks ("drive-removable-media");
info->icon_symbolic = g_themed_icon_new_with_default_fallbacks ("drive-removable-media-symbolic");
info->name = udisks_loop_dup_backing_file (loop);
if (size_str != NULL)
{
info->description = g_strdup_printf (_("%s Loop Device"), size_str);
}
else
{
info->description = g_strdup (_("Loop Device"));
}
if (partition != NULL)
{
/* Translators: Used to describe a partition of a loop device.
* The %d is the partition number.
* The %s is the description for the loop device (e.g. "5 GB Loop Device").
*/
s = g_strdup_printf (C_("part-loop", "Partition %d of %s"),
udisks_partition_get_number (partition), info->description);
g_free (info->description);
info->description = s;
}
/* Translators: String used for one-liner description of a loop device.
* The first %s is the description of the object (e.g. "2 GB Loop Device").
* The second %s is the name of the backing file (e.g. "/home/davidz/file.iso").
* The third %s is the special device file (e.g. "/dev/loop2").
*/
info->one_liner = g_strdup_printf (C_("one-liner-loop", "%s — %s (%s)"),
info->description,
info->name,
udisks_block_get_preferred_device (block));
info->sort_key = g_strdup_printf ("03_loop_%s_%d",
last_segment (g_dbus_object_get_object_path (G_DBUS_OBJECT (info->object))),
partition != NULL ? udisks_partition_get_number (partition) : 0);
}
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
lvm_object_changed (StorageProvider *provider,
GDBusObject *object)
{
const gchar *path = g_dbus_object_get_object_path (object);
if (g_str_has_prefix (path, "/org/freedesktop/UDisks2/block_devices/"))
provider_update_block (provider, path);
else if (g_str_has_prefix (path, "/org/freedesktop/UDisks2/jobs/"))
provider_update_jobs (provider);
else
provider_update (provider);
}
