From 1e2385077256bd5156d4269becc3a9e0a2d29c58 Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Tue, 3 Oct 2017 13:48:52 -0400

Subject: [PATCH 11/13] lib: simplify code dramatically

ActUser is a wrapper over the accountsservice daemon's

managed user objects.  There's a nearly 1-to-1 correspondence

between properties on the proxy to the daemon and properties

on the ActUser object.

This commit dramatically reduces the code, by leveraging the

proxies properties directly, rather than duplicating the values

on the ActUser object.

At the same time, it drops manual GetAll() calls for synchronizing

the proxies properties, since it's completely redundant with the

work the proxy is doing under the hood anyway.

---

 src/libaccountsservice/act-user.c | 676 ++++++++------------------------------

 1 file changed, 143 insertions(+), 533 deletions(-)

diff --git a/src/libaccountsservice/act-user.c b/src/libaccountsservice/act-user.c

index 17acacb..94884a1 100644

--- a/src/libaccountsservice/act-user.c

+++ b/src/libaccountsservice/act-user.c

@@ -81,94 +81,66 @@ enum {

         PROP_PASSWORD_HINT,

         PROP_HOME_DIR,

         PROP_SHELL,

         PROP_EMAIL,

         PROP_LOCATION,

         PROP_LOCKED,

         PROP_AUTOMATIC_LOGIN,

         PROP_SYSTEM_ACCOUNT,

         PROP_NONEXISTENT,

         PROP_LOCAL_ACCOUNT,

         PROP_LOGIN_FREQUENCY,

         PROP_LOGIN_TIME,

         PROP_LOGIN_HISTORY,

         PROP_ICON_FILE,

         PROP_LANGUAGE,

         PROP_X_SESSION,

         PROP_IS_LOADED

 };

 enum {

         CHANGED,

         SESSIONS_CHANGED,

         LAST_SIGNAL

 };

 struct _ActUser {

         GObject         parent;

         GDBusConnection *connection;

         AccountsUser    *accounts_proxy;

-        GDBusProxy      *object_proxy;

-        GCancellable    *get_all_cancellable;

-        char            *object_path;

-

-        uid_t           uid;

-        char           *user_name;

-        char           *real_name;

-        char           *password_hint;

-        char           *home_dir;

-        char           *shell;

-        char           *email;

-        char           *location;

-        char           *icon_file;

-        char           *language;

-        char           *x_session;

+

         GList          *our_sessions;

         GList          *other_sessions;

-        int             login_frequency;

-        gint64          login_time;

-        GVariant       *login_history;

-

-        ActUserAccountType  account_type;

-        ActUserPasswordMode password_mode;

-

-        guint           uid_set : 1;

         guint           is_loaded : 1;

-        guint           locked : 1;

-        guint           automatic_login : 1;

-        guint           system_account : 1;

-        guint           local_account : 1;

         guint           nonexistent : 1;

-

-        guint           update_info_timeout_id;

 };

 struct _ActUserClass

 {

         GObjectClass parent_class;

 };

 static void act_user_finalize     (GObject      *object);

 static guint signals[LAST_SIGNAL] = { 0 };

 G_DEFINE_TYPE (ActUser, act_user, G_TYPE_OBJECT)

 static int

 session_compare (const char *a,

                  const char *b)

 {

         if (a == NULL) {

                 return 1;

         } else if (b == NULL) {

                 return -1;

         }

         return strcmp (a, b);

 }

 void

 _act_user_add_session (ActUser    *user,

                        const char *ssid,

                        gboolean    is_ours)

@@ -238,128 +210,75 @@ act_user_get_num_sessions (ActUser    *user)

 /**

  * act_user_get_num_sessions_anywhere:

  * @user: a user

  *

  * Get the number of sessions for a user on any seat of any type.

  * See also act_user_get_num_sessions().

  *

  * (Currently, this function is only implemented for systemd-logind.

  * For ConsoleKit, it is equivalent to act_user_get_num_sessions.)

  *

  * Returns: the number of sessions

  */

 guint

 act_user_get_num_sessions_anywhere (ActUser    *user)

 {

         return (g_list_length (user->our_sessions)

                 + g_list_length (user->other_sessions));

 }

 static void

 act_user_get_property (GObject    *object,

                        guint       param_id,

                        GValue     *value,

                        GParamSpec *pspec)

 {

         ActUser *user;

         user = ACT_USER (object);

         switch (param_id) {

-        case PROP_UID:

-                g_value_set_int (value, user->uid);

-                break;

-        case PROP_USER_NAME:

-                g_value_set_string (value, user->user_name);

-                break;

-        case PROP_REAL_NAME:

-                g_value_set_string (value, user->real_name);

-                break;

-        case PROP_ACCOUNT_TYPE:

-                g_value_set_int (value, user->account_type);

-                break;

-        case PROP_PASSWORD_MODE:

-                g_value_set_int (value, user->password_mode);

-                break;

-        case PROP_PASSWORD_HINT:

-                g_value_set_string (value, user->password_hint);

-                break;

-        case PROP_HOME_DIR:

-                g_value_set_string (value, user->home_dir);

-                break;

-        case PROP_LOGIN_FREQUENCY:

-                g_value_set_int (value, user->login_frequency);

-                break;

-        case PROP_LOGIN_TIME:

-                g_value_set_int64 (value, user->login_time);

-                break;

-        case PROP_LOGIN_HISTORY:

-                g_value_set_variant (value, user->login_history);

-                break;

-        case PROP_SHELL:

-                g_value_set_string (value, user->shell);

-                break;

-        case PROP_EMAIL:

-                g_value_set_string (value, user->email);

-                break;

-        case PROP_LOCATION:

-                g_value_set_string (value, user->location);

-                break;

-        case PROP_ICON_FILE:

-                g_value_set_string (value, user->icon_file);

-                break;

-        case PROP_LANGUAGE:

-                g_value_set_string (value, user->language);

-                break;

-        case PROP_X_SESSION:

-                g_value_set_string (value, user->x_session);

-                break;

-        case PROP_LOCKED:

-                g_value_set_boolean (value, user->locked);

-                break;

-        case PROP_AUTOMATIC_LOGIN:

-                g_value_set_boolean (value, user->automatic_login);

-                break;

-        case PROP_SYSTEM_ACCOUNT:

-                g_value_set_boolean (value, user->system_account);

-                break;

-        case PROP_LOCAL_ACCOUNT:

-                g_value_set_boolean (value, user->local_account);

-                break;

         case PROP_NONEXISTENT:

                 g_value_set_boolean (value, user->nonexistent);

                 break;

         case PROP_IS_LOADED:

                 g_value_set_boolean (value, user->is_loaded);

                 break;

         default:

-                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);

+                if (user->accounts_proxy != NULL) {

+                        const char *property_name;

+

+                        property_name = g_param_spec_get_name (pspec);

+

+                        g_object_get_property (G_OBJECT (user->accounts_proxy), property_name, value);

+

+                }

                 break;

         }

 }

 static void

 act_user_class_init (ActUserClass *class)

 {

         GObjectClass *gobject_class;

         gobject_class = G_OBJECT_CLASS (class);

         gobject_class->finalize = act_user_finalize;

         gobject_class->get_property = act_user_get_property;

         g_object_class_install_property (gobject_class,

                                          PROP_REAL_NAME,

                                          g_param_spec_string ("real-name",

                                                               "Real Name",

                                                               "The real name to display for this user.",

                                                               NULL,

                                                               G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

         g_object_class_install_property (gobject_class,

                                          PROP_ACCOUNT_TYPE,

                                          g_param_spec_int ("account-type",

                                                            "Account Type",

                                                            "The account type for this user.",

                                                            ACT_USER_ACCOUNT_TYPE_STANDARD,

                                                            ACT_USER_ACCOUNT_TYPE_ADMINISTRATOR,

@@ -525,1082 +444,773 @@ act_user_class_init (ActUserClass *class)

          * Emitted when the user accounts changes in some way.

          */

         signals [CHANGED] =

                 g_signal_new ("changed",

                               G_TYPE_FROM_CLASS (class),

                               G_SIGNAL_RUN_LAST,

                               0,

                               NULL, NULL,

                               g_cclosure_marshal_VOID__VOID,

                               G_TYPE_NONE, 0);

         /**

          * ActUser::sessions-changed:

          *

          * Emitted when the list of sessions for this user changes.

          */

         signals [SESSIONS_CHANGED] =

                 g_signal_new ("sessions-changed",

                               G_TYPE_FROM_CLASS (class),

                               G_SIGNAL_RUN_LAST,

                               0,

                               NULL, NULL,

                               g_cclosure_marshal_VOID__VOID,

                               G_TYPE_NONE, 0);

 }

 static void

 act_user_init (ActUser *user)

 {

         GError *error = NULL;

-        user->local_account = TRUE;

-        user->user_name = NULL;

-        user->real_name = NULL;

         user->our_sessions = NULL;

         user->other_sessions = NULL;

-        user->login_history = NULL;

         user->connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);

         if (user->connection == NULL) {

                 g_warning ("Couldn't connect to system bus: %s", error->message);

                 g_error_free (error);

         }

 }

 static void

 act_user_finalize (GObject *object)

 {

         ActUser *user;

         user = ACT_USER (object);

-        g_free (user->user_name);

-        g_free (user->real_name);

-        g_free (user->icon_file);

-        g_free (user->language);

-        g_free (user->object_path);

-        g_free (user->password_hint);

-        g_free (user->home_dir);

-        g_free (user->shell);

-        g_free (user->email);

-        g_free (user->location);

-        if (user->login_history)

-          g_variant_unref (user->login_history);

-

         if (user->accounts_proxy != NULL) {

                 g_object_unref (user->accounts_proxy);

         }

-        if (user->object_proxy != NULL) {

-                g_object_unref (user->object_proxy);

-        }

-

-        if (user->get_all_cancellable != NULL) {

-                g_object_unref (user->get_all_cancellable);

-        }

-

         if (user->connection != NULL) {

                 g_object_unref (user->connection);

         }

-        if (user->update_info_timeout_id != 0) {

-                g_source_remove (user->update_info_timeout_id);

-        }

-

         if (G_OBJECT_CLASS (act_user_parent_class)->finalize)

                 (*G_OBJECT_CLASS (act_user_parent_class)->finalize) (object);

 }

 static void

 set_is_loaded (ActUser  *user,

                gboolean  is_loaded)

 {

         if (user->is_loaded != is_loaded) {

                 user->is_loaded = is_loaded;

                 g_object_notify (G_OBJECT (user), "is-loaded");

         }

 }

 /**

  * act_user_get_uid:

  * @user: the user object to examine.

  *

  * Retrieves the ID of @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 uid_t

 act_user_get_uid (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), -1);

-        return user->uid;

+        if (user->accounts_proxy == NULL)

+                return -1;

+

+        return accounts_user_get_uid (user->accounts_proxy);

 }

 /**

  * act_user_get_real_name:

  * @user: the user object to examine.

  *

  * Retrieves the display name of @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 const char *

 act_user_get_real_name (ActUser *user)

 {

+        const char *real_name = NULL;

+

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        if (user->real_name == NULL ||

-            user->real_name[0] == '\0') {

-                return user->user_name;

+        real_name = accounts_user_get_real_name (user->accounts_proxy);

+

+        if (real_name == NULL || real_name[0] == '\0') {

+                real_name = accounts_user_get_user_name (user->accounts_proxy);

         }

-        return user->real_name;

+        return real_name;

 }

 /**

  * act_user_get_account_type:

  * @user: the user object to examine.

  *

  * Retrieves the account type of @user.

  *

  * Returns: a #ActUserAccountType

  **/

 ActUserAccountType

 act_user_get_account_type (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), ACT_USER_ACCOUNT_TYPE_STANDARD);

-        return user->account_type;

+        if (user->accounts_proxy == NULL)

+                return ACT_USER_ACCOUNT_TYPE_STANDARD;

+

+        return accounts_user_get_account_type (user->accounts_proxy);

 }

 /**

  * act_user_get_password_mode:

  * @user: the user object to examine.

  *

  * Retrieves the password mode of @user.

  *

  * Returns: a #ActUserPasswordMode

  **/

 ActUserPasswordMode

 act_user_get_password_mode (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), ACT_USER_PASSWORD_MODE_REGULAR);

-        return user->password_mode;

+        if (user->accounts_proxy == NULL)

+                return ACT_USER_PASSWORD_MODE_REGULAR;

+

+        return accounts_user_get_password_mode (user->accounts_proxy);

 }

 /**

  * act_user_get_password_hint:

  * @user: the user object to examine.

  *

  * Retrieves the password hint set by @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 const char *

 act_user_get_password_hint (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        return user->password_hint;

+        if (user->accounts_proxy == NULL)

+                return NULL;

+

+        return accounts_user_get_password_hint (user->accounts_proxy);

 }

 /**

  * act_user_get_home_dir:

  * @user: the user object to examine.

  *

  * Retrieves the home directory for @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 const char *

 act_user_get_home_dir (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        return user->home_dir;

+        if (user->accounts_proxy == NULL)

+                return NULL;

+

+        return accounts_user_get_home_directory (user->accounts_proxy);

 }

 /**

  * act_user_get_shell:

  * @user: the user object to examine.

  *

  * Retrieves the shell assigned to @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 const char *

 act_user_get_shell (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        return user->shell;

+        if (user->accounts_proxy == NULL)

+                return NULL;

+

+        return accounts_user_get_shell (user->accounts_proxy);

 }

 /**

  * act_user_get_email:

  * @user: the user object to examine.

  *

  * Retrieves the email address set by @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 const char *

 act_user_get_email (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        return user->email;

+        if (user->accounts_proxy == NULL)

+                return NULL;

+

+        return accounts_user_get_email (user->accounts_proxy);

 }

 /**

  * act_user_get_location:

  * @user: the user object to examine.

  *

  * Retrieves the location set by @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 const char *

 act_user_get_location (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        return user->location;

+        if (user->accounts_proxy == NULL)

+                return NULL;

+

+        return accounts_user_get_location (user->accounts_proxy);

 }

 /**

  * act_user_get_user_name:

  * @user: the user object to examine.

  *

  * Retrieves the login name of @user.

  *

  * Returns: (transfer none): a pointer to an array of characters which must not be modified or

  *  freed, or %NULL.

  **/

 const char *

 act_user_get_user_name (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        return user->user_name;

+        if (user->accounts_proxy == NULL)

+                return NULL;

+

+        return accounts_user_get_user_name (user->accounts_proxy);

 }

 /**

  * act_user_get_login_frequency:

  * @user: a #ActUser

  *

  * Returns the number of times @user has logged in.

  *

  * Returns: the login frequency

  */

 int

 act_user_get_login_frequency (ActUser *user)

 {

         g_return_val_if_fail (ACT_IS_USER (user), 0);

-        return user->login_frequency;

+        if (user->accounts_proxy == NULL)

+                return 0;

+

+        return accounts_user_get_login_frequency (user->accounts_proxy);

 }

 /**

  * act_user_get_login_time:

  * @user: a #ActUser

  *

  * Returns the last login time for @user.

  *

  * Returns: (transfer none): the login time

  */

 gint64

-act_user_get_login_time (ActUser *user) {

+act_user_get_login_time (ActUser *user)

+{

         g_return_val_if_fail (ACT_IS_USER (user), 0);

-        return user->login_time;

+        if (user->accounts_proxy == NULL)

+                return 0;

+

+        return accounts_user_get_login_time (user->accounts_proxy);

 }

 /**

  * act_user_get_login_history:

  * @user: a #ActUser

  *

  * Returns the login history for @user.

  *

  * Returns: (transfer none): a pointer to GVariant of type "a(xxa{sv})"

  * which must not be modified or freed, or %NULL.

  */

 const GVariant *

-act_user_get_login_history (ActUser *user) {

+act_user_get_login_history (ActUser *user)

+{

         g_return_val_if_fail (ACT_IS_USER (user), NULL);

-        return user->login_history;

+        if (user->accounts_proxy == NULL)

+                return NULL;

+

+        return accounts_user_get_login_history (user->accounts_proxy);

 }

 /**

  * act_user_collate:

  * @user1: a user

  * @user2: a user

  *

  * Organize the user by login frequency and names.

  *

  * Returns: negative if @user1 is before @user2, zero if equal

  *    or positive if @user1 is after @user2

  */

 int

 act_user_collate (ActUser *user1,

                   ActUser *user2)

 {

         const char *str1;

         const char *str2;

         int         num1;

         int         num2;

         guint       len1;

         guint       len2;

         g_return_val_if_fail (ACT_IS_USER (user1), 0);

         g_return_val_if_fail (ACT_IS_USER (user2), 0);

-        num1 = user1->login_frequency;

-        num2 = user2->login_frequency;

+        num1 = act_user_get_login_frequency (user1);

+        num2 = act_user_get_login_frequency (user2);

         if (num1 > num2) {

                 return -1;

         }

         if (num1 < num2) {

                 return 1;

         }

         len1 = g_list_length (user1->our_sessions);

         len2 = g_list_length (user2->our_sessions);

         if (len1 > len2) {

                 return -1;

         }

         if (len1 < len2) {

                 return 1;

         }

         /* if login frequency is equal try names */

-        if (user1->real_name != NULL) {

-                str1 = user1->real_name;

-        } else {

-                str1 = user1->user_name;

-        }

-

-        if (user2->real_name != NULL) {

-                str2 = user2->real_name;

-        } else {

-                str2 = user2->user_name;

-        }

+        str1 = act_user_get_real_name (user1);

+        str2 = act_user_get_real_name (user2);

         if (str1 == NULL && str2 != NULL) {

                 return -1;

         }

         if (str1 != NULL && str2 == NULL) {

                 return 1;

         }

         if (str1 == NULL && str2 == NULL) {

                 return 0;

         }

         return g_utf8_collate (str1, str2);

 }

 /**

  * act_user_is_logged_in: