From 85f267bfa7045f41640da7feaac440327101ae74 Mon Sep 17 00:00:00 2001 From: Ondrej Holy Date: Tue, 24 Apr 2018 15:14:08 +0200 Subject: user-accounts: Port UmRealmManager to GTask https://gitlab.gnome.org/GNOME/gnome-control-center/issues/20 --- panels/user-accounts/um-account-dialog.c | 4 +- panels/user-accounts/um-realm-manager.c | 263 ++++++++++--------------------- panels/user-accounts/um-realm-manager.h | 3 +- 3 files changed, 87 insertions(+), 183 deletions(-) diff --git a/panels/user-accounts/um-account-dialog.c b/panels/user-accounts/um-account-dialog.c index d40622d68..91ac55a7a 100644 --- a/panels/user-accounts/um-account-dialog.c +++ b/panels/user-accounts/um-account-dialog.c @@ -894,7 +894,7 @@ on_join_login (GObject *source, return; } - um_realm_login_finish (result, &creds, &error); + creds = um_realm_login_finish (result, &error); /* Logged in as admin successfully, use creds to join domain */ if (error == NULL) { @@ -1000,7 +1000,7 @@ on_realm_login (GObject *source, return; } - um_realm_login_finish (result, &creds, &error); + creds = um_realm_login_finish (result, &error); /* * User login is valid, but cannot authenticate right now (eg: user needs diff --git a/panels/user-accounts/um-realm-manager.c b/panels/user-accounts/um-realm-manager.c index 26391486f..36fe48206 100644 --- a/panels/user-accounts/um-realm-manager.c +++ b/panels/user-accounts/um-realm-manager.c @@ -166,42 +166,25 @@ on_realm_diagnostics (GDBusConnection *connection, } } -typedef struct { - GCancellable *cancellable; - UmRealmManager *manager; -} NewClosure; - -static void -new_closure_free (gpointer data) -{ - NewClosure *closure = data; - g_clear_object (&closure->cancellable); - g_clear_object (&closure->manager); - g_slice_free (NewClosure, closure); -} - static void on_provider_new (GObject *source, GAsyncResult *result, gpointer user_data) { - GSimpleAsyncResult *async = G_SIMPLE_ASYNC_RESULT (user_data); - NewClosure *closure = g_simple_async_result_get_op_res_gpointer (async); + GTask *task = G_TASK (user_data); + UmRealmManager *manager = g_task_get_task_data (task); GError *error = NULL; - UmRealmProvider *provider; - - provider = um_realm_provider_proxy_new_finish (result, &error); - closure->manager->provider = provider; + manager->provider = um_realm_provider_proxy_new_finish (result, &error); if (error == NULL) { - g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (closure->manager->provider), -1); + g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (manager->provider), -1); g_debug ("Created realm manager"); + g_task_return_pointer (task, g_object_ref (manager), g_object_unref); } else { - g_simple_async_result_take_error (async, error); + g_task_return_error (task, error); } - g_simple_async_result_complete (async); - g_object_unref (async); + g_object_unref (task); } static void @@ -209,8 +192,8 @@ on_manager_new (GObject *source, GAsyncResult *result, gpointer user_data) { - GSimpleAsyncResult *async = G_SIMPLE_ASYNC_RESULT (user_data); - NewClosure *closure = g_simple_async_result_get_op_res_gpointer (async); + GTask *task = G_TASK (user_data); + UmRealmManager *manager; GDBusConnection *connection; GError *error = NULL; GObject *object; @@ -218,7 +201,7 @@ on_manager_new (GObject *source, object = g_async_initable_new_finish (G_ASYNC_INITABLE (source), result, &error); if (error == NULL) { - closure->manager = UM_REALM_MANAGER (object); + manager = UM_REALM_MANAGER (object); connection = g_dbus_object_manager_client_get_connection (G_DBUS_OBJECT_MANAGER_CLIENT (object)); g_debug ("Connected to realmd"); @@ -233,20 +216,20 @@ on_manager_new (GObject *source, on_realm_diagnostics, NULL, NULL); - closure->manager->diagnostics_sig = sig; + manager->diagnostics_sig = sig; + + g_task_set_task_data (task, manager, g_object_unref); um_realm_provider_proxy_new (connection, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "org.freedesktop.realmd", "/org/freedesktop/realmd", - closure->cancellable, - on_provider_new, g_object_ref (async)); + g_task_get_cancellable (task), + on_provider_new, task); } else { - g_simple_async_result_take_error (async, error); - g_simple_async_result_complete (async); + g_task_return_error (task, error); + g_object_unref (task); } - - g_object_unref (async); } void @@ -254,61 +237,37 @@ um_realm_manager_new (GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *async; - NewClosure *closure; + GTask *task; g_debug ("Connecting to realmd..."); - async = g_simple_async_result_new (NULL, callback, user_data, - um_realm_manager_new); - closure = g_slice_new (NewClosure); - closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL; - g_simple_async_result_set_op_res_gpointer (async, closure, new_closure_free); + task = g_task_new (NULL, cancellable, callback, user_data); + g_task_set_source_tag (task, um_realm_manager_new); g_async_initable_new_async (UM_TYPE_REALM_MANAGER, G_PRIORITY_DEFAULT, - cancellable, on_manager_new, g_object_ref (async), + cancellable, on_manager_new, task, "flags", G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, "name", "org.freedesktop.realmd", "bus-type", G_BUS_TYPE_SYSTEM, "object-path", "/org/freedesktop/realmd", "get-proxy-type-func", um_realm_object_manager_client_get_proxy_type, NULL); - - g_object_unref (async); } UmRealmManager * um_realm_manager_new_finish (GAsyncResult *result, GError **error) { - GSimpleAsyncResult *async; - NewClosure *closure; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL, - um_realm_manager_new), NULL); + g_return_val_if_fail (g_task_is_valid (result, NULL), NULL); + g_return_val_if_fail (g_async_result_is_tagged (result, um_realm_manager_new), NULL); - async = G_SIMPLE_ASYNC_RESULT (result); - if (g_simple_async_result_propagate_error (async, error)) - return NULL; - - closure = g_simple_async_result_get_op_res_gpointer (async); - return g_object_ref (closure->manager); + return g_task_propagate_pointer (G_TASK (result), error); } -typedef struct { - GDBusObjectManager *manager; - GCancellable *cancellable; - GList *realms; -} DiscoverClosure; - static void -discover_closure_free (gpointer data) +realms_free (gpointer data) { - DiscoverClosure *discover = data; - g_object_unref (discover->manager); - g_clear_object (&discover->cancellable); - g_list_free_full (discover->realms, g_object_unref); - g_slice_free (DiscoverClosure, discover); + g_list_free_full (data, g_object_unref); } static void @@ -316,26 +275,27 @@ on_provider_discover (GObject *source, GAsyncResult *result, gpointer user_data) { - GSimpleAsyncResult *async = G_SIMPLE_ASYNC_RESULT (user_data); - DiscoverClosure *discover = g_simple_async_result_get_op_res_gpointer (async); + GTask *task = G_TASK (user_data); + UmRealmManager *manager = g_task_get_source_object (task); GDBusObject *object; GError *error = NULL; gboolean no_membership = FALSE; gchar **realms; gint relevance; gint i; + GList *kerberos_realms = NULL; um_realm_provider_call_discover_finish (UM_REALM_PROVIDER (source), &relevance, &realms, result, &error); if (error == NULL) { for (i = 0; realms[i]; i++) { - object = g_dbus_object_manager_get_object (discover->manager, realms[i]); + object = g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (manager), realms[i]); if (object == NULL) { g_warning ("Realm is not in object manager: %s", realms[i]); } else { if (is_realm_with_kerberos_and_membership (object)) { g_debug ("Discovered realm: %s", realms[i]); - discover->realms = g_list_prepend (discover->realms, object); + kerberos_realms = g_list_prepend (kerberos_realms, object); } else { g_debug ("Realm does not support kerberos membership: %s", realms[i]); no_membership = TRUE; @@ -345,16 +305,21 @@ on_provider_discover (GObject *source, } g_strfreev (realms); - if (!discover->realms && no_membership) { - g_simple_async_result_set_error (async, UM_REALM_ERROR, UM_REALM_ERROR_GENERIC, - _("Cannot automatically join this type of domain")); + if (!kerberos_realms && no_membership) { + g_task_return_new_error (task, UM_REALM_ERROR, UM_REALM_ERROR_GENERIC, + _("Cannot automatically join this type of domain")); + } else if (!kerberos_realms) { + g_task_return_new_error (task, UM_REALM_ERROR, UM_REALM_ERROR_GENERIC, + _("No such domain or realm found")); + } else { + kerberos_realms = g_list_reverse (kerberos_realms); + g_task_return_pointer (task, kerberos_realms, realms_free); } } else { - g_simple_async_result_take_error (async, error); + g_task_return_error (task, error); } - g_simple_async_result_complete (async); - g_object_unref (async); + g_object_unref (task); } void @@ -364,8 +329,7 @@ um_realm_manager_discover (UmRealmManager *self, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *res; - DiscoverClosure *discover; + GTask *task; GVariant *options; g_return_if_fail (UM_IS_REALM_MANAGER (self)); @@ -374,19 +338,13 @@ um_realm_manager_discover (UmRealmManager *self, g_debug ("Discovering realms for: %s", input); - res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - um_realm_manager_discover); - discover = g_slice_new0 (DiscoverClosure); - discover->manager = g_object_ref (self); - discover->cancellable = cancellable ? g_object_ref (cancellable) : NULL; - g_simple_async_result_set_op_res_gpointer (res, discover, discover_closure_free); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); + g_task_set_source_tag (task, um_realm_manager_discover); options = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0); um_realm_provider_call_discover (self->provider, input, options, cancellable, - on_provider_discover, g_object_ref (res)); - - g_object_unref (res); + on_provider_discover, task); } GList * @@ -394,29 +352,12 @@ um_realm_manager_discover_finish (UmRealmManager *self, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *async; - DiscoverClosure *discover; - GList *realms; - g_return_val_if_fail (UM_IS_REALM_MANAGER (self), NULL); - g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self), - um_realm_manager_discover), NULL); + g_return_val_if_fail (g_task_is_valid (result, G_OBJECT (self)), NULL); + g_return_val_if_fail (g_async_result_is_tagged (result, um_realm_manager_discover), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); - async = G_SIMPLE_ASYNC_RESULT (result); - if (g_simple_async_result_propagate_error (async, error)) - return NULL; - - discover = g_simple_async_result_get_op_res_gpointer (async); - if (!discover->realms) { - g_set_error (error, UM_REALM_ERROR, UM_REALM_ERROR_GENERIC, - _("No such domain or realm found")); - return NULL; - } - - realms = g_list_reverse (discover->realms); - discover->realms = NULL; - return realms; + return g_task_propagate_pointer (G_TASK (result), error); } GList * @@ -516,20 +457,6 @@ find_supported_credentials (UmRealmKerberosMembership *membership, return NULL; } -static void -on_realm_join_complete (GObject *source, - GAsyncResult *result, - gpointer user_data) -{ - GSimpleAsyncResult *async = G_SIMPLE_ASYNC_RESULT (user_data); - - g_debug ("Completed Join() method call"); - - g_simple_async_result_set_op_res_gpointer (async, g_object_ref (result), g_object_unref); - g_simple_async_result_complete_in_idle (async); - g_object_unref (async); -} - static gboolean realm_join_as_owner (UmRealmObject *realm, const gchar *owner, @@ -541,7 +468,6 @@ realm_join_as_owner (UmRealmObject *realm, gpointer user_data) { UmRealmKerberosMembership *membership; - GSimpleAsyncResult *async; GVariant *contents; GVariant *options; GVariant *option; @@ -558,9 +484,6 @@ realm_join_as_owner (UmRealmObject *realm, return FALSE; } - async = g_simple_async_result_new (G_OBJECT (realm), callback, user_data, - realm_join_as_owner); - if (g_str_equal (type, "ccache")) { g_debug ("Using a kerberos credential cache to join the realm"); contents = g_variant_new_from_data (G_VARIANT_TYPE ("ay"), @@ -583,10 +506,7 @@ realm_join_as_owner (UmRealmObject *realm, g_debug ("Calling the Join() method with %s credentials", owner); um_realm_kerberos_membership_call_join (membership, creds, options, - cancellable, on_realm_join_complete, - g_object_ref (async)); - - g_object_unref (async); + cancellable, callback, user_data); g_object_unref (membership); return TRUE; @@ -640,7 +560,6 @@ um_realm_join_finish (UmRealmObject *realm, UmRealmKerberosMembership *membership; GError *call_error = NULL; gchar *dbus_error; - GAsyncResult *async; g_return_val_if_fail (UM_REALM_IS_OBJECT (realm), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); @@ -648,12 +567,13 @@ um_realm_join_finish (UmRealmObject *realm, membership = um_realm_object_get_kerberos_membership (realm); g_return_val_if_fail (membership != NULL, FALSE); - async = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result)); - um_realm_kerberos_membership_call_join_finish (membership, async, &call_error); + um_realm_kerberos_membership_call_join_finish (membership, result, &call_error); g_object_unref (membership); - if (call_error == NULL) + if (call_error == NULL) { + g_debug ("Completed Join() method call"); return TRUE; + } dbus_error = g_dbus_error_get_remote_error (call_error); if (dbus_error == NULL) { @@ -683,7 +603,6 @@ typedef struct { gchar *realm; gchar *user; gchar *password; - GBytes *credentials; } LoginClosure; static void @@ -694,7 +613,6 @@ login_closure_free (gpointer data) g_free (login->realm); g_free (login->user); g_free (login->password); - g_bytes_unref (login->credentials); g_slice_free (LoginClosure, login); } @@ -763,11 +681,12 @@ login_perform_kinit (krb5_context k5, } static void -kinit_thread_func (GSimpleAsyncResult *async, - GObject *object, +kinit_thread_func (GTask *task, + gpointer object, + gpointer task_data, GCancellable *cancellable) { - LoginClosure *login = g_simple_async_result_get_op_res_gpointer (async); + LoginClosure *login = task_data; krb5_context k5 = NULL; krb5_error_code code; GError *error = NULL; @@ -799,40 +718,41 @@ kinit_thread_func (GSimpleAsyncResult *async, if (filename != NULL) { g_file_get_contents (filename, &contents, &length, &error); if (error == NULL) { - login->credentials = g_bytes_new_take (contents, length); g_debug ("Read in credential cache: %s", filename); } else { g_warning ("Couldn't read credential cache: %s: %s", filename, error->message); g_error_free (error); } + + g_task_return_pointer (task, g_bytes_new_take (contents, length), (GDestroyNotify) g_bytes_unref); } break; case KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN: case KRB5KDC_ERR_POLICY: - g_simple_async_result_set_error (async, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN, - _("Cannot log in as %s at the %s domain"), - login->user, login->domain); + g_task_return_new_error (task, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN, + _("Cannot log in as %s at the %s domain"), + login->user, login->domain); break; case KRB5KDC_ERR_PREAUTH_FAILED: case KRB5KRB_AP_ERR_BAD_INTEGRITY: - g_simple_async_result_set_error (async, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD, - _("Invalid password, please try again")); + g_task_return_new_error (task, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD, + _("Invalid password, please try again")); break; case KRB5_PREAUTH_FAILED: case KRB5KDC_ERR_KEY_EXP: case KRB5KDC_ERR_CLIENT_REVOKED: case KRB5KDC_ERR_ETYPE_NOSUPP: case KRB5_PROG_ETYPE_NOSUPP: - g_simple_async_result_set_error (async, UM_REALM_ERROR, UM_REALM_ERROR_CANNOT_AUTH, - _("Cannot log in as %s at the %s domain"), - login->user, login->domain); + g_task_return_new_error (task, UM_REALM_ERROR, UM_REALM_ERROR_CANNOT_AUTH, + _("Cannot log in as %s at the %s domain"), + login->user, login->domain); break; default: - g_simple_async_result_set_error (async, UM_REALM_ERROR, UM_REALM_ERROR_GENERIC, - _("Couldn’t connect to the %s domain: %s"), - login->domain, krb5_get_error_message (k5, code)); + g_task_return_new_error (task, UM_REALM_ERROR, UM_REALM_ERROR_GENERIC, + _("Couldn’t connect to the %s domain: %s"), + login->domain, krb5_get_error_message (k5, code)); break; } @@ -844,6 +764,8 @@ kinit_thread_func (GSimpleAsyncResult *async, if (k5) krb5_free_context (k5); + + g_object_unref (task); } void @@ -854,7 +776,7 @@ um_realm_login (UmRealmObject *realm, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *async; + GTask *task; LoginClosure *login; UmRealmKerberos *kerberos; @@ -866,46 +788,29 @@ um_realm_login (UmRealmObject *realm, kerberos = um_realm_object_get_kerberos (realm); g_return_if_fail (kerberos != NULL); - async = g_simple_async_result_new (NULL, callback, user_data, - um_realm_login); + task = g_task_new (NULL, cancellable, callback, user_data); + g_task_set_source_tag (task, um_realm_login); + login = g_slice_new0 (LoginClosure); login->domain = g_strdup (um_realm_kerberos_get_domain_name (kerberos)); login->realm = g_strdup (um_realm_kerberos_get_realm_name (kerberos)); login->user = g_strdup (user); login->password = g_strdup (password); - g_simple_async_result_set_op_res_gpointer (async, login, login_closure_free); + g_task_set_task_data (task, login, login_closure_free); - g_simple_async_result_set_handle_cancellation (async, TRUE); - g_simple_async_result_run_in_thread (async, kinit_thread_func, - G_PRIORITY_DEFAULT, cancellable); + g_task_set_return_on_cancel (task, TRUE); + g_task_run_in_thread (task, kinit_thread_func); - g_object_unref (async); g_object_unref (kerberos); } -gboolean +GBytes * um_realm_login_finish (GAsyncResult *result, - GBytes **credentials, GError **error) { - GSimpleAsyncResult *async; - LoginClosure *login; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL, - um_realm_login), FALSE); + g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE); + g_return_val_if_fail (g_async_result_is_tagged (result, um_realm_login), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); - async = G_SIMPLE_ASYNC_RESULT (result); - if (g_simple_async_result_propagate_error (async, error)) - return FALSE; - - login = g_simple_async_result_get_op_res_gpointer (async); - if (credentials) { - if (login->credentials) - *credentials = g_bytes_ref (login->credentials); - else - *credentials = NULL; - } - - return TRUE; + return g_task_propagate_pointer (G_TASK (result), error); } diff --git a/panels/user-accounts/um-realm-manager.h b/panels/user-accounts/um-realm-manager.h index 2bf61e6cb..34d67a635 100644 --- a/panels/user-accounts/um-realm-manager.h +++ b/panels/user-accounts/um-realm-manager.h @@ -70,8 +70,7 @@ void um_realm_login (UmRealmObject *realm, GAsyncReadyCallback callback, gpointer user_data); -gboolean um_realm_login_finish (GAsyncResult *result, - GBytes **credentials, +GBytes * um_realm_login_finish (GAsyncResult *result, GError **error); gboolean um_realm_join_as_user (UmRealmObject *realm, -- cgit v1.2.1