/* runs in thread dedicated to handling the method call so may block */ static gboolean handle_set_hostname (CockpitManager *_manager, GDBusMethodInvocation *invocation, const gchar *arg_pretty_hostname, const gchar *arg_hostname, GVariant *arg_options) { Manager *manager = MANAGER (_manager); GError *error; if (!auth_check_sender_role (invocation, COCKPIT_ROLE_ADMIN)) return TRUE; /* TODO: validate that passed @arg_hostname is not malformed (e.g. only ASCII etc.) */ if (strlen (arg_pretty_hostname) > 0) { error = NULL; if (!g_dbus_proxy_call_sync (manager->hostname1_proxy, "SetPrettyHostname", g_variant_new ("(sb)", arg_pretty_hostname, FALSE), G_DBUS_CALL_FLAGS_NONE, -1, /* timeout_msec */ NULL, /* GCancellable* */ &error)) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_take_error (invocation, error); goto out; } } if (strlen (arg_hostname) > 0) { error = NULL; if (!g_dbus_proxy_call_sync (manager->hostname1_proxy, "SetHostname", g_variant_new ("(sb)", arg_hostname, FALSE), G_DBUS_CALL_FLAGS_NONE, -1, /* timeout_msec */ NULL, /* GCancellable* */ &error)) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_take_error (invocation, error); goto out; } } cockpit_manager_complete_set_hostname (COCKPIT_MANAGER (manager), invocation); out: return TRUE; /* Means we handled the invocation */ }
static void interface_add_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data) { NMSupplicantInterface *self; NMSupplicantInterfacePrivate *priv; gs_free_error GError *error = NULL; gs_unref_variant GVariant *variant = NULL; const char *path; variant = _nm_dbus_proxy_call_finish (proxy, result, G_VARIANT_TYPE ("(o)"), &error); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; self = NM_SUPPLICANT_INTERFACE (user_data); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); if (variant) { g_variant_get (variant, "(&o)", &path); interface_add_done (self, path); } else if (_nm_dbus_error_has_name (error, WPAS_ERROR_EXISTS_ERROR)) { /* Interface already added, just get its object path */ g_dbus_proxy_call (priv->wpas_proxy, "GetInterface", g_variant_new ("(s)", priv->dev), G_DBUS_CALL_FLAGS_NONE, -1, priv->init_cancellable, (GAsyncReadyCallback) interface_get_cb, self); } else if ( g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SPAWN_EXEC_FAILED) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SPAWN_FORK_FAILED) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SPAWN_FAILED) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_TIMEOUT) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_NO_REPLY) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_TIMED_OUT) || g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND)) { /* Supplicant wasn't running and could not be launched via service * activation. Wait for it to start by moving back to the INIT * state. */ g_dbus_error_strip_remote_error (error); nm_log_dbg (LOGD_SUPPLICANT, "(%s): failed to activate supplicant: %s", priv->dev, error->message); set_state (self, NM_SUPPLICANT_INTERFACE_STATE_INIT); } else { g_dbus_error_strip_remote_error (error); nm_log_err (LOGD_SUPPLICANT, "(%s): error adding interface: %s", priv->dev, error->message); set_state (self, NM_SUPPLICANT_INTERFACE_STATE_DOWN); } }
static void join_show_prompt (GisAccountPageEnterprise *page, GError *error) { GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); UmRealmKerberosMembership *membership; UmRealmKerberos *kerberos; gchar hostname[128]; const gchar *name; gtk_entry_set_text (GTK_ENTRY (priv->join_password), ""); gtk_widget_grab_focus (GTK_WIDGET (priv->join_password)); kerberos = um_realm_object_get_kerberos (priv->realm); membership = um_realm_object_get_kerberos_membership (priv->realm); gtk_label_set_text (GTK_LABEL (priv->join_domain), um_realm_kerberos_get_domain_name (kerberos)); if (gethostname (hostname, sizeof (hostname)) == 0) gtk_entry_set_text (GTK_ENTRY (priv->join_computer), hostname); clear_entry_validation_error (GTK_ENTRY (priv->join_name)); clear_entry_validation_error (GTK_ENTRY (priv->join_password)); if (!priv->join_prompted) { name = um_realm_kerberos_membership_get_suggested_administrator (membership); if (name && !g_str_equal (name, "")) { g_debug ("Suggesting admin user: %s", name); gtk_entry_set_text (GTK_ENTRY (priv->join_name), name); } else { gtk_widget_grab_focus (GTK_WIDGET (priv->join_name)); } } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_HOSTNAME)) { g_debug ("Bad host name: %s", error->message); set_entry_validation_error (GTK_ENTRY (priv->join_computer), error->message); } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) { g_debug ("Bad admin password: %s", error->message); set_entry_validation_error (GTK_ENTRY (priv->join_password), error->message); } else { g_debug ("Admin login failure: %s", error->message); g_dbus_error_strip_remote_error (error); set_entry_validation_error (GTK_ENTRY (priv->join_name), error->message); } g_debug ("Showing admin password dialog"); gtk_window_set_transient_for (GTK_WINDOW (priv->join_dialog), GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (page)))); gtk_window_set_modal (GTK_WINDOW (priv->join_dialog), TRUE); gtk_window_present (GTK_WINDOW (priv->join_dialog)); priv->join_prompted = TRUE; g_object_unref (kerberos); g_object_unref (membership); /* And now we wait for on_join_response() */ }
static gboolean handle_deactivate (CockpitStorageLogicalVolume *object, GDBusMethodInvocation *invocation) { StorageLogicalVolume *volume = STORAGE_LOGICAL_VOLUME(object); GError *error = NULL; if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN)) return TRUE; if (!lvm_logical_volume_call_deactivate_sync (volume->lvm_logical_volume, 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_logical_volume_complete_deactivate (object, invocation); return TRUE; }
static void show_error_dialog (GisAccountPageEnterprise *page, const gchar *message, GError *error) { GtkWidget *dialog; if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (page))), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", message); if (error != NULL) { g_dbus_error_strip_remote_error (error); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error->message); } g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_window_present (GTK_WINDOW (dialog)); }
static void interface_get_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data) { NMSupplicantInterface *self; NMSupplicantInterfacePrivate *priv; gs_unref_variant GVariant *variant = NULL; gs_free_error GError *error = NULL; const char *path; variant = _nm_dbus_proxy_call_finish (proxy, result, G_VARIANT_TYPE ("(o)"), &error); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; self = NM_SUPPLICANT_INTERFACE (user_data); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); if (variant) { g_variant_get (variant, "(&o)", &path); interface_add_done (self, path); } else { g_dbus_error_strip_remote_error (error); nm_log_err (LOGD_SUPPLICANT, "(%s): error getting interface: %s", priv->dev, error->message); set_state (self, NM_SUPPLICANT_INTERFACE_STATE_DOWN); } }
static gboolean handle_delete (CockpitStorageMDRaid *object, GDBusMethodInvocation *invocation) { StorageMDRaid *mdraid = STORAGE_MDRAID(object); StorageProvider *provider = storage_object_get_provider (mdraid->object); UDisksClient *udisks_client = storage_provider_get_udisks_client (provider); gs_unref_object UDisksBlock *block = NULL; GList *members = NULL; GError *error = NULL; /* Delete is Stop followed by wiping of all member devices. */ block = udisks_client_get_block_for_mdraid (udisks_client, mdraid->udisks_mdraid); if (block) { if (!storage_cleanup_block (provider, block, &error)) goto out; } GVariantBuilder options; g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}")); if (!udisks_mdraid_call_stop_sync (mdraid->udisks_mdraid, g_variant_builder_end (&options), NULL, &error)) goto out; members = udisks_client_get_members_for_mdraid (udisks_client, mdraid->udisks_mdraid); for (GList *m = members; m; m = m->next) { UDisksBlock *block = m->data; GVariantBuilder options; g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}")); udisks_block_call_format_sync (block, "empty", g_variant_builder_end (&options), NULL, error ? NULL : &error); } out: if (error) { g_dbus_error_strip_remote_error (error); g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "%s", error->message); } else cockpit_storage_mdraid_complete_stop (object, invocation); g_list_free_full (members, g_object_unref); g_clear_error (&error); return TRUE; }
static void send_dbus_reply (CockpitDBusJson1 *self, const gchar *cookie, GVariant *result, GError *error) { cleanup_unref_object JsonBuilder *builder = NULL; builder = prepare_builder ("call-reply"); json_builder_begin_object (builder); json_builder_set_member_name (builder, "cookie"); json_builder_add_string_value (builder, cookie); if (result == NULL) { gchar *error_name; error_name = g_dbus_error_get_remote_error (error); g_dbus_error_strip_remote_error (error); json_builder_set_member_name (builder, "error_name"); json_builder_add_string_value (builder, error_name != NULL ? error_name : ""); json_builder_set_member_name (builder, "error_message"); json_builder_add_string_value (builder, error->message); g_free (error_name); } else { json_builder_set_member_name (builder, "result"); _json_builder_add_gvariant (builder, result); } json_builder_end_object (builder); write_builder (self, builder); }
static void set_ap_scan_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data) { NMSupplicantInterface *self; NMSupplicantInterfacePrivate *priv; gs_unref_variant GVariant *reply = NULL; gs_free_error GError *error = NULL; reply = g_dbus_proxy_call_finish (proxy, result, &error); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; self = NM_SUPPLICANT_INTERFACE (user_data); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); if (!reply) { g_dbus_error_strip_remote_error (error); nm_log_warn (LOGD_SUPPLICANT, "Couldn't send AP scan mode to the supplicant interface: %s.", error->message); emit_error_helper (self, error); return; } nm_log_info (LOGD_SUPPLICANT, "Config: set interface ap_scan to %d", nm_supplicant_config_get_ap_scan (priv->cfg)); g_dbus_proxy_call (priv->iface_proxy, "AddNetwork", g_variant_new ("(@a{sv})", nm_supplicant_config_to_variant (priv->cfg)), G_DBUS_CALL_FLAGS_NONE, -1, priv->assoc_cancellable, (GAsyncReadyCallback) add_network_cb, self); }
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; }
static void list_connections (GDBusProxy *proxy) { int i; GError *error = NULL; GVariant *ret; char **paths; /* Call ListConnections D-Bus method */ ret = g_dbus_proxy_call_sync (proxy, "ListConnections", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (!ret) { g_dbus_error_strip_remote_error (error); g_print ("ListConnections failed: %s\n", error->message); g_error_free (error); return; } g_variant_get (ret, "(^ao)", &paths); g_variant_unref (ret); for (i = 0; paths[i]; i++) g_print ("%s\n", paths[i]); g_strfreev (paths); }
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); }
/** * fu_util_clear_results: **/ static gboolean fu_util_clear_results (FuUtilPrivate *priv, gchar **values, GError **error) { if (g_strv_length (values) != 1) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "Invalid arguments: expected 'id'"); return FALSE; } /* clear results, and wait for reply */ g_dbus_proxy_call (priv->proxy, "ClearResults", g_variant_new ("(s)", values[0]), G_DBUS_CALL_FLAGS_NONE, -1, NULL, fu_util_get_devices_cb, priv); g_main_loop_run (priv->loop); if (priv->val == NULL) { g_dbus_error_strip_remote_error (priv->error); g_propagate_error (error, priv->error); return FALSE; } return TRUE; }
static void dispatcher_done_cb (GObject *proxy, GAsyncResult *result, gpointer user_data) { DispatchInfo *info = user_data; GVariant *ret; GVariantIter *results; GError *error = NULL; ret = _nm_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, G_VARIANT_TYPE ("(a(sus))"), &error); if (ret) { g_variant_get (ret, "(a(sus))", &results); dispatcher_results_process (info->request_id, info->action, results); g_variant_iter_free (results); g_variant_unref (ret); } else { if (_nm_dbus_error_has_name (error, "org.freedesktop.systemd1.LoadFailed")) { g_dbus_error_strip_remote_error (error); _LOGW ("(%u) failed to call dispatcher scripts: %s", info->request_id, error->message); } else { _LOGD ("(%u) failed to call dispatcher scripts: %s", info->request_id, error->message); } g_clear_error (&error); } if (info->callback) info->callback (info->request_id, info->user_data); dispatcher_info_cleanup (info); }
static void on_realm_discover_input (GObject *source, GAsyncResult *result, gpointer user_data) { UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data); GError *error = NULL; GList *realms; realms = um_realm_manager_discover_finish (self->realm_manager, result, &error); /* Found a realm, log user into domain */ if (error == NULL) { g_assert (realms != NULL); self->selected_realm = g_object_ref (realms->data); enterprise_check_login (self); g_list_free_full (realms, g_object_unref); /* The domain is likely invalid*/ } else { finish_action (self); g_message ("Couldn't discover domain: %s", error->message); gtk_widget_grab_focus (GTK_WIDGET (self->enterprise_domain_entry)); g_dbus_error_strip_remote_error (error); set_entry_validation_error (self->enterprise_domain_entry, error->message); g_error_free (error); } g_object_unref (self); }
int main (int argc, char *argv[]) { GDBusProxy *proxy; GError *error = NULL; #if !GLIB_CHECK_VERSION (2, 35, 0) /* Initialize GType system */ g_type_init (); #endif /* Create a D-Bus proxy; NM_DBUS_* defined in nm-dbus-interface.h */ proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, NM_DBUS_SERVICE, NM_DBUS_PATH_SETTINGS, NM_DBUS_INTERFACE_SETTINGS, NULL, &error); if (!proxy) { g_dbus_error_strip_remote_error (error); g_print ("Could not create NetworkManager D-Bus proxy: %s\n", error->message); g_error_free (error); return 1; } /* Add a connection */ add_connection (proxy, "__Test connection__"); g_object_unref (proxy); return 0; }
static void on_realm_discover_input (GObject *source, GAsyncResult *result, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); GError *error = NULL; GList *realms; realms = um_realm_manager_discover_finish (priv->realm_manager, result, &error); /* Found a realm, log user into domain */ if (error == NULL) { g_assert (realms != NULL); priv->realm = g_object_ref (realms->data); enterprise_check_login (page); g_list_free_full (realms, g_object_unref); } else { /* The domain is likely invalid */ g_dbus_error_strip_remote_error (error); g_message ("Couldn't discover domain: %s", error->message); gtk_widget_grab_focus (priv->domain_entry); set_entry_validation_error (GTK_ENTRY (priv->domain_entry), error->message); apply_complete (page, FALSE); g_error_free (error); } }
void _g_propagate_error_stripped (GError **dest, GError *src) { g_propagate_error (dest, src); if (dest && *dest) g_dbus_error_strip_remote_error (*dest); }
static void dialog_sim_send_puk_ready (MMSim *sim, GAsyncResult *res, BroadbandDeviceInfo *info) { GError *error = NULL; if (!mm_sim_send_puk_finish (sim, res, &error)) { const gchar *msg; if (g_error_matches (error, MM_MOBILE_EQUIPMENT_ERROR, MM_MOBILE_EQUIPMENT_ERROR_INCORRECT_PASSWORD)) msg = _("Wrong PUK code; please contact your provider."); else { g_dbus_error_strip_remote_error (error); msg = error ? error->message : NULL; } applet_mobile_pin_dialog_stop_spinner (info->dialog, msg); g_warning ("Failed to send PUK to devid: '%s' simid: '%s' : %s", mm_modem_get_device_identifier (info->mm_modem), mm_sim_get_identifier (info->mm_sim), error->message); g_error_free (error); return; } /* Good */ unlock_dialog_destroy (info); }
void _g_simple_async_result_take_error_stripped (GSimpleAsyncResult *simple, GError *error) { g_dbus_error_strip_remote_error (error); g_simple_async_result_take_error (simple, error); }
static void default_adapter_cb (GObject *proxy, GAsyncResult *result, gpointer user_data) { NMBluez4Manager *self = NM_BLUEZ4_MANAGER (user_data); NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self); GVariant *ret; GError *err = NULL; ret = _nm_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, G_VARIANT_TYPE ("(o)"), &err); if (ret) { const char *default_adapter; g_variant_get (ret, "(&o)", &default_adapter); default_adapter_changed (priv->proxy, default_adapter, self); g_variant_unref (ret); } else { /* Ignore "No such adapter" errors; just means bluetooth isn't active */ if ( !_nm_dbus_error_has_name (err, "org.bluez.Error.NoSuchAdapter") && !_nm_dbus_error_has_name (err, "org.freedesktop.systemd1.LoadFailed") && !g_error_matches (err, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN)) { g_dbus_error_strip_remote_error (err); nm_log_warn (LOGD_BT, "bluez error getting default adapter: %s", err->message); } g_error_free (err); } }
static void inhibit_done (GObject *source, GAsyncResult *result, gpointer user_data) { GDBusProxy *sd_proxy = G_DBUS_PROXY (source); NMSleepMonitor *self = user_data; GError *error = NULL; GVariant *res; GUnixFDList *fd_list; res = g_dbus_proxy_call_with_unix_fd_list_finish (sd_proxy, &fd_list, result, &error); if (!res) { g_dbus_error_strip_remote_error (error); nm_log_warn (LOGD_SUSPEND, "Inhibit failed: %s", error->message); g_error_free (error); } else { if (!fd_list || g_unix_fd_list_get_length (fd_list) != 1) nm_log_warn (LOGD_SUSPEND, "Didn't get a single fd back"); self->inhibit_fd = g_unix_fd_list_get (fd_list, 0, NULL); nm_log_dbg (LOGD_SUSPEND, "Inhibitor fd is %d", self->inhibit_fd); g_object_unref (fd_list); g_variant_unref (res); } }
gboolean nm_supplicant_interface_credentials_reply (NMSupplicantInterface *self, const char *field, const char *value, GError **error) { NMSupplicantInterfacePrivate *priv; gs_unref_variant GVariant *reply = NULL; g_return_val_if_fail (NM_IS_SUPPLICANT_INTERFACE (self), FALSE); g_return_val_if_fail (field != NULL, FALSE); g_return_val_if_fail (value != NULL, FALSE); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); g_return_val_if_fail (priv->has_credreq == TRUE, FALSE); /* Need a network block object path */ g_return_val_if_fail (priv->net_path, FALSE); reply = g_dbus_proxy_call_sync (priv->iface_proxy, "NetworkReply", g_variant_new ("(oss)", priv->net_path, field, value), G_DBUS_CALL_FLAGS_NONE, 5000, NULL, error); if (error && *error) g_dbus_error_strip_remote_error (*error); return !!reply; }
static void finish_auth_check(GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error = NULL; GVariant *result; gboolean authorized; struct auth_check *auth_check = user_data; if (auth_check->cancel_id) g_source_remove(auth_check->cancel_id); g_free(auth_check->cancel_string); result = g_dbus_proxy_call_finish(polkit_proxy, res, &error); if (!result) { g_dbus_error_strip_remote_error(error); g_printerr("Failed to check authorization: %s\n", error->message); g_error_free(error); authorized = FALSE; } else { g_variant_get(result, "((bba{ss}))", &authorized, NULL, NULL); g_variant_unref(result); } if (authorized) { (auth_check->handler)(auth_check->invocation, auth_check->handler_data); } else { return_error(auth_check->invocation, G_DBUS_ERROR_AUTH_FAILED, "Not authorized"); } g_object_unref(auth_check->cancellable); g_free(auth_check->handler_data); g_free(auth_check); g_assert(running_auth_checks); running_auth_checks--; }
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 handle_start (CockpitStorageMDRaid *object, GDBusMethodInvocation *invocation) { StorageMDRaid *mdraid = STORAGE_MDRAID(object); GError *error = NULL; GVariantBuilder options; g_variant_builder_init (&options, G_VARIANT_TYPE("a{sv}")); g_variant_builder_add (&options, "{sv}", "start-degraded", g_variant_new_boolean (TRUE)); if (!udisks_mdraid_call_start_sync (mdraid->udisks_mdraid, 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_start (object, invocation); return TRUE; }
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 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 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 async_got_connection_cb (GDBusConnection *connection, GError *io_error, gpointer callback_data) { AsyncPathCall *data = callback_data; if (connection == NULL) { g_dbus_error_strip_remote_error (io_error); g_simple_async_result_set_from_error (data->result, io_error); _g_simple_async_result_complete_with_cancellable (data->result, data->cancellable); async_path_call_free (data); return; } data->connection = g_object_ref (connection); gvfs_dbus_mount_proxy_new (connection, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, data->mount_info->dbus_id, data->mount_info->object_path, data->cancellable, async_proxy_new_cb, data); }