static gboolean
handle_uninstall (FlatpakSystemHelper *object,
GDBusMethodInvocation *invocation,
guint arg_flags,
const gchar *arg_ref)
{
g_autoptr(FlatpakDir) system = dir_get_system ();
g_autoptr(GError) error = NULL;
g_debug ("Uninstall %u %s", arg_flags, arg_ref);
if ((arg_flags & ~FLATPAK_HELPER_UNINSTALL_FLAGS_ALL) != 0)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
"Unsupported flags enabled: 0x%x", (arg_flags & ~FLATPAK_HELPER_UNINSTALL_FLAGS_ALL));
return TRUE;
}
if (!flatpak_dir_ensure_repo (system, NULL, &error))
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
if (!flatpak_dir_uninstall (system, arg_ref, arg_flags, NULL, &error))
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
flatpak_system_helper_complete_uninstall (object, invocation);
return TRUE;
}
/*
* This handler is run in a separate thread, so all operations can be
* synchronous.
*/
static gboolean
on_authorize_method_check (GDBusInterfaceSkeleton *interface,
GDBusMethodInvocation *invocation,
EmerDaemon *daemon)
{
const gchar *method_name =
g_dbus_method_invocation_get_method_name (invocation);
const AuthorizedMethod *authorized_method = lookup_authorized_method (method_name);
if (authorized_method == NULL)
return TRUE;
GError *error = NULL;
PolkitAuthority *authority =
polkit_authority_get_sync (NULL /*GCancellable*/, &error);
if (authority == NULL)
{
g_critical ("Could not get PolicyKit authority: %s.", error->message);
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
return FALSE;
}
const gchar *sender_name = g_dbus_method_invocation_get_sender (invocation);
PolkitSubject *subject = polkit_system_bus_name_new (sender_name);
PolkitAuthorizationResult *result =
polkit_authority_check_authorization_sync (authority,
subject,
authorized_method->method_full_name,
NULL /*PolkitDetails*/,
POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE,
NULL /*GCancellable*/,
&error);
g_object_unref (authority);
g_object_unref (subject);
if (result == NULL)
{
g_critical ("Could not get PolicyKit authorization result: %s.",
error->message);
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
return FALSE;
}
gboolean authorized = polkit_authorization_result_get_is_authorized (result);
if (!authorized)
g_dbus_method_invocation_return_error_literal (invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_AUTH_FAILED,
authorized_method->error_message);
g_object_unref (result);
return authorized;
}
/**
* cd_sensor_get_sample_cb:
**/
static void
cd_sensor_get_sample_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *result = NULL;
CdColorXYZ *sample;
CdSensor *sensor = CD_SENSOR (source_object);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
GError *error = NULL;
/* get the result */
sample = sensor->priv->desc->get_sample_finish (sensor, res, &error);
if (sample == NULL) {
g_dbus_method_invocation_return_gerror (invocation,
error);
g_error_free (error);
goto out;
}
/* return value */
g_debug ("returning value %f, %f, %f",
sample->X,
sample->Y,
sample->Z);
result = g_variant_new ("(ddd)",
sample->X,
sample->Y,
sample->Z);
g_dbus_method_invocation_return_value (invocation, result);
out:
if (sample != NULL)
cd_color_xyz_free (sample);
}
static void
sniff_async_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
InvocationData *data = user_data;
gchar **types;
GError *error = NULL;
types = cinnamon_mime_sniffer_sniff_finish (CINNAMON_MIME_SNIFFER (source),
res, &error);
if (error != NULL)
{
g_dbus_method_invocation_return_gerror (data->invocation, error);
g_error_free (error);
goto out;
}
g_dbus_method_invocation_return_value (data->invocation,
g_variant_new ("(^as)", types));
g_strfreev (types);
out:
invocation_data_free (data);
ensure_autoquit_on ();
}
static void _dbus_steadyflow_iapp_service_set_visible (SteadyflowIAppService* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error = NULL;
GVariantIter _arguments_iter;
gboolean visible = FALSE;
GVariant* _tmp1_;
GDBusMessage* _reply_message;
GVariant* _reply;
GVariantBuilder _reply_builder;
g_variant_iter_init (&_arguments_iter, parameters);
_tmp1_ = g_variant_iter_next_value (&_arguments_iter);
visible = g_variant_get_boolean (_tmp1_);
g_variant_unref (_tmp1_);
steadyflow_iapp_service_set_visible (self, visible, &error);
if (error) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
_reply = g_variant_builder_end (&_reply_builder);
g_dbus_message_set_body (_reply_message, _reply);
g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (invocation);
g_object_unref (_reply_message);
}
static gboolean
handle_close (XdpRequest *object,
GDBusMethodInvocation *invocation,
Request *request)
{
g_autoptr(GError) error = NULL;
REQUEST_AUTOLOCK (request);
if (request->exported)
{
const char *handle = g_object_get_data (G_OBJECT (request), "impl-handle");
if (!xdp_impl_file_chooser_call_close_sync (impl,
request->sender, request->app_id, handle,
NULL, &error))
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
unregister_handle (handle);
request_unexport (request);
}
xdp_request_complete_close (XDP_REQUEST (request), invocation);
return TRUE;
}
static gboolean
handle_set_profile (MmGdbusTest *skeleton,
GDBusMethodInvocation *invocation,
const gchar *id,
const gchar *plugin_name,
const gchar *const *ports,
MMBaseManager *self)
{
MMPlugin *plugin;
MMDevice *device;
gchar *physdev;
GError *error = NULL;
mm_info ("Test profile set to: '%s'", id);
/* Create device and keep it listed in the Manager */
physdev = g_strdup_printf ("/virtual/%s", id);
device = mm_device_virtual_new (physdev, TRUE);
g_hash_table_insert (self->priv->devices, physdev, device);
/* Grab virtual ports */
mm_device_virtual_grab_ports (device, (const gchar **)ports);
/* Set plugin to use */
plugin = mm_plugin_manager_peek_plugin (self->priv->plugin_manager, plugin_name);
if (!plugin) {
error = g_error_new (MM_CORE_ERROR,
MM_CORE_ERROR_NOT_FOUND,
"Requested plugin '%s' not found",
plugin_name);
mm_warn ("Couldn't set plugin for virtual device at '%s': %s",
mm_device_get_path (device),
error->message);
goto out;
}
mm_device_set_plugin (device, G_OBJECT (plugin));
/* Create modem */
if (!mm_device_create_modem (device, self->priv->object_manager, &error)) {
mm_warn ("Couldn't create modem for virtual device at '%s': %s",
mm_device_get_path (device),
error->message);
goto out;
}
mm_info ("Modem for virtual device at '%s' successfully created",
mm_device_get_path (device));
out:
if (error) {
mm_device_remove_modem (device);
g_hash_table_remove (self->priv->devices, mm_device_get_path (device));
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
} else
mm_gdbus_test_complete_set_profile (skeleton, invocation);
return TRUE;
}
static void
korva_server_on_push_async_ready (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
KorvaDevice *device = KORVA_DEVICE (obj);
PushAsyncData *data = (PushAsyncData *) user_data;
GError *error = NULL;
char *tag;
tag = korva_device_push_finish (device, res, &error);
if (tag == NULL) {
g_dbus_method_invocation_return_gerror (data->invocation,
error);
goto out;
}
g_hash_table_insert (data->self->priv->tags,
g_strdup (tag),
g_strdup (korva_device_get_uid (device)));
korva_controller1_complete_push (data->self->priv->dbus_controller, data->invocation, tag);
g_free (tag);
out:
g_free (data);
}
static gboolean
handle_prepare_print (XdpPrint *object,
GDBusMethodInvocation *invocation,
const gchar *arg_parent_window,
const gchar *arg_title,
GVariant *arg_settings,
GVariant *arg_page_setup,
GVariant *arg_options)
{
Request *request = request_from_invocation (invocation);
const char *app_id = xdp_app_info_get_id (request->app_info);
g_autoptr(GError) error = NULL;
g_autoptr(XdpImplRequest) impl_request = NULL;
GVariantBuilder opt_builder;
if (xdp_impl_lockdown_get_disable_printing (lockdown))
{
g_debug ("Printing disabled");
g_dbus_method_invocation_return_error (invocation,
XDG_DESKTOP_PORTAL_ERROR,
XDG_DESKTOP_PORTAL_ERROR_NOT_ALLOWED,
"Printing disabled");
return TRUE;
}
REQUEST_AUTOLOCK (request);
impl_request = xdp_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),
G_DBUS_PROXY_FLAGS_NONE,
g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),
request->id,
NULL, &error);
if (!impl_request)
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
request_set_impl_request (request, impl_request);
request_export (request, g_dbus_method_invocation_get_connection (invocation));
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
xdp_filter_options (arg_options, &opt_builder,
prepare_print_options, G_N_ELEMENTS (prepare_print_options));
xdp_impl_print_call_prepare_print (impl,
request->id,
app_id,
arg_parent_window,
arg_title,
arg_settings,
arg_page_setup,
g_variant_builder_end (&opt_builder),
NULL,
prepare_print_done,
g_object_ref (request));
xdp_print_complete_prepare_print (object, invocation, request->id);
return TRUE;
}
static void
handle_result(GDBusMethodInvocation *invocation,
gboolean ret,
GError *error)
{
if (ret)
{
g_dbus_method_invocation_return_value(invocation, NULL);
}
else
{
if (error != NULL)
{
xmr_debug("mpris: returning error: %s", error->message);
g_dbus_method_invocation_return_gerror(invocation, error);
g_error_free(error);
}
else
{
xmr_debug("mpris: returning unknown error");
g_dbus_method_invocation_return_error_literal(invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_FAILED,
"Unknown error");
}
}
}
static void prv_connector_return_error(dleyna_connector_msg_id_t message_id,
const GError *error)
{
g_dbus_method_invocation_return_gerror(
(GDBusMethodInvocation *)message_id,
error);
}
/**
* cd_sensor_get_sample_cb:
**/
static void
cd_sensor_get_sample_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *result = NULL;
g_autoptr(CdColorXYZ) sample = NULL;
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
g_autoptr(GError) error = NULL;
/* set here to avoid every sensor doing this */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_IDLE);
/* get the result */
sample = priv->desc->get_sample_finish (sensor, res, &error);
if (sample == NULL) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
/* return value */
g_debug ("returning value %f, %f, %f", sample->X, sample->Y, sample->Z);
result = g_variant_new ("(ddd)", sample->X, sample->Y, sample->Z);
g_dbus_method_invocation_return_value (invocation, result);
}
static gboolean
perform_writeback_cb (gpointer user_data)
{
TrackerControllerPrivate *priv;
WritebackData *data;
data = user_data;
priv = data->controller->priv;
priv->ongoing_tasks = g_list_remove (priv->ongoing_tasks, data);
if (data->error == NULL) {
g_dbus_method_invocation_return_value (data->invocation, NULL);
} else {
g_dbus_method_invocation_return_gerror (data->invocation, data->error);
}
tracker_dbus_request_end (data->request, NULL);
g_mutex_lock (&priv->mutex);
priv->current = NULL;
g_mutex_unlock (&priv->mutex);
writeback_data_free (data);
return FALSE;
}
/**
* g_dbus_method_invocation_take_error: (skip)
* @invocation: (transfer full): A #GDBusMethodInvocation.
* @error: (transfer full): A #GError.
*
* Like g_dbus_method_invocation_return_gerror() but takes ownership
* of @error so the caller does not need to free it.
*
* This method will free @invocation, you cannot use it afterwards.
*
* Since: 2.30
*/
void
g_dbus_method_invocation_take_error (GDBusMethodInvocation *invocation,
GError *error)
{
g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation));
g_return_if_fail (error != NULL);
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
}
static void
infinoted_plugin_dbus_set_acl(InfinotedPluginDbus* plugin,
InfinotedPluginDbusInvocation* invocation,
InfBrowser* browser,
const InfBrowserIter* iter)
{
GVariant* sheet_set_variant;
InfAclSheetSet* sheet_set;
GError* error;
InfRequest* request;
g_variant_get_child(
invocation->parameters,
1,
"@a{sa{sb}}",
&sheet_set_variant
);
error = NULL;
sheet_set = infinoted_plugin_dbus_sheet_set_from_variant(
sheet_set_variant,
&error
);
g_variant_unref(sheet_set_variant);
if(error != NULL)
{
g_dbus_method_invocation_return_gerror(invocation->invocation, error);
g_error_free(error);
infinoted_plugin_dbus_invocation_free(plugin, invocation);
}
else
{
request = inf_browser_set_acl(
browser,
iter,
sheet_set,
infinoted_plugin_dbus_set_acl_finished_cb,
invocation
);
inf_acl_sheet_set_free(sheet_set);
if(request != NULL)
{
invocation->request = request;
invocation->request_func = infinoted_plugin_dbus_set_acl_finished_cb;
}
}
}
void rsu_task_fail_and_delete(rsu_task_t *task, GError *error)
{
if (!task)
goto finished;
if (task->invocation)
g_dbus_method_invocation_return_gerror(task->invocation, error);
prv_rsu_task_delete(task);
finished:
return;
}
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
handle_save_file (XdpFileChooser *object,
GDBusMethodInvocation *invocation,
const gchar *arg_parent_window,
const gchar *arg_title,
GVariant *arg_options)
{
Request *request = request_from_invocation (invocation);
const char *app_id = request->app_id;
g_autoptr(GError) error = NULL;
XdpImplRequest *impl_request;
GVariantBuilder options;
REQUEST_AUTOLOCK (request);
g_variant_builder_init (&options, G_VARIANT_TYPE_VARDICT);
xdp_filter_options (arg_options, &options,
save_file_options, G_N_ELEMENTS (save_file_options));
impl_request = xdp_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),
G_DBUS_PROXY_FLAGS_NONE,
g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),
request->id,
NULL, &error);
if (!impl_request)
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
g_object_set_data (G_OBJECT (request), "for-save", GINT_TO_POINTER (TRUE));
request_set_impl_request (request, impl_request);
request_export (request, g_dbus_method_invocation_get_connection (invocation));
xdp_impl_file_chooser_call_save_file (impl,
request->id,
app_id,
arg_parent_window,
arg_title,
g_variant_builder_end (&options),
NULL,
save_file_done,
g_object_ref (request));
xdp_file_chooser_complete_open_file (object, invocation, request->id);
return TRUE;
}
/**
* g_dbus_method_invocation_return_error_literal:
* @invocation: A #GDBusMethodInvocation.
* @domain: A #GQuark for the #GError error domain.
* @code: The error code.
* @message: The error message.
*
* Like g_dbus_method_invocation_return_error() but without printf()-style formatting.
*
* This method will free @invocation, you cannot use it afterwards.
*
* Since: 2.26
*/
void
g_dbus_method_invocation_return_error_literal (GDBusMethodInvocation *invocation,
GQuark domain,
gint code,
const gchar *message)
{
GError *error;
g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation));
g_return_if_fail (message != NULL);
error = g_error_new_literal (domain, code, message);
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
}
static void
ensure_credentials_cb (GoaProvider *provider,
GAsyncResult *res,
gpointer user_data)
{
EnsureData *data = user_data;
gint expires_in;
GError *error;
error= NULL;
if (!goa_provider_ensure_credentials_finish (provider, &expires_in, res, &error))
{
/* Set AttentionNeeded only if the error is an authorization error */
if (is_authorization_error (error))
{
GoaAccount *account;
account = goa_object_peek_account (data->object);
if (!goa_account_get_attention_needed (account))
{
goa_account_set_attention_needed (account, TRUE);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (account));
g_message ("%s: Setting AttentionNeeded to TRUE because EnsureCredentials() failed with: %s (%s, %d)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object)),
error->message, g_quark_to_string (error->domain), error->code);
}
}
g_dbus_method_invocation_return_gerror (data->invocation, error);
g_error_free (error);
}
else
{
GoaAccount *account;
account = goa_object_peek_account (data->object);
/* Clear AttentionNeeded flag if set */
if (goa_account_get_attention_needed (account))
{
goa_account_set_attention_needed (account, FALSE);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (account));
g_message ("%s: Setting AttentionNeeded to FALSE because EnsureCredentials() succeded\n",
g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object)));
}
goa_account_complete_ensure_credentials (goa_object_peek_account (data->object),
data->invocation,
expires_in);
}
ensure_data_unref (data);
}
static gboolean
on_reset_tracking_id (EmerEventRecorderServer *server,
GDBusMethodInvocation *invocation,
EmerDaemon *daemon)
{
g_autoptr(GError) error = NULL;
if (!emer_daemon_reset_tracking_id (daemon, &error))
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
emer_event_recorder_server_complete_reset_tracking_id (server, invocation);
return TRUE;
}
static void
got_app_id_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (source_object);
g_autoptr(GError) error = NULL;
g_autofree char *app_id = NULL;
PortalMethod portal_method = user_data;
app_id = xdg_app_invocation_lookup_app_id_finish (invocation, res, &error);
if (app_id == NULL)
g_dbus_method_invocation_return_gerror (invocation, error);
else
portal_method (invocation, g_dbus_method_invocation_get_parameters (invocation), app_id);
}
static gboolean
handle_set_slave_bus_name (GdmDBusDisplay *skeleton,
GDBusMethodInvocation *invocation,
const char *bus_name,
GdmDisplay *display)
{
GError *error = NULL;
if (gdm_display_set_slave_bus_name (display, bus_name, &error)) {
gdm_dbus_display_complete_set_slave_bus_name (skeleton, invocation);
} else {
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
}
return TRUE;
}
static gboolean
handle_remove_user_authorization (GdmDBusDisplay *skeleton,
GDBusMethodInvocation *invocation,
const char *username,
GdmDisplay *display)
{
GError *error = NULL;
if (gdm_display_remove_user_authorization (display, username, &error)) {
gdm_dbus_display_complete_remove_user_authorization (skeleton, invocation);
} else {
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
}
return TRUE;
}
static void
got_app_id_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (source_object);
gboolean create = GPOINTER_TO_INT (user_data);
g_autoptr(GError) error = NULL;
char *app_id;
app_id = xdp_invocation_lookup_app_id_finish (invocation, res, &error);
if (app_id == NULL)
g_dbus_method_invocation_return_gerror (invocation, error);
else
open_content_chooser (invocation, app_id, create);
}
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 void
infinoted_plugin_dbus_check_acl(InfinotedPluginDbus* plugin,
InfinotedPluginDbusInvocation* invocation,
InfBrowser* browser,
const InfBrowserIter* iter)
{
const gchar* account;
GVariant* mask_variant;
InfAclMask mask;
InfAclMask out;
GError* error;
g_variant_get_child(invocation->parameters, 1, "&s", &account);
g_variant_get_child(invocation->parameters, 2, "@as", &mask_variant);
error = NULL;
infinoted_plugin_dbus_mask_from_variant(&mask, mask_variant, &error);
g_variant_unref(mask_variant);
if(error != NULL)
{
g_dbus_method_invocation_return_gerror(invocation->invocation, error);
g_error_free(error);
}
else
{
inf_browser_check_acl(
browser,
iter,
inf_acl_account_id_from_string(account),
&mask,
&out
);
g_dbus_method_invocation_return_value(
invocation->invocation,
g_variant_new(
"(@a{sb})",
infinoted_plugin_dbus_perms_to_variant(&mask, &out)
)
);
}
infinoted_plugin_dbus_invocation_free(plugin, invocation);
}
/**
* cd_sensor_set_options_cb:
**/
static void
cd_sensor_set_options_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
gboolean ret;
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
g_autoptr(GError) error = NULL;
/* get the result */
ret = priv->desc->set_options_finish (sensor, res, &error);
if (!ret) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
g_dbus_method_invocation_return_value (invocation, NULL);
}
/**
* cd_sensor_get_spectrum_cb:
**/
static void
cd_sensor_get_spectrum_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
GVariant *result = NULL;
GVariantBuilder data;
guint i;
g_autoptr(CdSpectrum) sp = NULL;
g_autoptr(GError) error = NULL;
/* set here to avoid every sensor doing this */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_IDLE);
/* get the result */
sp = priv->desc->get_spectrum_finish (sensor, res, &error);
if (sp == NULL) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
/* build data array */
g_variant_builder_init (&data, G_VARIANT_TYPE ("ad"));
for (i = 0; i < cd_spectrum_get_size (sp); i++) {
g_variant_builder_add (&data, "d",
cd_spectrum_get_value (sp, i));
}
/* return value */
g_debug ("returning value %f, %f, [%u]",
cd_spectrum_get_start (sp),
cd_spectrum_get_end (sp),
cd_spectrum_get_size (sp));
result = g_variant_new ("(ddad)",
cd_spectrum_get_start (sp),
cd_spectrum_get_end (sp),
&data);
g_dbus_method_invocation_return_value (invocation, result);
}
static gboolean
handle_install_bundle (FlatpakSystemHelper *object,
GDBusMethodInvocation *invocation,
const gchar *arg_bundle_path,
guint32 arg_flags,
GVariant *arg_gpg_key)
{
g_autoptr(FlatpakDir) system = dir_get_system ();
g_autoptr(GFile) path = g_file_new_for_path (arg_bundle_path);
g_autoptr(GError) error = NULL;
g_autoptr(GBytes) gpg_data = NULL;
g_autofree char *ref = NULL;
g_debug ("InstallBundle %s %u %p", arg_bundle_path, arg_flags, arg_gpg_key);
if (arg_flags != 0)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
"Unsupported flags enabled: 0x%x", arg_flags);
return TRUE;
}
if (!g_file_query_exists (path, NULL))
{
g_dbus_method_invocation_return_error (invocation, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
"Bundle %s does not exist", arg_bundle_path);
return TRUE;
}
if (g_variant_get_size (arg_gpg_key) > 0)
gpg_data = g_variant_get_data_as_bytes (arg_gpg_key);
if (!flatpak_dir_install_bundle (system, path, gpg_data, &ref, NULL, &error))
{
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
flatpak_system_helper_complete_install_bundle (object, invocation, ref);
return TRUE;
}
