static void
impl_ifcfgrh_get_ifcfg_details (SettingsPluginIfcfg *plugin,
GDBusMethodInvocation *context,
const char *in_ifcfg)
{
NMIfcfgConnection *connection;
NMSettingConnection *s_con;
const char *uuid;
const char *path;
if (!g_path_is_absolute (in_ifcfg)) {
g_dbus_method_invocation_return_error (context,
NM_SETTINGS_ERROR,
NM_SETTINGS_ERROR_INVALID_CONNECTION,
"ifcfg path '%s' is not absolute", in_ifcfg);
return;
}
connection = find_by_path (plugin, in_ifcfg);
if ( !connection
|| nm_ifcfg_connection_get_unmanaged_spec (connection)
|| nm_ifcfg_connection_get_unrecognized_spec (connection)) {
g_dbus_method_invocation_return_error (context,
NM_SETTINGS_ERROR,
NM_SETTINGS_ERROR_INVALID_CONNECTION,
"ifcfg file '%s' unknown", in_ifcfg);
return;
}
s_con = nm_connection_get_setting_connection (NM_CONNECTION (connection));
if (!s_con) {
g_dbus_method_invocation_return_error (context,
NM_SETTINGS_ERROR,
NM_SETTINGS_ERROR_FAILED,
"unable to retrieve the connection setting");
return;
}
uuid = nm_setting_connection_get_uuid (s_con);
if (!uuid) {
g_dbus_method_invocation_return_error (context,
NM_SETTINGS_ERROR,
NM_SETTINGS_ERROR_FAILED,
"unable to get the UUID");
return;
}
path = nm_connection_get_path (NM_CONNECTION (connection));
if (!path) {
g_dbus_method_invocation_return_error (context,
NM_SETTINGS_ERROR,
NM_SETTINGS_ERROR_FAILED,
"unable to get the connection D-Bus path");
return;
}
g_dbus_method_invocation_return_value (context,
g_variant_new ("(so)", uuid, path));
}
static gboolean
meta_monitor_manager_handle_get_crtc_gamma (MetaDBusDisplayConfig *skeleton,
GDBusMethodInvocation *invocation,
guint serial,
guint crtc_id)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
MetaMonitorManagerClass *klass;
MetaCRTC *crtc;
gsize size;
unsigned short *red;
unsigned short *green;
unsigned short *blue;
GBytes *red_bytes, *green_bytes, *blue_bytes;
GVariant *red_v, *green_v, *blue_v;
if (serial != manager->serial)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_ACCESS_DENIED,
"The requested configuration is based on stale information");
return TRUE;
}
if (crtc_id >= manager->n_crtcs)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid crtc id");
return TRUE;
}
crtc = &manager->crtcs[crtc_id];
klass = META_MONITOR_MANAGER_GET_CLASS (manager);
if (klass->get_crtc_gamma)
klass->get_crtc_gamma (manager, crtc, &size, &red, &green, &blue);
else
{
size = 0;
red = green = blue = NULL;
}
red_bytes = g_bytes_new_take (red, size * sizeof (unsigned short));
green_bytes = g_bytes_new_take (green, size * sizeof (unsigned short));
blue_bytes = g_bytes_new_take (blue, size * sizeof (unsigned short));
red_v = g_variant_new_from_bytes (G_VARIANT_TYPE ("aq"), red_bytes, TRUE);
green_v = g_variant_new_from_bytes (G_VARIANT_TYPE ("aq"), green_bytes, TRUE);
blue_v = g_variant_new_from_bytes (G_VARIANT_TYPE ("aq"), blue_bytes, TRUE);
meta_dbus_display_config_complete_get_crtc_gamma (skeleton, invocation,
red_v, green_v, blue_v);
g_bytes_unref (red_bytes);
g_bytes_unref (green_bytes);
g_bytes_unref (blue_bytes);
return TRUE;
}
static gboolean
meta_monitor_manager_handle_set_crtc_gamma (MetaDBusDisplayConfig *skeleton,
GDBusMethodInvocation *invocation,
guint serial,
guint crtc_id,
GVariant *red_v,
GVariant *green_v,
GVariant *blue_v)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
MetaMonitorManagerClass *klass;
MetaCRTC *crtc;
gsize size, dummy;
unsigned short *red;
unsigned short *green;
unsigned short *blue;
GBytes *red_bytes, *green_bytes, *blue_bytes;
if (serial != manager->serial)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_ACCESS_DENIED,
"The requested configuration is based on stale information");
return TRUE;
}
if (crtc_id >= manager->n_crtcs)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid crtc id");
return TRUE;
}
crtc = &manager->crtcs[crtc_id];
red_bytes = g_variant_get_data_as_bytes (red_v);
green_bytes = g_variant_get_data_as_bytes (green_v);
blue_bytes = g_variant_get_data_as_bytes (blue_v);
size = g_bytes_get_size (red_bytes) / sizeof (unsigned short);
red = (unsigned short*) g_bytes_get_data (red_bytes, &dummy);
green = (unsigned short*) g_bytes_get_data (green_bytes, &dummy);
blue = (unsigned short*) g_bytes_get_data (blue_bytes, &dummy);
klass = META_MONITOR_MANAGER_GET_CLASS (manager);
if (klass->set_crtc_gamma)
klass->set_crtc_gamma (manager, crtc, size, red, green, blue);
meta_dbus_display_config_complete_set_crtc_gamma (skeleton, invocation);
g_bytes_unref (red_bytes);
g_bytes_unref (green_bytes);
g_bytes_unref (blue_bytes);
return TRUE;
}
static gboolean
handle_delete_partition (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation)
{
StorageBlock *block = STORAGE_BLOCK(object);
StorageProvider *provider = storage_object_get_provider (block->object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
UDisksObject *udisks_object =
(UDisksObject *) g_dbus_interface_get_object(G_DBUS_INTERFACE (block->udisks_block));
if (udisks_object == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"No object!?");
g_error_free (error);
return TRUE;
}
UDisksPartition *part = udisks_object_peek_partition (udisks_object);
if (part == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"Block device is not a partition");
g_error_free (error);
return TRUE;
}
if (!storage_cleanup_block (provider,
block->udisks_block,
&error)
|| !udisks_partition_call_delete_sync (part,
g_variant_new ("a{sv}", 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_block_complete_delete_partition (object, invocation);
return TRUE;
}
static gboolean
handle_unlock (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation,
const gchar *arg_passphrase)
{
StorageBlock *block = STORAGE_BLOCK(object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
UDisksObject *udisks_object =
(UDisksObject *) g_dbus_interface_get_object(G_DBUS_INTERFACE (block->udisks_block));
if (udisks_object == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"No object!?");
g_error_free (error);
return TRUE;
}
UDisksEncrypted *enc = udisks_object_peek_encrypted (udisks_object);
if (enc == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"Block device is not encrypted");
g_error_free (error);
return TRUE;
}
if (!udisks_encrypted_call_unlock_sync (enc,
arg_passphrase,
g_variant_new ("a{sv}", NULL),
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_block_complete_unlock (object, invocation);
return TRUE;
}
static void
portal_revoke_permissions (GDBusMethodInvocation *invocation,
GVariant *parameters,
const char *app_id)
{
const char *target_app_id;
const char *id;
g_autofree const char **permissions = NULL;
g_autoptr(XdgAppDbEntry) entry = NULL;
XdpPermissionFlags perms;
g_variant_get (parameters, "(&s&s^a&s)", &id, &target_app_id, &permissions);
{
AUTOLOCK(db);
entry = xdg_app_db_lookup (db, id);
if (entry == NULL)
{
g_dbus_method_invocation_return_error (invocation, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_NOT_FOUND,
"No such document: %s", id);
return;
}
if (!xdg_app_is_valid_name (target_app_id))
{
g_dbus_method_invocation_return_error (invocation, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_INVALID_ARGUMENT,
"Invalid app name: %s", target_app_id);
return;
}
perms = xdp_parse_permissions (permissions);
/* Must have grant-permissions, or be itself */
if (!xdp_entry_has_permissions (entry, app_id,
XDP_PERMISSION_FLAGS_GRANT_PERMISSIONS) ||
strcmp (app_id, target_app_id) == 0)
{
g_dbus_method_invocation_return_error (invocation, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_NOT_ALLOWED,
"Not enough permissions");
return;
}
do_set_permissions (entry, id, target_app_id,
~perms & xdp_entry_get_permissions (entry, target_app_id));
}
/* Invalidate with lock dropped to avoid deadlock */
xdp_fuse_invalidate_doc_app (id, target_app_id);
g_dbus_method_invocation_return_value (invocation, g_variant_new ("()"));
}
static gboolean
handle_mount (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation)
{
StorageBlock *block = STORAGE_BLOCK(object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
UDisksObject *udisks_object =
(UDisksObject *) g_dbus_interface_get_object(G_DBUS_INTERFACE (block->udisks_block));
if (udisks_object == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"No object!?");
g_error_free (error);
return TRUE;
}
UDisksFilesystem *fsys = udisks_object_peek_filesystem (udisks_object);
if (fsys == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"Block device is not a filesystem");
g_error_free (error);
return TRUE;
}
if (!udisks_filesystem_call_mount_sync (fsys,
g_variant_new ("a{sv}", NULL),
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_block_complete_mount (object, invocation);
return TRUE;
}
static void
content_chooser_done (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GSubprocess) subprocess = G_SUBPROCESS (object);
ContentChooserData *data = user_data;
g_autoptr(GBytes) stdout_buf = NULL;
g_autoptr(GError) error = NULL;
const char *uri = NULL;
g_autoptr (GFile) file = NULL;
g_autoptr(GDBusConnection) connection = NULL;
if (!g_subprocess_communicate_finish (subprocess, result, &stdout_buf, NULL, &error))
{
g_dbus_method_invocation_return_error (data->invocation,
XDP_ERROR, XDP_ERROR_FAILED,
"Content chooser failed: %s", error->message);
g_free (data);
return;
}
if (!g_subprocess_get_if_exited (subprocess) ||
g_subprocess_get_exit_status (subprocess) != 0)
{
g_dbus_method_invocation_return_error (data->invocation,
XDP_ERROR, XDP_ERROR_FAILED,
"Content chooser exit %d", g_subprocess_get_exit_status (subprocess));
g_free (data);
return;
}
uri = g_bytes_get_data (stdout_buf, NULL);
file = g_file_new_for_uri (uri);
data->basename = g_file_get_basename (file);
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
g_dbus_connection_call (connection,
"org.freedesktop.portal.Documents",
"/org/freedesktop/portal/documents",
"org.freedesktop.portal.Documents",
"Add",
g_variant_new ("(s)", uri),
G_VARIANT_TYPE ("(u)"),
G_DBUS_CALL_FLAGS_NONE,
30000,
NULL,
got_document_handle,
data);
}
static void
handle_root_method_call(GDBusConnection *connection,
const char *sender,
const char *object_path,
const char *interface_name,
const char *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
XmrMprisPlugin *plugin)
{
XmrWindow *window = NULL;
if (g_strcmp0(object_path, MPRIS_OBJECT_NAME) != 0 ||
g_strcmp0(interface_name, MPRIS_ROOT_INTERFACE) != 0)
{
g_dbus_method_invocation_return_error(invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Method %s.%s not supported",
interface_name,
method_name);
return;
}
g_object_get(plugin, "object", &window, NULL);
if (g_strcmp0(method_name, "Raise") == 0)
{
gtk_widget_show(GTK_WIDGET(window));
gtk_window_present(GTK_WINDOW(window));
g_dbus_method_invocation_return_value(invocation, NULL);
}
else if (g_strcmp0(method_name, "Quit") == 0)
{
xmr_window_quit(window);
g_dbus_method_invocation_return_value(invocation, NULL);
}
else
{
g_dbus_method_invocation_return_error(invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Method %s.%s not supported",
interface_name,
method_name);
}
g_object_unref(window);
}
static gboolean
meta_monitor_manager_handle_change_backlight (MetaDBusDisplayConfig *skeleton,
GDBusMethodInvocation *invocation,
guint serial,
guint output_id,
gint value)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
MetaOutput *output;
if (serial != manager->serial)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_ACCESS_DENIED,
"The requested configuration is based on stale information");
return TRUE;
}
if (output_id >= manager->n_outputs)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid output id");
return TRUE;
}
output = &manager->outputs[output_id];
if (value < 0 || value > 100)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid backlight value");
return TRUE;
}
if (output->backlight == -1 ||
(output->backlight_min == 0 && output->backlight_max == 0))
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Output does not support changing backlight");
return TRUE;
}
META_MONITOR_MANAGER_GET_CLASS (manager)->change_backlight (manager, output, value);
meta_dbus_display_config_complete_change_backlight (skeleton, invocation, output->backlight);
return TRUE;
}
static void
portal_delete (GDBusMethodInvocation *invocation,
GVariant *parameters,
const char *app_id)
{
const char *id;
g_autoptr(XdgAppDbEntry) entry = NULL;
g_autofree const char **old_apps = NULL;
int i;
g_variant_get (parameters, "(s)", &id);
{
AUTOLOCK(db);
entry = xdg_app_db_lookup (db, id);
if (entry == NULL)
{
g_dbus_method_invocation_return_error (invocation, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_NOT_FOUND,
"No such document: %s", id);
return;
}
if (!xdp_entry_has_permissions (entry, app_id, XDP_PERMISSION_FLAGS_DELETE))
{
g_dbus_method_invocation_return_error (invocation, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_NOT_ALLOWED,
"Not enough permissions");
return;
}
g_debug ("delete %s", id);
xdg_app_db_set_entry (db, id, NULL);
if (persist_entry (entry))
xdg_app_permission_store_call_delete (permission_store, TABLE_NAME,
id, NULL, NULL, NULL);
}
/* All i/o is done now, so drop the lock so we can invalidate the fuse caches */
old_apps = xdg_app_db_entry_list_apps (entry);
for (i = 0; old_apps[i] != NULL; i++)
xdp_fuse_invalidate_doc_app (id, old_apps[i]);
xdp_fuse_invalidate_doc_app (id, NULL);
/* Now fuse view is up-to-date, so we can return the call */
g_dbus_method_invocation_return_value (invocation, g_variant_new ("()"));
}
static void
handle_player_method_call(GDBusConnection *connection,
const char *sender,
const char *object_path,
const char *interface_name,
const char *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
XmrMprisPlugin *plugin)
{
if(g_strcmp0(object_path, MPRIS_OBJECT_NAME) != 0 ||
g_strcmp0(interface_name, MPRIS_PLAYER_INTERFACE) != 0)
{
g_dbus_method_invocation_return_error(invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Method %s.%s not supported",
interface_name,
method_name);
return;
}
if (g_strcmp0(method_name, "Next") == 0)
{
xmr_window_play_next(plugin->window);
handle_result(invocation, TRUE, NULL);
}
else if (g_strcmp0(method_name, "Pause") == 0)
{
xmr_window_pause(plugin->window);
handle_result(invocation, TRUE, NULL);
}
else if (g_strcmp0 (method_name, "Play") == 0)
{
xmr_window_play(plugin->window);
handle_result(invocation, TRUE, NULL);
}
else
{
g_dbus_method_invocation_return_error(invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Method %s.%s not supported",
interface_name,
method_name);
}
}
static void
on_discover_done (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
struct DiscoverData *data = (struct DiscoverData *)user_data;
GError *error = NULL;
gs_unref_variant GVariant *discover_result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error);
if (error)
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (data->invocation,
COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"%s", error->message);
g_free (data);
g_error_free (error);
return;
}
g_variant_builder_init (&(data->all_details), G_VARIANT_TYPE ("aa{sv}"));
g_variant_get (discover_result, "(iao)", NULL, &(data->object_paths));
data->cur_proxy = NULL;
get_next_discover_info (data);
}
static gboolean
handle_set_crypto_options (CockpitStorageBlock *object,
GDBusMethodInvocation *invocation,
const gchar *arg_passphrase,
const gchar *arg_options)
{
StorageBlock *block = STORAGE_BLOCK(object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
if (!(storage_remove_crypto_config (block->udisks_block,
&error)
&& set_crypto_config (block->udisks_block,
arg_passphrase,
arg_options,
&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_block_complete_set_crypto_options (object, invocation);
return TRUE;
}
static void
create_account_done (ActUserManager *manager,
GAsyncResult *res,
CallData *data)
{
CockpitAccounts *object = data->object;
GDBusMethodInvocation *invocation = data->invocation;
gs_free gchar *password = data->password;
gboolean locked = data->locked;
g_free (data);
GError *error = NULL;
ActUser *user = act_user_manager_create_user_finish (manager, res, &error);
if (user == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"Failed to create user account: %s", error->message);
g_error_free (error);
return;
}
if (password && *password)
{
act_user_set_password_mode (user, ACT_USER_PASSWORD_MODE_REGULAR);
act_user_set_password (user, password, "");
}
act_user_set_locked (user, locked);
cockpit_accounts_complete_create_account (object, invocation);
}
/**
* cd_sensor_unlock_cb:
**/
static void
cd_sensor_unlock_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (source_object);
gboolean ret;
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
GError *error = NULL;
/* get the result */
if (sensor->priv->desc != NULL &&
sensor->priv->desc->unlock_finish != NULL) {
ret = sensor->priv->desc->unlock_finish (sensor, res, &error);
if (!ret) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to unlock: %s",
error->message);
g_error_free (error);
goto out;
}
}
cd_sensor_set_locked (sensor, FALSE);
g_dbus_method_invocation_return_value (invocation, NULL);
out:
return;
}
/* org.nemomobile.MmsEngine.sendReadReport */
static
gboolean
mms_engine_handle_send_read_report(
OrgNemomobileMmsEngine* proxy,
GDBusMethodInvocation* call,
int database_id,
const char* imsi,
const char* message_id,
const char* to,
int read_status, /* 0: Read 1: Deleted without reading */
MMSEngine* engine)
{
GError* error = NULL;
char* id = g_strdup_printf("%d", database_id);
MMS_DEBUG_("%s %s %s %s %d", id, imsi, message_id, to, read_status);
if (mms_dispatcher_send_read_report(engine->dispatcher, id, imsi,
message_id, to, (read_status == 1) ? MMS_READ_STATUS_DELETED :
MMS_READ_STATUS_READ, &error)) {
if (mms_dispatcher_start(engine->dispatcher)) {
mms_engine_start_timeout_cancel(engine);
}
org_nemomobile_mms_engine_complete_send_read_report(proxy, call);
} else {
g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
G_DBUS_ERROR_FAILED, "%s", MMS_ERRMSG(error));
g_error_free(error);
}
g_free(id);
return TRUE;
}
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;
}
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_create_thin_pool_volume (CockpitStorageVolumeGroup *object,
GDBusMethodInvocation *invocation,
const gchar *arg_name,
guint64 arg_size)
{
StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
GError *error = NULL;
gs_free gchar *result = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
if (!lvm_volume_group_call_create_thin_pool_volume_sync (group->lvm_volume_group,
arg_name,
arg_size,
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_delete (CockpitStorageVolumeGroup *object,
GDBusMethodInvocation *invocation)
{
StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
StorageProvider *provider = storage_object_get_provider (group->object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
if (!storage_cleanup_volume_group (provider,
group->lvm_volume_group,
&error)
|| !lvm_volume_group_call_delete_sync (group->lvm_volume_group,
TRUE,
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_delete (object, invocation);
return TRUE;
}
static gboolean
on_handle_delete_object (TestFrobber *object,
GDBusMethodInvocation *invocation,
const gchar *path,
gpointer user_data)
{
MockData *data = user_data;
GDBusObject *previous;
previous = g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (data->object_manager), path);
if (previous != NULL)
{
g_warn_if_fail (g_dbus_object_manager_server_unexport (data->object_manager, path));
test_frobber_complete_delete_object (object, invocation);
g_object_unref (previous);
}
else
{
g_dbus_method_invocation_return_error (invocation,
G_IO_ERROR, G_IO_ERROR_FAILED,
"Sorry, there is no object at %s",
path);
}
return TRUE;
}
static gboolean
on_account_handle_ensure_credentials (GoaAccount *account,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
GoaDaemon *daemon = GOA_DAEMON (user_data);
GoaProvider *provider;
GoaObject *object;
object = GOA_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (account)));
provider = goa_provider_get_for_provider_type (goa_account_get_provider_type (account));
if (provider == NULL)
{
g_dbus_method_invocation_return_error (invocation,
GOA_ERROR,
GOA_ERROR_FAILED,
"Unsupported account type %s for id %s (no provider)",
goa_account_get_provider_type (account),
goa_account_get_id (account));
goto out;
}
goa_provider_ensure_credentials (provider,
object,
NULL, /* GCancellable */
(GAsyncReadyCallback) ensure_credentials_cb,
ensure_data_new (daemon, object, invocation));
out:
return TRUE; /* invocation was handled */
}
static gboolean
korva_server_on_handle_get_device_info (KorvaController1 *iface,
GDBusMethodInvocation *invocation,
const char *uid,
gpointer user_data)
{
KorvaServer *self = KORVA_SERVER (user_data);
KorvaDevice *device;
korva_server_reset_timeout (self);
device = korva_server_get_device (self, uid);
if (device != NULL) {
GVariant *result;
result = korva_device_serialize (device);
korva_controller1_complete_get_device_info (iface, invocation, result);
} else {
g_dbus_method_invocation_return_error (invocation,
KORVA_CONTROLLER1_ERROR,
KORVA_CONTROLLER1_ERROR_NO_SUCH_DEVICE,
"Device '%s' does not exist",
uid);
}
return TRUE;
}
static gboolean
set_invocation (Realms *realms,
GDBusMethodInvocation *invocation,
const gchar *op,
const gchar *name,
GVariant *creds,
GVariant *options)
{
if (realms->op_invocation == NULL)
{
realms->op_invocation = invocation;
realms->op = op;
realms->op_name = g_strdup (name);
realms->op_creds = g_variant_ref (creds);
realms->op_options = g_variant_ref (options);
realms->op_id = g_strdup_printf ("cockpitd-%u", realms->next_op_id++);
realms->op_cancelled = FALSE;
cockpit_realms_set_busy (COCKPIT_REALMS (realms),
g_variant_new ("(ss)", op, name));
g_string_assign (realms->diagnostics, "");
return TRUE;
}
else
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"Busy");
return FALSE;
}
}
static gboolean
handle_set_bitmap_location (CockpitStorageMDRaid *object,
GDBusMethodInvocation *invocation,
const gchar *arg_value)
{
StorageMDRaid *mdraid = STORAGE_MDRAID(object);
GError *error = NULL;
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
GVariantBuilder options;
g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}"));
if (!udisks_mdraid_call_set_bitmap_location_sync (mdraid->udisks_mdraid,
arg_value,
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);
}
else
cockpit_storage_mdraid_complete_set_bitmap_location (object, invocation);
return TRUE;
}
/**
* daemon_authorize_method:
* @daemon: a #Daemon
* @invocation: method invocation handle
*
* Global hook used to authorize DBus methods. We restrict them to
* root at the moment (but this forces the bridge to run as root).
*
* Possibly a better long term fix is that the bridge actually starts
* cockpitd as root, opens a private socketpair between them to speak
* DBus, then drops privileges.
*
* Returns: %TRUE if call should be authorized, %FALSE otherwise
*/
gboolean
daemon_authorize_method (Daemon *daemon,
GDBusMethodInvocation *invocation)
{
GError *error = NULL;
gboolean is_authorized = FALSE;
if (!authorize_method (daemon, invocation, &is_authorized, NULL, &error))
{
g_warning ("Error while authorizing method %s.%s: %s",
g_dbus_method_invocation_get_interface_name (invocation),
g_dbus_method_invocation_get_method_name (invocation),
error->message);
g_clear_error (&error);
return FALSE;
}
if (!is_authorized)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_ACCESS_DENIED,
"Method %s.%s cannot be invoked by non-root",
g_dbus_method_invocation_get_interface_name (invocation),
g_dbus_method_invocation_get_method_name (invocation));
}
return is_authorized;
}
static gboolean
handle_remove (GVfsMetadata *object,
GDBusMethodInvocation *invocation,
const gchar *arg_treefile,
const gchar *arg_path,
GVfsMetadata *daemon)
{
TreeInfo *info;
info = tree_info_lookup (arg_treefile);
if (info == NULL)
{
g_dbus_method_invocation_return_error (invocation,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
_("Can't find metadata file %s"),
arg_treefile);
return TRUE;
}
if (!meta_tree_remove (info->tree, arg_path))
{
g_dbus_method_invocation_return_error_literal (invocation,
G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Unable to remove metadata keys"));
return TRUE;
}
tree_info_schedule_writeout (info);
gvfs_metadata_complete_remove (object, invocation);
return TRUE;
}
static gboolean
handle_list_services (CockpitServices *object,
GDBusMethodInvocation *invocation)
{
Services *services = SERVICES (object);
if (services->systemd == NULL)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"systemd not running");
return TRUE;
}
ListServicesData *data = g_new0(ListServicesData, 1);
data->services = services;
data->invocation = invocation;
g_dbus_proxy_call (services->systemd,
"ListUnits",
NULL,
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT,
NULL,
on_list_units_done,
data);
return TRUE;
}
/**
* cd_sensor_unlock_cb:
**/
static void
cd_sensor_unlock_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;
gboolean ret;
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 */
if (priv->desc != NULL &&
priv->desc->unlock_finish != NULL) {
ret = priv->desc->unlock_finish (sensor, res, &error);
if (!ret) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to unlock: %s",
error->message);
return;
}
}
cd_sensor_set_locked (sensor, FALSE);
g_dbus_method_invocation_return_value (invocation, NULL);
}
