static void
photos_search_provider_fetch_ids_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GApplication *app;
GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (user_data);
PhotosFetchIdsJob *job = PHOTOS_FETCH_IDS_JOB (source_object);
GError *error = NULL;
GVariant *parameters;
const gchar *const *ids;
app = g_application_get_default ();
g_application_release (app);
ids = photos_fetch_ids_job_finish (job, res, &error);
if (error != NULL)
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
parameters = g_variant_new ("(^as)", ids);
g_dbus_method_invocation_return_value (invocation, parameters);
out:
g_object_unref (invocation);
}
static void
gom_application_refresh_db_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GomApplication *self;
GDBusMethodInvocation *invocation = user_data;
GError *error = NULL;
self = GOM_APPLICATION (g_application_get_default ());
g_application_release (G_APPLICATION (self));
self->refreshing = FALSE;
gom_miner_refresh_db_finish (GOM_MINER (source), res, &error);
if (error != NULL)
{
g_printerr ("Failed to refresh the DB cache: %s\n", error->message);
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
gom_dbus_complete_refresh_db (self->skeleton, invocation);
out:
g_object_unref (invocation);
gom_application_process_queue (self);
}
static void
end_invocation_take_gerror (GDBusMethodInvocation *invocation,
GError *error)
{
gchar *remote_error = g_dbus_error_get_remote_error (error);
if (remote_error)
{
g_dbus_error_strip_remote_error (error);
if (strcmp (remote_error, "org.freedesktop.DBus.Error.AccessDenied") == 0)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"You are not authorized for this operation.");
}
else
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s (%s)", error->message, remote_error);
}
g_free (remote_error);
g_error_free (error);
}
else
g_dbus_method_invocation_take_error (invocation, error);
}
static void
gom_application_insert_shared_content_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GomApplication *self;
GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (user_data);
GError *error;
self = GOM_APPLICATION (g_application_get_default ());
g_application_release (G_APPLICATION (self));
error = NULL;
if (!gom_miner_insert_shared_content_finish (GOM_MINER (source), res, &error))
{
g_printerr ("Failed to insert shared content: %s\n", error->message);
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
gom_dbus_complete_insert_shared_content (self->skeleton, invocation);
out:
g_object_unref (invocation);
}
static void
load_current_ready (MMIfaceModemFirmware *self,
GAsyncResult *res,
HandleListContext *ctx)
{
GVariantBuilder builder;
GList *l;
GError *error = NULL;
/* reported current may be NULL and we don't treat it as error */
ctx->current = MM_IFACE_MODEM_FIRMWARE_GET_INTERFACE (self)->load_current_finish (self, res, &error);
if (error) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_list_context_free (ctx);
return;
}
/* Build array of dicts */
g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
for (l = ctx->list; l; l = g_list_next (l))
g_variant_builder_add_value (
&builder,
mm_firmware_properties_get_dictionary (MM_FIRMWARE_PROPERTIES (l->data)));
mm_gdbus_modem_firmware_complete_list (
ctx->skeleton,
ctx->invocation,
(ctx->current ? mm_firmware_properties_get_unique_id (ctx->current) : ""),
g_variant_builder_end (&builder));
handle_list_context_free (ctx);
}
gboolean
daemon_get_sender_uid (Daemon *daemon,
GDBusMethodInvocation *invocation,
uid_t *uid)
{
GError *error = NULL;
const char *sender = g_dbus_method_invocation_get_sender (invocation);
gs_unref_variant GVariant *reply = NULL;
reply = g_dbus_proxy_call_sync (daemon->system_bus_proxy, "org.freedesktop.DBus.GetConnectionUnixUser",
g_variant_new ("(s)", sender), 0, -1,
NULL, &error);
if (reply == NULL)
{
g_dbus_method_invocation_take_error (invocation, error);
return FALSE;
}
if (g_variant_is_of_type (reply, G_VARIANT_TYPE("(u)")))
g_variant_get (reply, "(u)", uid);
else
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"DBus is broken");
return FALSE;
}
return TRUE;
}
static gboolean
handle_delete (UDisksLogicalVolume *_volume,
GDBusMethodInvocation *invocation,
GVariant *options)
{
GError *error = NULL;
UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (_volume);
UDisksLinuxLogicalVolumeObject *object = NULL;
UDisksDaemon *daemon = NULL;
uid_t caller_uid;
gboolean teardown_flag = FALSE;
UDisksLinuxVolumeGroupObject *group_object;
LVJobData data;
g_variant_lookup (options, "tear-down", "b", &teardown_flag);
if (!common_setup (volume, invocation, options,
N_("Authentication is required to delete a logical volume"),
&object, &daemon, &caller_uid, NULL))
goto out;
if (teardown_flag &&
!teardown_logical_volume (_volume,
daemon,
invocation,
options,
&error))
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
group_object = udisks_linux_logical_volume_object_get_volume_group (object);
data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
data.lv_name = udisks_linux_logical_volume_object_get_name (object);
if (!udisks_daemon_launch_threaded_job_sync (daemon,
UDISKS_OBJECT (object),
"lvm-lvol-delete",
caller_uid,
lvremove_job_func,
&data,
NULL, /* user_data_free_func */
NULL, /* GCancellable */
&error))
{
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
"Error deleting logical volume: %s",
error->message);
goto out;
}
udisks_logical_volume_complete_delete (_volume, invocation);
out:
g_clear_object (&object);
return TRUE;
}
static gboolean
subprocess_backend_handle_create_cb (EDBusSubprocessBackend *proxy,
GDBusMethodInvocation *invocation,
const gchar *uid,
const gchar *backend_factory_type_name,
const gchar *module_filename,
ESubprocessBookFactory *subprocess_book_factory)
{
gchar *object_path = NULL;
GDBusConnection *connection;
GError *error = NULL;
connection = g_dbus_method_invocation_get_connection (invocation);
object_path = e_subprocess_factory_open_backend (
E_SUBPROCESS_FACTORY (subprocess_book_factory),
connection,
uid,
backend_factory_type_name,
module_filename,
G_DBUS_INTERFACE_SKELETON (proxy),
NULL,
&error);
if (object_path != NULL) {
e_dbus_subprocess_backend_complete_create (proxy, invocation, object_path);
g_free (object_path);
} else {
g_dbus_method_invocation_take_error (invocation, error);
}
return TRUE;
}
static gboolean
handle_rename (UDisksLogicalVolume *_volume,
GDBusMethodInvocation *invocation,
const gchar *new_name,
GVariant *options)
{
GError *error = NULL;
UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (_volume);
UDisksLinuxLogicalVolumeObject *object = NULL;
UDisksDaemon *daemon;
uid_t caller_uid;
UDisksLinuxVolumeGroupObject *group_object;
const gchar *lv_objpath;
LVJobData data;
if (!common_setup (volume, invocation, options,
N_("Authentication is required to rename a logical volume"),
&object, &daemon, &caller_uid, NULL))
goto out;
group_object = udisks_linux_logical_volume_object_get_volume_group (object);
data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
data.lv_name = udisks_linux_logical_volume_object_get_name (object);
data.new_lv_name = new_name;
if (!udisks_daemon_launch_threaded_job_sync (daemon,
UDISKS_OBJECT (object),
"lvm-lvol-rename",
caller_uid,
lvrename_job_func,
&data,
NULL, /* user_data_free_func */
NULL, /* GCancellable */
&error))
{
g_dbus_method_invocation_return_error (invocation,
UDISKS_ERROR,
UDISKS_ERROR_FAILED,
"Error renaming logical volume: %s",
error->message);
goto out;
}
lv_objpath = wait_for_logical_volume_path (group_object, new_name, &error);
if (lv_objpath == NULL)
{
g_prefix_error (&error,
"Error waiting for logical volume object for %s",
new_name);
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
udisks_logical_volume_complete_rename (_volume, invocation, lv_objpath);
out:
g_clear_object (&object);
return TRUE;
}
static gboolean
handle_create_devices (StoragedManagerZRAM *object,
GDBusMethodInvocation *invocation,
GVariant *sizes_,
GVariant *num_streams_,
GVariant *options)
{
StoragedLinuxManagerZRAM *manager = STORAGED_LINUX_MANAGER_ZRAM (object);
GError *error = NULL;
gsize sizes_len;
gsize streams_len;
guint64 *sizes;
guint64 *num_streams;
/* Policy check */
STORAGED_DAEMON_CHECK_AUTHORIZATION (manager->daemon,
NULL,
zram_policy_action_id,
options,
N_("Authentication is required to add zRAM kernel module"),
invocation);
sizes = (guint64*) g_variant_get_fixed_array (sizes_,
&sizes_len,
sizeof (guint64));
num_streams = (guint64*) g_variant_get_fixed_array (num_streams_,
&streams_len,
sizeof (guint64));
if (! create_conf_files ((guint64) streams_len, sizes, num_streams, &error))
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
if (! bd_kbd_zram_create_devices ((guint64) sizes_len, sizes, num_streams, &error))
{
g_dbus_method_invocation_take_error (invocation, error);
delete_conf_files (&error);
goto out;
}
storaged_manager_zram_complete_create_devices(object, invocation);
out:
return TRUE;
}
gboolean
gkd_secret_objects_handle_get_secrets (GkdSecretObjects *self,
GDBusMethodInvocation *invocation,
const gchar **paths,
const gchar *session_path)
{
GkdSecretSession *session;
GkdSecretSecret *secret;
GckObject *item;
const char *caller;
int i;
GVariantBuilder builder;
GError *error = NULL;
caller = g_dbus_method_invocation_get_sender (invocation);
session = gkd_secret_service_lookup_session (self->service, session_path, caller);
if (session == NULL) {
g_dbus_method_invocation_return_error_literal (invocation, GKD_SECRET_ERROR,
GKD_SECRET_ERROR_NO_SESSION,
"The session does not exist");
return TRUE;
}
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{o(oayays)}"));
for (i = 0; paths[i] != NULL; ++i) {
/* Try to find the item, if it doesn't exist, just ignore */
item = gkd_secret_objects_lookup_item (self, caller, paths[i]);
if (!item)
continue;
secret = gkd_secret_session_get_item_secret (session, item, &error);
g_object_unref (item);
if (secret == NULL) {
/* We ignore is locked, and just leave out from response */
if (g_error_matches (error, GKD_SECRET_ERROR, GKD_SECRET_ERROR_IS_LOCKED)) {
g_clear_error (&error);
continue;
/* All other errors stop the operation */
} else {
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
}
g_variant_builder_add (&builder, "{o@(oayays)}", paths[i], gkd_secret_secret_append (secret));
gkd_secret_secret_free (secret);
}
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(@a{o(oayays)})", g_variant_builder_end (&builder)));
return TRUE;
}
static gboolean
handle_destroy (LoomSettings *object,
GDBusMethodInvocation *invocation,
const gchar *arg_setting)
{
Settings *settings = SETTINGS (object);
GError *error;
gs_free gchar **object_paths = NULL;
const gchar * const *active_settings;
if (!g_hash_table_remove (settings->settings, arg_setting))
{
error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("no such 'setting' object found"));
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
active_settings = loom_settings_get_active_settings (object);
if (active_settings != NULL)
{
for (guint i = 0; active_settings[i] != NULL; i++)
{
if (g_str_equal (arg_setting, active_settings[i]))
{
error = g_error_new (G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("'setting' object is in use"));
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
}
}
object_paths = (gchar **)g_hash_table_get_keys_as_array (settings->settings,
NULL);
loom_settings_set_settings (object, (const gchar* const*)object_paths);
loom_settings_complete_destroy (object, invocation);
return TRUE;
}
static void
set_logging_auth_ready (MMAuthProvider *authp,
GAsyncResult *res,
SetLoggingContext *ctx)
{
GError *error = NULL;
if (!mm_auth_provider_authorize_finish (authp, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else if (!mm_log_set_level(ctx->level, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else {
mm_info ("logging: level '%s'", ctx->level);
mm_gdbus_org_freedesktop_modem_manager1_complete_set_logging (
MM_GDBUS_ORG_FREEDESKTOP_MODEM_MANAGER1 (ctx->self),
ctx->invocation);
}
set_logging_context_free (ctx);
}
static gboolean
service_method_create_with_master_password (GkdExportedInternal *skeleton,
GDBusMethodInvocation *invocation,
GVariant *attributes,
GVariant *master,
GkdSecretService *self)
{
GckBuilder builder = GCK_BUILDER_INIT;
GkdSecretSecret *secret = NULL;
GckAttributes *attrs = NULL;
GError *error = NULL;
gchar *path;
const gchar *caller;
if (!gkd_secret_property_parse_all (attributes, SECRET_COLLECTION_INTERFACE, &builder)) {
gck_builder_clear (&builder);
g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid properties argument");
return TRUE;
}
caller = g_dbus_method_invocation_get_sender (invocation);
secret = gkd_secret_secret_parse (self,
caller,
master, &error);
if (secret == NULL) {
gck_builder_clear (&builder);
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
gck_builder_add_boolean (&builder, CKA_TOKEN, TRUE);
attrs = gck_attributes_ref_sink (gck_builder_end (&builder));
path = gkd_secret_create_with_secret (attrs, secret, &error);
gck_attributes_unref (attrs);
gkd_secret_secret_free (secret);
if (path == NULL) {
gkd_secret_propagate_error (invocation, "Couldn't create collection", error);
return TRUE;
}
/* Notify the callers that a collection was created */
g_message ("emit collection_Created");
gkd_secret_service_emit_collection_created (self, path);
gkd_exported_internal_complete_create_with_master_password
(skeleton, invocation, path);
g_free (path);
return TRUE;
}
static gboolean
on_handle_get_password (GoaPasswordBased *interface,
GDBusMethodInvocation *invocation,
const gchar *id,
gpointer user_data)
{
GoaObject *object;
GoaAccount *account;
GoaProvider *provider;
GError *error;
GVariant *credentials;
gchar *password;
/* TODO: maybe log what app is requesting access */
password = NULL;
credentials = NULL;
object = GOA_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (interface)));
account = goa_object_peek_account (object);
provider = goa_provider_get_for_provider_type (goa_account_get_provider_type (account));
error = NULL;
credentials = goa_utils_lookup_credentials_sync (provider,
object,
NULL, /* GCancellable* */
&error);
if (credentials == NULL)
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
if (!g_variant_lookup (credentials, "password", "s", &password))
{
g_dbus_method_invocation_return_error (invocation,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
_("Did not find password with username `%s' in credentials"),
id);
goto out;
}
goa_password_based_complete_get_password (interface, invocation, password);
out:
g_free (password);
if (credentials != NULL)
g_variant_unref (credentials);
g_object_unref (provider);
return TRUE; /* invocation was handled */
}
static gboolean
handle_bcache_destroy (StoragedBlockBcache *block_,
GDBusMethodInvocation *invocation,
GVariant *options)
{
GError *error = NULL;
StoragedLinuxBlockBcache *block = STORAGED_LINUX_BLOCK_BCACHE (block_);
StoragedLinuxBlockObject *object = NULL;
gchar *devname = NULL;
object = storaged_daemon_util_dup_object (block, &error);
if (! object)
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
/* Policy check */
STORAGED_DAEMON_CHECK_AUTHORIZATION (storaged_linux_block_bcache_get_daemon (block),
NULL,
bcache_policy_action_id,
options,
N_("Authentication is required to destroy bcache device."),
invocation);
devname = storaged_linux_block_object_get_device_file (object);
if (! bd_kbd_bcache_destroy (devname, &error))
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
storaged_block_bcache_complete_bcache_destroy (block_, invocation);
out:
g_free (devname);
g_clear_object (&object);
return TRUE;
}
static void
change_current_ready (MMIfaceModemFirmware *self,
GAsyncResult *res,
HandleSelectContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_FIRMWARE_GET_INTERFACE (self)->change_current_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else
mm_gdbus_modem_firmware_complete_select (ctx->skeleton, ctx->invocation);
handle_select_context_free (ctx);
}
/**
* bus_installer_install_local_cb:
*/
static gboolean
bus_installer_install_local_cb (LiProxyManager *mgr_bus, GDBusMethodInvocation *context, const gchar *fname, LiHelperDaemon *helper)
{
GError *error = NULL;
LiInstaller *inst = NULL;
PolkitAuthorizationResult *pres = NULL;
PolkitSubject *subject;
const gchar *sender;
sender = g_dbus_method_invocation_get_sender (context);
subject = polkit_system_bus_name_new (sender);
pres = polkit_authority_check_authorization_sync (helper->authority,
subject,
"org.freedesktop.limba.install-package-local",
NULL,
POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
NULL,
&error);
g_object_unref (subject);
if (error != NULL) {
g_dbus_method_invocation_take_error (context, error);
goto out;
}
if (!polkit_authorization_result_get_is_authorized (pres)) {
g_dbus_method_invocation_return_dbus_error (context, "org.freedesktop.Limba.Installer.Error.NotAuthorized",
"Authorization failed.");
goto out;
}
/* initialize our job, in case it is idling */
if (!li_daemon_init_job (helper, mgr_bus, context))
goto out;
/* do the thing */
li_daemon_job_run_install_local (helper->job, fname);
li_proxy_manager_complete_install_local (mgr_bus, context);
out:
if (inst != NULL)
g_object_unref (inst);
if (pres != NULL)
g_object_unref (pres);
li_daemon_reset_timer (helper);
return TRUE;
}
static void
impl_ppp_manager_need_secrets (NMPPPManager *manager,
GDBusMethodInvocation *context)
{
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (manager);
NMConnection *applied_connection;
const char *username = NULL;
const char *password = NULL;
guint32 tries;
GPtrArray *hints = NULL;
GError *error = NULL;
NMSecretAgentGetSecretsFlags flags = NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION;
nm_active_connection_clear_secrets (NM_ACTIVE_CONNECTION (priv->act_req));
applied_connection = nm_act_request_get_applied_connection (priv->act_req);
priv->secrets_setting_name = nm_connection_need_secrets (applied_connection, &hints);
if (!priv->secrets_setting_name) {
/* Use existing secrets from the connection */
if (extract_details_from_connection (applied_connection, NULL, &username, &password, &error)) {
/* Send existing secrets to the PPP plugin */
priv->pending_secrets_context = context;
ppp_secrets_cb (priv->act_req, priv->secrets_id, NULL, NULL, manager);
} else {
_LOGW ("%s", error->message);
g_dbus_method_invocation_take_error (priv->pending_secrets_context, error);
}
return;
}
/* Only ask for completely new secrets after retrying them once; some devices
* appear to ask a few times when they actually don't even care what you
* pass back.
*/
tries = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (applied_connection), PPP_MANAGER_SECRET_TRIES));
if (tries > 1)
flags |= NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW;
priv->secrets_id = nm_act_request_get_secrets (priv->act_req,
priv->secrets_setting_name,
flags,
hints ? g_ptr_array_index (hints, 0) : NULL,
ppp_secrets_cb,
manager);
g_object_set_data (G_OBJECT (applied_connection), PPP_MANAGER_SECRET_TRIES, GUINT_TO_POINTER (++tries));
priv->pending_secrets_context = context;
if (hints)
g_ptr_array_free (hints, TRUE);
}
static void
handle_delete_ready (MMSmsList *list,
GAsyncResult *res,
HandleDeleteContext *ctx)
{
GError *error = NULL;
if (!mm_sms_list_delete_sms_finish (list, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else
mm_gdbus_modem_messaging_complete_delete (ctx->skeleton, ctx->invocation);
handle_delete_context_free (ctx);
}
static void
ppp_secrets_cb (NMActRequest *req,
NMActRequestGetSecretsCallId call_id,
NMSettingsConnection *settings_connection, /* unused (we pass NULL here) */
GError *error,
gpointer user_data)
{
NMPPPManager *self = NM_PPP_MANAGER (user_data);
NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self);
const char *username = NULL;
const char *password = NULL;
GError *local = NULL;
NMConnection *applied_connection;
g_return_if_fail (priv->pending_secrets_context != NULL);
g_return_if_fail (req == priv->act_req);
g_return_if_fail (call_id == priv->secrets_id);
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
goto out;
if (error) {
_LOGW ("%s", error->message);
g_dbus_method_invocation_return_gerror (priv->pending_secrets_context, error);
goto out;
}
applied_connection = nm_act_request_get_applied_connection (req);
if (!extract_details_from_connection (applied_connection, priv->secrets_setting_name, &username, &password, &local)) {
_LOGW ("%s", local->message);
g_dbus_method_invocation_take_error (priv->pending_secrets_context, local);
goto out;
}
/* This is sort of a hack but...
* pppd plugin only ever needs username and password. Passing the full
* connection there would mean some bloat: the plugin would need to link
* against libnm just to parse this. So instead, let's just send what
* it needs.
*/
g_dbus_method_invocation_return_value (
priv->pending_secrets_context,
g_variant_new ("(ss)", username ? username : "", password ? password : ""));
out:
priv->pending_secrets_context = NULL;
priv->secrets_id = NULL;
priv->secrets_setting_name = NULL;
}
static gboolean
service_method_unlock_with_master_password (GkdExportedInternal *skeleton,
GDBusMethodInvocation *invocation,
gchar *path,
GVariant *master_variant,
GkdSecretService *self)
{
GkdSecretSecret *master;
GError *error = NULL;
GckObject *collection;
const gchar *sender;
sender = g_dbus_method_invocation_get_sender (invocation);
/* Parse the incoming message */
master = gkd_secret_secret_parse (self, sender, master_variant, &error);
if (master == NULL) {
g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
/* Make sure we have such a collection */
collection = gkd_secret_objects_lookup_collection (self->objects, sender, path);
/* No such collection */
if (collection == NULL) {
g_dbus_method_invocation_return_error_literal (invocation, GKD_SECRET_ERROR,
GKD_SECRET_ERROR_NO_SUCH_OBJECT,
"The collection does not exist");
/* Success */
} else if (gkd_secret_unlock_with_secret (collection, master, &error)) {
gkd_secret_objects_emit_collection_locked (self->objects, collection);
gkd_exported_internal_complete_unlock_with_master_password
(skeleton, invocation);
/* Failure */
} else {
gkd_secret_propagate_error (invocation, "Couldn't unlock collection", error);
}
gkd_secret_secret_free (master);
if (collection)
g_object_unref (collection);
return TRUE;
}
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_take_error (data->invocation, 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);
}
static gboolean
common_setup (UDisksLinuxLogicalVolume *volume,
GDBusMethodInvocation *invocation,
GVariant *options,
const gchar *auth_err_msg,
UDisksLinuxLogicalVolumeObject **object,
UDisksDaemon **daemon,
uid_t *out_uid,
gid_t *out_gid)
{
gboolean rc = FALSE;
GError *error = NULL;
*object = udisks_daemon_util_dup_object (volume, &error);
if (*object == NULL)
{
g_dbus_method_invocation_take_error (invocation, error);
goto out;
}
*daemon = udisks_linux_logical_volume_object_get_daemon (*object);
if (!udisks_daemon_util_get_caller_uid_sync (*daemon,
invocation,
NULL /* GCancellable */,
out_uid,
out_gid,
NULL,
&error))
{
g_dbus_method_invocation_return_gerror (invocation, error);
g_clear_error (&error);
goto out;
}
/* Policy check. */
UDISKS_DAEMON_CHECK_AUTHORIZATION (*daemon,
UDISKS_OBJECT (*object),
lvm2_policy_action_id,
options,
auth_err_msg,
invocation);
rc = TRUE;
out:
return rc;
}
static gboolean
osexperimental_handle_live_fs (RPMOSTreeOSExperimental *interface,
GDBusMethodInvocation *invocation,
GVariant *arg_options)
{
RpmostreedOSExperimental *self = RPMOSTREED_OSEXPERIMENTAL (interface);
glnx_unref_object RpmostreedTransaction *transaction = NULL;
glnx_unref_object OstreeSysroot *ot_sysroot = NULL;
g_autoptr(GCancellable) cancellable = g_cancellable_new ();
GError *local_error = NULL;
transaction = merge_compatible_txn (self, invocation);
if (transaction)
goto out;
if (!rpmostreed_sysroot_load_state (rpmostreed_sysroot_get (),
cancellable,
&ot_sysroot,
NULL,
&local_error))
goto out;
transaction = rpmostreed_transaction_new_livefs (invocation,
ot_sysroot,
livefs_flags_from_options (arg_options),
cancellable,
&local_error);
if (transaction == NULL)
goto out;
rpmostreed_transaction_monitor_add (self->transaction_monitor, transaction);
out:
if (local_error != NULL)
{
g_dbus_method_invocation_take_error (invocation, local_error);
}
else
{
const char *client_address;
client_address = rpmostreed_transaction_get_client_address (transaction);
rpmostree_osexperimental_complete_live_fs (interface, invocation, client_address);
}
return TRUE;
}
static void
list_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleListContext *ctx)
{
GError *error = NULL;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_list_context_free (ctx);
return;
}
MM_IFACE_MODEM_FIRMWARE_GET_INTERFACE (self)->load_list (MM_IFACE_MODEM_FIRMWARE (self),
(GAsyncReadyCallback)load_list_ready,
ctx);
}
static void
handle_upload_finished (EmerDaemon *daemon,
GAsyncResult *result,
DBusCallbackData *callback_data)
{
GError *error = NULL;
gboolean upload_succeeded =
emer_daemon_upload_events_finish (daemon, result, &error);
if (upload_succeeded)
emer_event_recorder_server_complete_upload_events (callback_data->server,
callback_data->invocation);
else
g_dbus_method_invocation_take_error (callback_data->invocation, error);
g_object_unref (callback_data->server);
g_free (callback_data);
}
static void
handle_delete_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleDeleteContext *ctx)
{
MMModemState modem_state = MM_MODEM_STATE_UNKNOWN;
MMSmsList *list = NULL;
GError *error = NULL;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_delete_context_free (ctx);
return;
}
g_object_get (self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
if (modem_state < MM_MODEM_STATE_ENABLED) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot delete SMS: device not yet enabled");
handle_delete_context_free (ctx);
return;
}
g_object_get (self,
MM_IFACE_MODEM_MESSAGING_SMS_LIST, &list,
NULL);
if (!list) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot delete SMS: missing SMS list");
handle_delete_context_free (ctx);
return;
}
mm_sms_list_delete_sms (list,
ctx->path,
(GAsyncReadyCallback)handle_delete_ready,
ctx);
g_object_unref (list);
}
static GckObject *
secret_objects_lookup_gck_object_for_invocation (GkdSecretObjects *self,
GDBusMethodInvocation *invocation)
{
GError *error = NULL;
GckObject *object;
object = secret_objects_lookup_gck_object_for_path (self,
g_dbus_method_invocation_get_sender (invocation),
g_dbus_method_invocation_get_object_path (invocation),
&error);
if (!object)
g_dbus_method_invocation_take_error (invocation, error);
return object;
}
static void
end_invocation_take_gerror (GDBusMethodInvocation *invocation,
GError *error)
{
gchar *remote_error = g_dbus_error_get_remote_error (error);
if (remote_error)
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s (%s)", error->message, remote_error);
g_free (remote_error);
g_error_free (error);
}
else
g_dbus_method_invocation_take_error (invocation, error);
}
