void
storage_daemon_publish (StorageDaemon *self,
const gchar *path,
gboolean uniquely,
gpointer thing)
{
GDBusInterface *prev;
GDBusInterfaceInfo *info;
GDBusObjectSkeleton *object;
GQuark detail;
g_return_if_fail (STORAGE_IS_DAEMON (self));
g_return_if_fail (path != NULL);
if (G_IS_DBUS_INTERFACE (thing))
{
g_debug ("%spublishing iface: %s %s", uniquely ? "uniquely " : "", path,
g_dbus_interface_get_info(thing)->name);
object = G_DBUS_OBJECT_SKELETON (g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (self->object_manager), path));
if (object != NULL)
{
if (uniquely)
{
info = g_dbus_interface_get_info (thing);
prev = g_dbus_object_get_interface (G_DBUS_OBJECT (object), info->name);
if (prev)
{
g_object_unref (prev);
g_object_unref (object);
object = NULL;
}
}
}
if (object == NULL)
object = g_dbus_object_skeleton_new (path);
g_dbus_object_skeleton_add_interface (object, thing);
}
else
{
g_critical ("Unsupported type to publish: %s", G_OBJECT_TYPE_NAME (thing));
return;
}
if (uniquely)
g_dbus_object_manager_server_export_uniquely (self->object_manager, object);
else
g_dbus_object_manager_server_export (self->object_manager, object);
detail = g_quark_from_static_string (G_OBJECT_TYPE_NAME (thing));
g_signal_emit (self, signals[PUBLISHED], detail, thing);
g_object_unref (object);
}
static gboolean
handle_remove_devices (CockpitStorageMDRaid *object,
GDBusMethodInvocation *invocation,
const gchar *const *arg_devices)
{
StorageMDRaid *mdraid = STORAGE_MDRAID(object);
StorageProvider *provider = storage_object_get_provider (mdraid->object);
Daemon *daemon = storage_provider_get_daemon (provider);
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon);
GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
GError *error = NULL;
int n_devices = 0;
for (int i = 0; arg_devices[i]; i++)
n_devices += 1;
const gchar *udisks_devices[n_devices + 1];
for (int i = 0; arg_devices[i]; i++)
{
StorageObject *stobj =
STORAGE_OBJECT(g_dbus_object_manager_get_object (object_manager, arg_devices[i]));
UDisksBlock *block = storage_object_get_udisks_block (stobj);
if (block)
udisks_devices[i] = g_dbus_proxy_get_object_path (G_DBUS_PROXY(block));
else
udisks_devices[i] = "XXX";
}
udisks_devices[n_devices] = NULL;
for (int i = 0; udisks_devices[i]; i++)
{
GVariantBuilder options;
g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add (&options, "{sv}", "wipe", g_variant_new_boolean (TRUE));
if (!udisks_mdraid_call_remove_device_sync (mdraid->udisks_mdraid,
udisks_devices[i],
g_variant_builder_end (&options),
NULL,
&error))
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s", error->message);
g_error_free (error);
return TRUE;
}
}
cockpit_storage_mdraid_complete_remove_devices (object, invocation);
return TRUE;
}
static gboolean
walk_block_parents (UDisksClient *client,
GDBusObjectManager *objman,
UDisksBlock *block,
ObjectWalker *walker,
gpointer user_data,
GError **error)
{
/* Parents are
- of a block that is a logical volume, the logical volume object
- of a clear text device, the encrypted device.
XXX - support the whole tree.
*/
while (block)
{
const gchar *path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (block));
LvmLogicalVolumeBlock *lvm_block =
LVM_LOGICAL_VOLUME_BLOCK (g_dbus_object_manager_get_interface (objman, path,
"com.redhat.lvm2.LogicalVolumeBlock"));
const gchar *logical_volume_path =
(lvm_block ? lvm_logical_volume_block_get_logical_volume (lvm_block) : "/");
const gchar *crypto_path = udisks_block_get_crypto_backing_device (block);
if (g_strcmp0 (logical_volume_path, "/") != 0)
{
gs_unref_object LvmObject *logical_volume_object =
LVM_OBJECT (g_dbus_object_manager_get_object (objman, logical_volume_path));
if (logical_volume_object)
{
if (!walker (client, G_DBUS_OBJECT (logical_volume_object), user_data, error))
return FALSE;
}
block = NULL;
}
else if (g_strcmp0 (crypto_path, "/") != 0)
{
UDisksObject *crypto_object = udisks_client_peek_object (client, crypto_path);
if (crypto_object)
{
if (!walker (client, G_DBUS_OBJECT (crypto_object), user_data, error))
return FALSE;
}
block = udisks_object_peek_block (crypto_object);
}
else
block = NULL;
}
return TRUE;
}
const gchar *
storage_provider_translate_path (StorageProvider *provider,
const gchar *udisks_or_lvm_path)
{
StorageObject *object = NULL;
if (udisks_or_lvm_path == NULL)
udisks_or_lvm_path = "/";
gs_unref_object UDisksObject *udisks_object = udisks_client_get_object (provider->udisks_client,
udisks_or_lvm_path);
if (udisks_object != NULL)
{
UDisksDrive *udisks_drive = udisks_object_peek_drive (udisks_object);
if (udisks_drive != NULL)
object = storage_provider_lookup_for_udisks_drive (provider, udisks_drive);
UDisksBlock *udisks_block = udisks_object_peek_block (udisks_object);
if (udisks_block != NULL)
object = storage_provider_lookup_for_udisks_block (provider, udisks_block);
UDisksMDRaid *udisks_raid = udisks_object_peek_mdraid (udisks_object);
if (udisks_raid != NULL)
object = storage_provider_lookup_for_udisks_mdraid (provider, udisks_raid);
}
gs_unref_object LvmObject *lvm_object = LVM_OBJECT (g_dbus_object_manager_get_object (provider->lvm_objman,
udisks_or_lvm_path));
if (lvm_object)
{
LvmVolumeGroup *lvm_volume_group = lvm_object_peek_volume_group (lvm_object);
if (lvm_volume_group != NULL)
object = storage_provider_lookup_for_lvm_volume_group (provider, lvm_volume_group);
LvmLogicalVolume *lvm_logical_volume = lvm_object_peek_logical_volume (lvm_object);
if (lvm_logical_volume != NULL)
object = storage_provider_lookup_for_lvm_logical_volume (provider, lvm_logical_volume);
}
if (object != NULL)
{
// g_debug ("%s -> %s", udisks_or_lvm_path, g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
return g_dbus_object_get_object_path (G_DBUS_OBJECT (object));
}
else
{
// g_debug ("%s -> nothing", udisks_or_lvm_path);
return "/";
}
}
static gboolean
handle_create_thin_volume (CockpitStorageVolumeGroup *object,
GDBusMethodInvocation *invocation,
const gchar *arg_name,
guint64 arg_size,
const gchar *arg_pool)
{
StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
GError *error = NULL;
gs_free gchar *result = NULL;
const gchar *pool_path = "/";
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
StorageProvider *provider = storage_object_get_provider (group->object);
Daemon *daemon = storage_provider_get_daemon (provider);
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon);
GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
StorageObject *pool_object =
STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_pool));
LvmLogicalVolume *lvm_pool_lvol = storage_object_get_lvm_logical_volume (pool_object);
if (lvm_pool_lvol)
pool_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (lvm_pool_lvol));
if (!lvm_volume_group_call_create_thin_volume_sync (group->lvm_volume_group,
arg_name,
arg_size,
pool_path,
null_asv (),
&result,
NULL,
&error))
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s", error->message);
g_error_free (error);
}
else
cockpit_storage_volume_group_complete_create_thin_pool_volume (object, invocation);
return TRUE;
}
static gboolean
handle_empty_device (CockpitStorageVolumeGroup *object,
GDBusMethodInvocation *invocation,
const gchar *arg_objpath)
{
StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
GError *error = NULL;
const gchar *block_path = "/";
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
StorageProvider *provider = storage_object_get_provider (group->object);
Daemon *daemon = storage_provider_get_daemon (provider);
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon);
GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
StorageObject *block_object =
STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_objpath));
UDisksBlock *udisks_block = storage_object_get_udisks_block (block_object);
if (udisks_block)
block_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (udisks_block));
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),
G_MAXINT);
if (!lvm_volume_group_call_empty_device_sync (group->lvm_volume_group,
block_path,
null_asv (),
NULL,
&error))
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s", error->message);
g_error_free (error);
}
else
cockpit_storage_volume_group_complete_empty_device (object, invocation);
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),
-1);
return TRUE;
}
static void
on_provider_discover (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *async = G_SIMPLE_ASYNC_RESULT (user_data);
DiscoverClosure *discover = g_simple_async_result_get_op_res_gpointer (async);
GDBusObject *object;
GError *error = NULL;
gboolean no_membership = FALSE;
gchar **realms;
gint relevance;
gint i;
um_realm_provider_call_discover_finish (UM_REALM_PROVIDER (source), &relevance,
&realms, result, &error);
if (error == NULL) {
for (i = 0; realms[i]; i++) {
object = g_dbus_object_manager_get_object (discover->manager, realms[i]);
if (object == NULL) {
g_warning ("Realm is not in object manager: %s", realms[i]);
} else {
if (is_realm_with_kerberos_and_membership (object)) {
g_debug ("Discovered realm: %s", realms[i]);
discover->realms = g_list_prepend (discover->realms, object);
} else {
g_debug ("Realm does not support kerberos membership: %s", realms[i]);
no_membership = TRUE;
g_object_unref (object);
}
}
}
g_strfreev (realms);
if (!discover->realms && no_membership) {
g_simple_async_result_set_error (async, UM_REALM_ERROR, UM_REALM_ERROR_GENERIC,
_("Cannot automatically join this type of domain"));
}
} else {
g_simple_async_result_take_error (async, error);
}
g_simple_async_result_complete (async);
g_object_unref (async);
}
static void
do_list_remote ()
{
GDBusObjectManager *object_manager;
UsbemuDBusManager *manager;
GError *error = NULL;
const gchar * const *list;
const gchar * const *path;
usbip_dbus_init (opt_list_remote_path, &object_manager, &manager);
list = usbemu_dbus_manager_get_devices (manager);
if (list == NULL || *list == NULL) {
g_print ("no exportable devices found on %s\n",
opt_list_remote_path ? opt_list_remote_path : "(local)");
return;
}
g_print ("Exportable USB devices\n");
g_print ("======================\n");
g_print (" - %s\n\n", opt_list_remote_path ? opt_list_remote_path : "(local)");
path = list;
while (*path) {
GDBusObject *device_object;
UsbemuDBusDevice *device;
device_object = g_dbus_object_manager_get_object (object_manager, *path);
device =
USBEMU_DBUS_DEVICE (g_dbus_object_get_interface (device_object,
USBEMU_DBUS_DEVICE_PREFIX));
g_object_unref (device_object);
g_print ("%s\n", *path);
g_print ("\n");
g_object_unref (device);
++path;
}
g_object_unref (manager);
g_object_unref (object_manager);
}
/**
* goa_client_get_manager:
* @client: A #GoaClient.
*
* Gets the #GoaManager for @client.
*
* Returns: (transfer none): A #GoaManager. Do not free, the returned
* object belongs to @client.
*/
GoaManager *
goa_client_get_manager (GoaClient *client)
{
GDBusObject *object;
GoaManager *manager;
manager = NULL;
object = g_dbus_object_manager_get_object (client->object_manager, "/org/gnome/OnlineAccounts/Manager");
if (object == NULL)
goto out;
manager = goa_object_peek_manager (GOA_OBJECT (object));
out:
if (object != NULL)
g_object_unref (object);
return manager;
}
UDisksManager *
udisks_client_get_manager (UDisksClient *client)
{
UDisksManager *ret = NULL;
GDBusObject *obj;
g_return_val_if_fail (UDISKS_IS_CLIENT (client), NULL);
obj = g_dbus_object_manager_get_object (client->object_manager, "/org/freedesktop/UDisks2/Manager");
if (obj == NULL)
goto out;
ret = udisks_object_peek_manager (UDISKS_OBJECT (obj));
g_object_unref (obj);
out:
return ret;
}
static GDBusInterface *
g_dbus_object_manager_server_get_interface (GDBusObjectManager *_manager,
const gchar *object_path,
const gchar *interface_name)
{
GDBusInterface *ret;
GDBusObject *object;
ret = NULL;
object = g_dbus_object_manager_get_object (_manager, object_path);
if (object == NULL)
goto out;
ret = g_dbus_object_get_interface (object, interface_name);
g_object_unref (object);
out:
return ret;
}
static gboolean
on_handle_create_object (TestFrobber *object,
GDBusMethodInvocation *invocation,
const gchar *at_path,
gpointer user_data)
{
MockData *data = user_data;
GDBusObject *previous;
previous = g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (data->object_manager), at_path);
if (previous != NULL)
{
g_dbus_method_invocation_return_error (invocation,
G_IO_ERROR, G_IO_ERROR_FAILED,
"Sorry, object already exists at %s",
at_path);
g_object_unref (previous);
}
else
{
TestObjectSkeleton *new_object;
TestFrobber *frobber;
new_object = test_object_skeleton_new (at_path);
frobber = test_frobber_skeleton_new ();
test_object_skeleton_set_frobber (new_object, frobber);
g_dbus_object_manager_server_export (data->object_manager, G_DBUS_OBJECT_SKELETON (new_object));
g_object_unref (frobber);
g_object_unref (new_object);
g_signal_connect (frobber,
"handle-request-property-mods",
G_CALLBACK (on_handle_request_property_mods),
NULL);
test_frobber_complete_create_object (object, invocation);
}
return TRUE;
}
/*
* the DBus.Tracker.Properties1 interface returns a list of strings
* where each selected item brings up both its URI and its Caja
* mime type.
*
* We return to the caller a GList of NASelectedInfo objects
*/
static GList *
targets_from_selection( void )
{
static const gchar *thisfn = "caja_actions_run_targets_from_selection";
GList *selection;
GError *error;
gchar **paths;
g_debug( "%s", thisfn );
selection = NULL;
error = NULL;
paths = NULL;
#ifdef HAVE_GDBUS
GDBusObjectManager *manager;
gchar *name_owner;
GDBusObject *object;
GDBusInterface *iface;
manager = na_tracker_object_manager_client_new_for_bus_sync(
G_BUS_TYPE_SESSION,
G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
CAJA_ACTIONS_DBUS_SERVICE,
CAJA_ACTIONS_DBUS_TRACKER_PATH,
NULL,
&error );
if( !manager ){
g_printerr( "%s: unable to allocate an ObjectManagerClient: %s\n", thisfn, error->message );
g_error_free( error );
return( NULL );
}
name_owner = g_dbus_object_manager_client_get_name_owner( G_DBUS_OBJECT_MANAGER_CLIENT( manager ));
g_debug( "%s: name_owner=%s", thisfn, name_owner );
g_free( name_owner );
object = g_dbus_object_manager_get_object( manager, CAJA_ACTIONS_DBUS_TRACKER_PATH "/0" );
if( !object ){
g_printerr( "%s: unable to get object at %s path\n", thisfn, CAJA_ACTIONS_DBUS_TRACKER_PATH "/0" );
g_object_unref( manager );
return( NULL );
}
iface = g_dbus_object_get_interface( object, CAJA_ACTIONS_DBUS_TRACKER_IFACE );
if( !iface ){
g_printerr( "%s: unable to get %s interface\n", thisfn, CAJA_ACTIONS_DBUS_TRACKER_IFACE );
g_object_unref( object );
g_object_unref( manager );
return( NULL );
}
/* note that @iface is really a GDBusProxy instance
* and additionally also a NATrackerProperties1 instance
*/
na_tracker_properties1_call_get_selected_paths_sync(
NA_TRACKER_PROPERTIES1( iface ),
&paths,
NULL,
&error );
#else
# ifdef HAVE_DBUS_GLIB
DBusGConnection *connection;
DBusGProxy *proxy = NULL;
connection = dbus_g_bus_get( DBUS_BUS_SESSION, &error );
if( !connection ){
if( error ){
g_printerr( _( "Error: unable to get a connection to session DBus: %s" ), error->message );
g_error_free( error );
}
return( NULL );
}
g_debug( "%s: connection is ok", thisfn );
proxy = dbus_g_proxy_new_for_name( connection,
CAJA_ACTIONS_DBUS_SERVICE,
CAJA_ACTIONS_DBUS_TRACKER_PATH "/0",
CAJA_ACTIONS_DBUS_TRACKER_IFACE );
if( !proxy ){
g_printerr( _( "Error: unable to get a proxy on %s service" ), CAJA_ACTIONS_DBUS_SERVICE );
dbus_g_connection_unref( connection );
return( NULL );
}
g_debug( "%s: proxy is ok", thisfn );
if( !dbus_g_proxy_call( proxy, "GetSelectedPaths", &error,
G_TYPE_INVALID,
G_TYPE_STRV, &paths, G_TYPE_INVALID )){
g_printerr( _( "Error on GetSelectedPaths call: %s" ), error->message );
g_error_free( error );
/* TODO: unref proxy */
dbus_g_connection_unref( connection );
return( NULL );
}
g_debug( "%s: function call is ok", thisfn );
/* TODO: unref proxy */
dbus_g_connection_unref( connection );
# endif
#endif
selection = get_selection_from_strv(( const gchar ** ) paths, TRUE );
g_strfreev( paths );
return( selection );
}
static GoaObject *
add_account (GoaProvider *provider,
GoaClient *client,
GtkDialog *dialog,
GtkBox *vbox,
GError **error)
{
AddAccountData data;
GVariantBuilder credentials;
GVariantBuilder details;
GoaEwsClient *ews_client;
GoaObject *ret;
gboolean accept_ssl_errors;
const gchar *email_address;
const gchar *server;
const gchar *password;
const gchar *username;
const gchar *provider_type;
gint response;
ews_client = NULL;
accept_ssl_errors = FALSE;
ret = NULL;
memset (&data, 0, sizeof (AddAccountData));
data.loop = g_main_loop_new (NULL, FALSE);
data.dialog = dialog;
data.error = NULL;
create_account_details_ui (provider, dialog, vbox, TRUE, &data);
gtk_widget_show_all (GTK_WIDGET (vbox));
ews_client = goa_ews_client_new ();
ews_again:
response = gtk_dialog_run (dialog);
if (response != GTK_RESPONSE_OK)
{
g_set_error (&data.error,
GOA_ERROR,
GOA_ERROR_DIALOG_DISMISSED,
_("Dialog was dismissed"));
goto out;
}
email_address = gtk_entry_get_text (GTK_ENTRY (data.email_address));
password = gtk_entry_get_text (GTK_ENTRY (data.password));
username = gtk_entry_get_text (GTK_ENTRY (data.username));
server = gtk_entry_get_text (GTK_ENTRY (data.server));
/* See if there's already an account of this type with the
* given identity
*/
provider_type = goa_provider_get_provider_type (provider);
if (!goa_utils_check_duplicate (client,
username,
provider_type,
(GoaPeekInterfaceFunc) goa_object_peek_password_based,
&data.error))
goto out;
goa_ews_client_autodiscover (ews_client,
email_address,
password,
username,
server,
accept_ssl_errors,
NULL,
autodiscover_cb,
&data);
goa_spinner_button_start (GOA_SPINNER_BUTTON (data.spinner_button));
g_main_loop_run (data.loop);
if (data.error != NULL)
{
gchar *markup;
if (data.error->code == GOA_ERROR_SSL)
{
goa_spinner_button_set_label (GOA_SPINNER_BUTTON (data.spinner_button), _("_Ignore"));
accept_ssl_errors = TRUE;
}
else
{
goa_spinner_button_set_label (GOA_SPINNER_BUTTON (data.spinner_button), _("_Try Again"));
accept_ssl_errors = FALSE;
}
markup = g_strdup_printf ("<b>%s:</b> %s",
_("Error connecting to Microsoft Exchange server"),
data.error->message);
g_clear_error (&data.error);
gtk_label_set_markup (GTK_LABEL (data.cluebar_label), markup);
g_free (markup);
gtk_expander_set_expanded (GTK_EXPANDER (data.expander), TRUE);
gtk_widget_set_no_show_all (data.cluebar, FALSE);
gtk_widget_show_all (data.cluebar);
goto ews_again;
}
gtk_widget_hide (GTK_WIDGET (dialog));
g_variant_builder_init (&credentials, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&credentials, "{sv}", "password", g_variant_new_string (password));
g_variant_builder_init (&details, G_VARIANT_TYPE ("a{ss}"));
g_variant_builder_add (&details, "{ss}", "MailEnabled", "true");
g_variant_builder_add (&details, "{ss}", "CalendarEnabled", "true");
g_variant_builder_add (&details, "{ss}", "ContactsEnabled", "true");
g_variant_builder_add (&details, "{ss}", "Host", server);
g_variant_builder_add (&details, "{ss}", "AcceptSslErrors", (accept_ssl_errors) ? "true" : "false");
/* OK, everything is dandy, add the account */
/* we want the GoaClient to update before this method returns (so it
* can create a proxy for the new object) so run the mainloop while
* waiting for this to complete
*/
goa_manager_call_add_account (goa_client_get_manager (client),
goa_provider_get_provider_type (provider),
username,
email_address,
g_variant_builder_end (&credentials),
g_variant_builder_end (&details),
NULL, /* GCancellable* */
(GAsyncReadyCallback) add_account_cb,
&data);
g_main_loop_run (data.loop);
if (data.error != NULL)
goto out;
ret = GOA_OBJECT (g_dbus_object_manager_get_object (goa_client_get_object_manager (client),
data.account_object_path));
out:
/* We might have an object even when data.error is set.
* eg., if we failed to store the credentials in the keyring.
*/
if (data.error != NULL)
g_propagate_error (error, data.error);
else
g_assert (ret != NULL);
g_free (data.account_object_path);
if (data.loop != NULL)
g_main_loop_unref (data.loop);
if (ews_client != NULL)
g_object_unref (ews_client);
return ret;
}
static gboolean
handle_volume_group_create (CockpitStorageManager *object,
GDBusMethodInvocation *invocation,
const gchar *arg_name,
const gchar *const *arg_blocks)
{
StorageManager *storage_manager = STORAGE_MANAGER(object);
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (storage_manager->daemon);
GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
GError *error = NULL;
int n_blocks = 0;
for (int i = 0; arg_blocks[i]; i++)
n_blocks += 1;
const gchar *udisks_blocks[n_blocks + 1];
for (int i = 0; arg_blocks[i]; i++)
{
StorageObject *stobj =
STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_blocks[i]));
UDisksBlock *block = storage_object_get_udisks_block (stobj);
if (block)
udisks_blocks[i] = g_dbus_proxy_get_object_path (G_DBUS_PROXY(block));
else
udisks_blocks[i] = "XXX";
}
udisks_blocks[n_blocks] = NULL;
if (storage_manager->lvm_manager == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"storaged daemon is not running");
return TRUE;
}
if (!lvm_manager_call_volume_group_create_sync (storage_manager->lvm_manager,
arg_name,
udisks_blocks,
null_asv (),
NULL,
NULL,
&error))
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s", error->message);
g_error_free (error);
return TRUE;
}
cockpit_storage_manager_complete_volume_group_create (object, invocation);
return TRUE;
}
static gboolean
handle_mdraid_create (CockpitStorageManager *object,
GDBusMethodInvocation *invocation,
const gchar *const *arg_blocks,
const gchar *arg_level,
const gchar *arg_name,
guint64 arg_chunk)
{
StorageManager *storage_manager = STORAGE_MANAGER(object);
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (storage_manager->daemon);
GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
GError *error = NULL;
int n_blocks = 0;
for (int i = 0; arg_blocks[i]; i++)
n_blocks += 1;
const gchar *udisks_blocks[n_blocks + 1];
for (int i = 0; arg_blocks[i]; i++)
{
StorageObject *stobj =
STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_blocks[i]));
UDisksBlock *block = storage_object_get_udisks_block (stobj);
if (block)
udisks_blocks[i] = g_dbus_proxy_get_object_path (G_DBUS_PROXY(block));
else
udisks_blocks[i] = "XXX";
}
udisks_blocks[n_blocks] = NULL;
UDisksManager *manager = udisks_client_get_manager (storage_manager->udisks);
if (manager == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"UDisks daemon is not running");
return TRUE;
}
GVariantBuilder options;
g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}"));
if (!udisks_manager_call_mdraid_create_sync (manager,
udisks_blocks,
arg_level,
arg_name,
arg_chunk,
null_asv (),
NULL,
NULL,
&error))
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s", error->message);
g_error_free (error);
return TRUE;
}
cockpit_storage_manager_complete_mdraid_create (object, invocation);
return TRUE;
}
void
storage_block_update (StorageBlock *block)
{
CockpitStorageBlock *iface = COCKPIT_STORAGE_BLOCK (block);
StorageProvider *provider;
UDisksClient *udisks_client;
UDisksObject *udisks_object;
UDisksBlock *udisks_block;
UDisksPartition *udisks_partition = NULL;
UDisksPartitionTable *udisks_partition_table = NULL;
UDisksFilesystem *udisks_filesystem = NULL;
provider = storage_object_get_provider (block->object);
udisks_client = storage_provider_get_udisks_client (provider);
udisks_block = block->udisks_block;
udisks_object = (UDisksObject *)g_dbus_interface_get_object (G_DBUS_INTERFACE (udisks_block));
if (udisks_object != NULL)
{
udisks_partition = udisks_object_peek_partition (udisks_object);
udisks_partition_table = udisks_object_peek_partition_table (udisks_object);
udisks_filesystem = udisks_object_peek_filesystem (udisks_object);
}
{
gs_free gchar *d =
g_filename_display_name (udisks_block_get_preferred_device (udisks_block));
cockpit_storage_block_set_device (iface, d);
}
cockpit_storage_block_set_size (iface, udisks_block_get_size (udisks_block));
cockpit_storage_block_set_id_usage (iface, udisks_block_get_id_usage (udisks_block));
cockpit_storage_block_set_id_type (iface, udisks_block_get_id_type (udisks_block));
cockpit_storage_block_set_id_version (iface, udisks_block_get_id_version (udisks_block));
cockpit_storage_block_set_id_label (iface, udisks_block_get_id_label (udisks_block));
cockpit_storage_block_set_id_uuid (iface, udisks_block_get_id_uuid (udisks_block));
cockpit_storage_block_set_hint_ignore (iface, udisks_block_get_hint_ignore (udisks_block));
if (udisks_partition == NULL)
{
cockpit_storage_block_set_partition_number (iface, 0);
cockpit_storage_block_set_partition_table (iface, "/");
}
else
{
UDisksPartitionTable *table_for_partition;
const gchar *objpath = "/";
GDBusObject *o;
UDisksBlock *b;
StorageObject *so;
table_for_partition = udisks_client_get_partition_table (udisks_client, udisks_partition);
if (table_for_partition != NULL)
{
o = g_dbus_interface_get_object (G_DBUS_INTERFACE (table_for_partition));
if (o != NULL)
{
b = udisks_object_peek_block (UDISKS_OBJECT (o));
if (b != NULL)
{
so = storage_provider_lookup_for_udisks_block (provider, b);
if (so != NULL)
{
objpath = g_dbus_object_get_object_path (G_DBUS_OBJECT (so));
}
}
}
}
cockpit_storage_block_set_partition_table (iface, objpath);
cockpit_storage_block_set_partition_number (iface, udisks_partition_get_number (udisks_partition));
}
GVariantBuilder partitions;
g_variant_builder_init (&partitions, G_VARIANT_TYPE ("a(otts)"));
if (udisks_partition_table != NULL)
{
GList *ps, *l;
ps = udisks_client_get_partitions (udisks_client, udisks_partition_table);
for (l = ps; l != NULL; l = l->next)
{
UDisksPartition *p = UDISKS_PARTITION (l->data);
GDBusObject *o;
UDisksBlock *b;
StorageObject *so;
o = g_dbus_interface_get_object (G_DBUS_INTERFACE (p));
if (o != NULL)
{
b = udisks_object_peek_block (UDISKS_OBJECT (o));
if (b != NULL)
{
so = storage_provider_lookup_for_udisks_block (provider, b);
if (so != NULL)
{
const gchar *type = "p";
if (udisks_partition_get_is_container (p))
type = "x";
else if (udisks_partition_get_is_contained (p))
type = "l";
g_variant_builder_add (&partitions, "(otts)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (so)),
udisks_partition_get_offset (p),
udisks_partition_get_size (p),
type);
}
}
}
}
g_list_free_full (ps, g_object_unref);
const gchar *type = udisks_partition_table_get_type_ (udisks_partition_table);
if (type == NULL || type[0] == '\0')
type = "unknown";
cockpit_storage_block_set_partition_table_type (iface, type);
}
else
cockpit_storage_block_set_partition_table_type (iface, "");
cockpit_storage_block_set_partitions (iface, g_variant_builder_end (&partitions));
cockpit_storage_block_set_drive
(iface, storage_provider_translate_path (provider, udisks_block_get_drive (udisks_block)));
cockpit_storage_block_set_crypto_backing_device
(iface, storage_provider_translate_path (provider, udisks_block_get_crypto_backing_device (udisks_block)));
cockpit_storage_block_set_mdraid
(iface, storage_provider_translate_path (provider, udisks_block_get_mdraid (udisks_block)));
cockpit_storage_block_set_mdraid_member
(iface, storage_provider_translate_path (provider, udisks_block_get_mdraid_member (udisks_block)));
if (udisks_filesystem)
{
const gchar *const *p = udisks_filesystem_get_mount_points (udisks_filesystem);
gchar *u[g_strv_length ((gchar **)p) + 1];
int i;
for (i = 0; p[i]; i++)
u[i] = g_filename_display_name (p[i]);
u[i] = NULL;
cockpit_storage_block_set_mounted_at (iface, (const gchar *const *)u);
for (i = 0; u[i]; i++)
g_free (u[i]);
}
GVariantIter iter;
g_variant_iter_init (&iter, udisks_block_get_configuration (udisks_block));
const gchar *type;
GVariant *details;
gboolean got_fstab = FALSE, got_crypttab = FALSE;
while (g_variant_iter_next (&iter, "(&s*)", &type, &details))
{
if (strcmp (type, "fstab") == 0 && !got_fstab)
{
got_fstab = TRUE;
const gchar *dir = variant_lookup (details, "dir");
if (dir)
{
gs_free gchar *dir_display = g_filename_display_name (dir);
cockpit_storage_block_set_mount_point (iface, dir_display);
}
const gchar *opts = variant_lookup (details, "opts");
if (opts)
{
gs_free gchar *opts_locale = g_locale_to_utf8 (opts, -1, NULL, NULL, NULL);
if (opts_locale)
cockpit_storage_block_set_mount_options (iface, opts_locale);
else
g_warning ("Can't convert fstab options into UTF8");
}
}
else if (strcmp (type, "crypttab") == 0 && !got_crypttab)
{
got_crypttab = TRUE;
const gchar *opts = variant_lookup (details, "options");
if (opts)
{
gs_free gchar *opts_locale = g_locale_to_utf8 (opts, -1, NULL, NULL, NULL);
if (opts_locale)
cockpit_storage_block_set_crypto_options (iface, opts_locale);
else
g_warning ("Can't convert crypttab options into UTF8");
}
}
g_variant_unref (details);
}
/* Now the com.redhat.lvm2 overlays. The StorageProvider makes sure
that we are called whenever something changes about them.
*/
LvmLogicalVolumeBlock *lv = NULL;
LvmPhysicalVolumeBlock *pv = NULL;
GDBusObjectManager *objman = storage_provider_get_lvm_object_manager (provider);
GDBusObject *lvm_object =
g_dbus_object_manager_get_object (objman,
g_dbus_object_get_object_path (G_DBUS_OBJECT (udisks_object)));
if (lvm_object)
{
lv = lvm_object_peek_logical_volume_block (LVM_OBJECT (lvm_object));
pv = lvm_object_peek_physical_volume_block (LVM_OBJECT (lvm_object));
}
if (lv)
{
cockpit_storage_block_set_logical_volume
(iface,
storage_provider_translate_path
(provider,
lvm_logical_volume_block_get_logical_volume (lv)));
}
else
cockpit_storage_block_set_logical_volume (iface, "/");
if (pv)
{
cockpit_storage_block_set_pv_group
(iface,
storage_provider_translate_path (provider,
lvm_physical_volume_block_get_volume_group (pv)));
cockpit_storage_block_set_pv_size (iface,
lvm_physical_volume_block_get_size (pv));
cockpit_storage_block_set_pv_free_size (iface,
lvm_physical_volume_block_get_free_size (pv));
}
else
{
cockpit_storage_block_set_pv_group (iface, "/");
cockpit_storage_block_set_pv_size (iface, 0);
cockpit_storage_block_set_pv_free_size (iface, 0);
}
}
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);
}
