From dee5f443807fee3b5b279d0488df617eeed52230 Mon Sep 17 00:00:00 2001 From: Robert Ancell Date: Thu, 6 Sep 2018 14:37:39 +1200 Subject: [PATCH] daemon: Fix warnings about type-punning --- src/daemon.c | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/src/daemon.c b/src/daemon.c index 2587b8a..00dff51 100644 --- a/src/daemon.c +++ b/src/daemon.c @@ -232,117 +232,118 @@ entry_generator_fgetpwent (Daemon *daemon, pwent = fgetpwent (generator_state->fp); if (pwent != NULL) { shadow_entry_buffers = g_hash_table_lookup (generator_state->users, pwent->pw_name); if (shadow_entry_buffers != NULL) { *spent = &shadow_entry_buffers->spbuf; } return pwent; } } /* Last iteration */ fclose (generator_state->fp); g_hash_table_unref (generator_state->users); g_free (generator_state); *state = NULL; return NULL; } static struct passwd * entry_generator_cachedir (Daemon *daemon, GHashTable *users, gpointer *state, struct spwd **shadow_entry) { struct passwd *pwent; g_autoptr(GError) error = NULL; gboolean regular; GHashTableIter iter; - const gchar *name; - User *user; + gpointer key, value; GDir *dir; /* First iteration */ if (*state == NULL) { *state = g_dir_open (USERDIR, 0, &error); if (error != NULL) { if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT)) g_warning ("couldn't list user cache directory: %s", USERDIR); return NULL; } } /* Every iteration */ /* * Use names of files of regular type to lookup information * about each user. Loop until we find something valid. */ dir = *state; while (TRUE) { const gchar *name; g_autofree gchar *filename = NULL; name = g_dir_read_name (dir); if (name == NULL) break; /* Only load files in this directory */ filename = g_build_filename (USERDIR, name, NULL); regular = g_file_test (filename, G_FILE_TEST_IS_REGULAR); if (regular) { errno = 0; pwent = getpwnam (name); if (pwent != NULL) { *shadow_entry = getspnam (pwent->pw_name); return pwent; } else if (errno == 0) { g_debug ("user '%s' in cache dir but not present on system, removing", name); remove_cache_files (name); } else { g_warning ("failed to check if user '%s' in cache dir is present on system: %s", name, g_strerror (errno)); } } } /* Last iteration */ g_dir_close (dir); /* Update all the users from the files in the cache dir */ g_hash_table_iter_init (&iter, users); - while (g_hash_table_iter_next (&iter, (gpointer *)&name, (gpointer *)&user)) { + while (g_hash_table_iter_next (&iter, &key, &value)) { + const gchar *name = key; + User *user = value; g_autofree gchar *filename = NULL; g_autoptr(GKeyFile) key_file = NULL; filename = g_build_filename (USERDIR, name, NULL); key_file = g_key_file_new (); if (g_key_file_load_from_file (key_file, filename, 0, NULL)) user_update_from_keyfile (user, key_file); } *state = NULL; return NULL; } static struct passwd * entry_generator_requested_users (Daemon *daemon, GHashTable *users, gpointer *state, struct spwd **shadow_entry) { struct passwd *pwent; GList *node; /* First iteration */ if (*state == NULL) { *state = daemon->priv->explicitly_requested_users; } /* Every iteration */ if (g_hash_table_size (users) < MAX_LOCAL_USERS) { @@ -423,129 +424,131 @@ load_entries (Daemon *daemon, } if (!explicitly_requested) { user_set_cached (user, TRUE); } } /* Generator should have cleaned up */ g_assert (generator_state == NULL); } static GHashTable * create_users_hash_table (void) { return g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); } static void reload_users (Daemon *daemon) { AccountsAccounts *accounts = ACCOUNTS_ACCOUNTS (daemon); gboolean had_no_users, has_no_users, had_multiple_users, has_multiple_users; GHashTable *users; GHashTable *old_users; GHashTable *local; GHashTableIter iter; gsize number_of_normal_users = 0; - gpointer name; - User *user; + gpointer name, value; /* Track the users that we saw during our (re)load */ users = create_users_hash_table (); /* * NOTE: As we load data from all the sources, notifies are * frozen in load_entries() and then thawed as we process * them below. */ /* Load the local users into our hash table */ load_entries (daemon, users, FALSE, entry_generator_fgetpwent); local = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_iter_init (&iter, users); while (g_hash_table_iter_next (&iter, &name, NULL)) g_hash_table_add (local, name); /* and add users to hash table that were explicitly requested */ load_entries (daemon, users, TRUE, entry_generator_requested_users); /* Now add/update users from other sources, possibly non-local */ load_entries (daemon, users, FALSE, entry_generator_cachedir); wtmp_helper_update_login_frequencies (users); /* Count the non-system users. Mark which users are local, which are not. */ g_hash_table_iter_init (&iter, users); - while (g_hash_table_iter_next (&iter, &name, (gpointer *)&user)) { + while (g_hash_table_iter_next (&iter, &name, &value)) { + User *user = value; if (!user_get_system_account (user)) number_of_normal_users++; user_update_local_account_property (user, g_hash_table_lookup (local, name) != NULL); } g_hash_table_destroy (local); had_no_users = accounts_accounts_get_has_no_users (accounts); has_no_users = number_of_normal_users == 0; if (had_no_users != has_no_users) accounts_accounts_set_has_no_users (accounts, has_no_users); had_multiple_users = accounts_accounts_get_has_multiple_users (accounts); has_multiple_users = number_of_normal_users > 1; if (had_multiple_users != has_multiple_users) accounts_accounts_set_has_multiple_users (accounts, has_multiple_users); /* Swap out the users */ old_users = daemon->priv->users; daemon->priv->users = users; /* Remove all the old users */ g_hash_table_iter_init (&iter, old_users); - while (g_hash_table_iter_next (&iter, &name, (gpointer *)&user)) { + while (g_hash_table_iter_next (&iter, &name, &value)) { + User *user = value; User *refreshed_user; refreshed_user = g_hash_table_lookup (users, name); if (!refreshed_user || (user_get_cached (user) && !user_get_cached (refreshed_user))) { accounts_accounts_emit_user_deleted (ACCOUNTS_ACCOUNTS (daemon), user_get_object_path (user)); user_unregister (user); } } /* Register all the new users */ g_hash_table_iter_init (&iter, users); - while (g_hash_table_iter_next (&iter, &name, (gpointer *)&user)) { + while (g_hash_table_iter_next (&iter, &name, &value)) { + User *user = value; User *stale_user; stale_user = g_hash_table_lookup (old_users, name); if (!stale_user || (!user_get_cached (stale_user) && user_get_cached (user))) { user_register (user); accounts_accounts_emit_user_added (ACCOUNTS_ACCOUNTS (daemon), user_get_object_path (user)); } g_object_thaw_notify (G_OBJECT (user)); } g_hash_table_destroy (old_users); } static gboolean reload_users_timeout (Daemon *daemon) { reload_users (daemon); daemon->priv->reload_id = 0; return FALSE; } static gboolean load_autologin (Daemon *daemon, gchar **name, gboolean *enabled, GError **error); static gboolean @@ -932,69 +935,70 @@ typedef struct { } ListUserData; static ListUserData * list_user_data_new (Daemon *daemon, GDBusMethodInvocation *context) { ListUserData *data; data = g_new0 (ListUserData, 1); data->daemon = g_object_ref (daemon); data->context = context; return data; } static void list_user_data_free (ListUserData *data) { g_object_unref (data->daemon); g_free (data); } static gboolean finish_list_cached_users (gpointer user_data) { ListUserData *data = user_data; g_autoptr(GPtrArray) object_paths = NULL; GHashTableIter iter; - const gchar *name; - User *user; + gpointer key, value; uid_t uid; const gchar *shell; object_paths = g_ptr_array_new (); g_hash_table_iter_init (&iter, data->daemon->priv->users); - while (g_hash_table_iter_next (&iter, (gpointer *)&name, (gpointer *)&user)) { + while (g_hash_table_iter_next (&iter, &key, &value)) { + const gchar *name = key; + User *user = value; uid = user_get_uid (user); shell = user_get_shell (user); if (!user_classify_is_human (uid, name, shell, NULL)) { g_debug ("user %s %ld excluded", name, (long) uid); continue; } if (!user_get_cached (user)) { g_debug ("user %s %ld not cached", name, (long) uid); continue; } g_debug ("user %s %ld not excluded", name, (long) uid); g_ptr_array_add (object_paths, (gpointer) user_get_object_path (user)); } g_ptr_array_add (object_paths, NULL); accounts_accounts_complete_list_cached_users (NULL, data->context, (const gchar * const *) object_paths->pdata); list_user_data_free (data); return FALSE; } static gboolean daemon_list_cached_users (AccountsAccounts *accounts, GDBusMethodInvocation *context) { Daemon *daemon = (Daemon*)accounts; -- 2.17.1