src/shared-data-manager.c

   1 /*
   2  * Copyright (C) 2014 Canonical, Ltd
   3  * Author: Michael Terry <michael.terry@canonical.com>
   4  *
   5  * This program is free software: you can redistribute it and/or modify it under
   6  * the terms of the GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option) any later
   8  * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
   9  * license.
  10  */
  11
  12 #include <config.h>
  13 #include <gio/gio.h>
  14 #include <pwd.h>
  15 #include <sys/types.h>
  16 #include <unistd.h>
  17
  18 #include "configuration.h"
  19 #include "shared-data-manager.h"
  20 #include "user-list.h"
  21
  22 #define NUM_ENUMERATION_FILES 100
  23
  24 struct SharedDataManagerPrivate
  25 {
  26     gchar *greeter_user;
  27     guint32 greeter_gid;
  28     GHashTable *starting_dirs;
  29 };
  30
  31 struct OwnerInfo
  32 {
  33     SharedDataManager *manager;
  34     guint32 uid;
  35 };
  36
  37 G_DEFINE_TYPE (SharedDataManager, shared_data_manager, G_TYPE_OBJECT);
  38
  39 static SharedDataManager *singleton = NULL;
  40
  41 SharedDataManager *
  42 shared_data_manager_get_instance (void)
  43 {
  44     if (!singleton)
  45         singleton = g_object_new (SHARED_DATA_MANAGER_TYPE, NULL);
  46     return singleton;
  47 }
  48
  49 void
  50 shared_data_manager_cleanup (void)
  51 {
  52     if (singleton)
  53     {
  54         g_object_unref (singleton);
  55         singleton = NULL;
  56     }
  57 }
  58
  59 static void
  60 delete_unused_user (gpointer key, gpointer value, gpointer user_data)
  61 {
  62     const gchar *user = (const gchar *)key;
  63     GError *error = NULL;
  64
  65     /* Listen, the rest of this file is nice async glib code and all, but
  66        for this operation, we just need a fire and forget rm -rf.  Since
  67        recursively deleting in GIO is a huge pain in the butt, we'll just drop
  68        to shell for this. */
  69
  70     gchar *path = g_build_filename (USERS_DIR, user, NULL);
  71     gchar *quoted_path = g_shell_quote (path);
  72     gchar *cmd = g_strdup_printf ("/bin/rm -rf %s", quoted_path);
  73
  74     if (!g_spawn_command_line_async (cmd, &error))
  75     {
  76         g_warning ("Could not delete unused user data directory %s: %s", path, error->message);
  77         g_error_free (error);
  78     }
  79
  80     g_free (cmd);
  81     g_free (quoted_path);
  82     g_free (path);
  83 }
  84
  85 static void
  86 chown_user_dir_cb (GObject *object, GAsyncResult *res, gpointer user_data)
  87 {
  88     GFile *file = G_FILE (object);
  89     GFileInfo *info = NULL;
  90     GError *error = NULL;
  91
  92     if (!g_file_set_attributes_finish (file, res, &info, &error))
  93     {
  94         gchar *path = g_file_get_path (file);
  95         g_warning ("Could not chown user data directory %s: %s",
  96                    path, error->message);
  97         g_free (path);
  98         g_error_free (error);
  99     }
 100
 101     if (info)
 102         g_object_unref (info);
 103 }
 104
 105 static void
 106 make_user_dir_cb (GObject *object, GAsyncResult *res, gpointer user_data)
 107 {
 108     GFile *file = G_FILE (object);
 109     struct OwnerInfo *owner = (struct OwnerInfo *)user_data;
 110     GError *error = NULL;
 111
 112     if (!g_file_make_directory_finish (file, res, &error))
 113     {
 114         if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS))
 115         {
 116             gchar *path = g_file_get_path (file);
 117             g_warning ("Could not create user data directory %s: %s",
 118                        path, error->message);
 119             g_free (path);
 120             g_error_free (error);
 121             g_object_unref (owner->manager);
 122             g_free (owner);
 123             return;
 124         }
 125         g_error_free (error);
 126     }
 127
 128     /* Even if the directory already exists, we want to re-affirm the owners
 129        because the greeter gid is configuration based and may change between
 130        runs. */
 131     GFileInfo *info = g_file_info_new ();
 132     g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID,
 133                                       owner->uid);
 134     g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_GID,
 135                                       owner->manager->priv->greeter_gid);
 136     g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE, 0770);
 137     g_file_set_attributes_async (file, info, G_FILE_QUERY_INFO_NONE,
 138                                  G_PRIORITY_DEFAULT, NULL,
 139                                  chown_user_dir_cb, NULL);
 140
 141     g_object_unref (owner->manager);
 142     g_free (owner);
 143 }
 144
 145 void
 146 shared_data_manager_ensure_user_dir (SharedDataManager *manager, const gchar *user)
 147 {
 148     struct passwd *entry = getpwnam (user);
 149     if (!entry)
 150         return;
 151
 152     struct OwnerInfo *owner = g_malloc (sizeof (struct OwnerInfo));
 153     owner->manager = g_object_ref (manager);
 154     owner->uid = entry->pw_uid;
 155
 156     gchar *path = g_build_filename (USERS_DIR, user, NULL);
 157     GFile *file = g_file_new_for_path (path);
 158     g_free (path);
 159
 160     g_file_make_directory_async (file, G_PRIORITY_DEFAULT, NULL,
 161                                  make_user_dir_cb, owner);
 162
 163     g_object_unref (file);
 164 }
 165
 166 static void
 167 next_user_dirs_cb (GObject *object, GAsyncResult *res, gpointer user_data)
 168 {
 169     GFileEnumerator *enumerator = G_FILE_ENUMERATOR (object);
 170     SharedDataManager *manager = SHARED_DATA_MANAGER (user_data);
 171     GList *link;
 172     GError *error = NULL;
 173
 174     GList *files = g_file_enumerator_next_files_finish (enumerator, res,
 175                                                         &error);
 176     if (error != NULL)
 177     {
 178         g_warning ("Could not enumerate user data directory %s: %s",
 179                    USERS_DIR, error->message);
 180         g_error_free (error);
 181         g_object_unref (manager);
 182         return;
 183     }
 184
 185     for (link = files; link; link = link->next)
 186     {
 187         GFileInfo *info = link->data;
 188         g_hash_table_insert (manager->priv->starting_dirs,
 189                              g_strdup (g_file_info_get_name (info)), NULL);
 190     }
 191
 192     if (files != NULL)
 193     {
 194         g_list_free_full (files, g_object_unref);
 195         g_file_enumerator_next_files_async (enumerator, NUM_ENUMERATION_FILES,
 196                                             G_PRIORITY_DEFAULT, NULL,
 197                                             next_user_dirs_cb, manager);
 198     }
 199     else
 200     {
 201         // We've finally assembled all the initial directories.  Now let's
 202         // iterate the current users and as we go, remove the users from the
 203         // starting_dirs hash and thus see which users are obsolete.
 204         GList *users = common_user_list_get_users (common_user_list_get_instance ());
 205         for (link = users; link; link = link->next)
 206         {
 207             CommonUser *user = link->data;
 208             g_hash_table_remove (manager->priv->starting_dirs, common_user_get_name (user));
 209         }
 210         g_hash_table_foreach (manager->priv->starting_dirs, delete_unused_user, manager);
 211         g_hash_table_destroy (manager->priv->starting_dirs);
 212         manager->priv->starting_dirs = NULL;
 213
 214         // Also set up our own greeter dir, so it has a place to dump its own files
 215         // (imagine it holding some large files temporarily before shunting them
 216         // to the next user to log in's specific directory).
 217         shared_data_manager_ensure_user_dir (manager, manager->priv->greeter_user);
 218
 219         g_object_unref (manager);
 220     }
 221 }
 222
 223 static void
 224 list_user_dirs_cb (GObject *object, GAsyncResult *res, gpointer user_data)
 225 {
 226     GFile *file = G_FILE (object);
 227     SharedDataManager *manager = SHARED_DATA_MANAGER (user_data);
 228     GFileEnumerator *enumerator;
 229     GError *error = NULL;
 230
 231     enumerator = g_file_enumerate_children_finish (file, res, &error);
 232     if (enumerator == NULL)
 233     {
 234         g_warning ("Could not enumerate user data directory %s: %s",
 235                    USERS_DIR, error->message);
 236         g_error_free (error);
 237         g_object_unref (manager);
 238         return;
 239     }
 240
 241     manager->priv->starting_dirs = g_hash_table_new_full (g_str_hash,
 242                                                           g_str_equal,
 243                                                           g_free, NULL);
 244     g_file_enumerator_next_files_async (enumerator, NUM_ENUMERATION_FILES,
 245                                         G_PRIORITY_DEFAULT, NULL,
 246                                         next_user_dirs_cb, manager);
 247 }
 248
 249 static void
 250 user_removed_cb (CommonUserList *list, CommonUser *user,
 251                  SharedDataManager *manager)
 252 {
 253     delete_unused_user (common_user_get_name (user), NULL, manager);
 254 }
 255
 256 void
 257 shared_data_manager_start (SharedDataManager *manager)
 258 {
 259     /* Grab list of all current directories, so we know if any exist that we
 260        no longer need. */
 261     GFile *file = g_file_new_for_path (USERS_DIR);
 262     g_file_enumerate_children_async (file, G_FILE_ATTRIBUTE_STANDARD_NAME,
 263                                      G_FILE_QUERY_INFO_NONE,
 264                                      G_PRIORITY_DEFAULT, NULL,
 265                                      list_user_dirs_cb, g_object_ref (manager));
 266     g_object_unref (file);
 267
 268     /* And listen for user removals. */
 269     g_signal_connect (common_user_list_get_instance (), "user-removed",
 270                       G_CALLBACK (user_removed_cb), manager);
 271 }
 272
 273 static void
 274 shared_data_manager_init (SharedDataManager *manager)
 275 {
 276     manager->priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, SHARED_DATA_MANAGER_TYPE, SharedDataManagerPrivate);
 277
 278     // Grab current greeter-user gid
 279     struct passwd *greeter_entry;
 280     manager->priv->greeter_user = config_get_string (config_get_instance (), "LightDM", "greeter-user");
 281     greeter_entry = getpwnam (manager->priv->greeter_user);
 282     if (greeter_entry)
 283         manager->priv->greeter_gid = greeter_entry->pw_gid;
 284 }
 285
 286 static void
 287 shared_data_manager_dispose (GObject *object)
 288 {
 289     SharedDataManager *self = SHARED_DATA_MANAGER (object);
 290
 291     /* Should also cancel outstanding GIO operations, but whatever, let them
 292        do their thing. */
 293
 294     g_signal_handlers_disconnect_by_data (common_user_list_get_instance (),
 295                                           self);
 296
 297     G_OBJECT_CLASS (shared_data_manager_parent_class)->dispose (object);
 298 }
 299
 300 static void
 301 shared_data_manager_finalize (GObject *object)
 302 {
 303     SharedDataManager *self = SHARED_DATA_MANAGER (object);
 304
 305     if (self->priv->starting_dirs)
 306         g_hash_table_destroy (self->priv->starting_dirs);
 307
 308     g_free (self->priv->greeter_user);
 309
 310     G_OBJECT_CLASS (shared_data_manager_parent_class)->finalize (object);
 311 }
 312
 313 static void
 314 shared_data_manager_class_init (SharedDataManagerClass *klass)
 315 {
 316     GObjectClass *object_class = G_OBJECT_CLASS (klass);
 317
 318     object_class->dispose = shared_data_manager_dispose;
 319     object_class->finalize = shared_data_manager_finalize;
 320
 321     g_type_class_add_private (klass, sizeof (SharedDataManagerPrivate));
 322 }