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