flimflam: revise multi-profile support to pin objects to a profile

src/profile.c

 /*
  *
  *  Connection Manager
  *
  *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.
  *
@@ skipping 21 matching lines @@
 
 #include "connman.h"
 
 #define PROFILE_DEFAULT_IDENT  "default"
 #define PROFILE_MAX             3               /* 2 is probably sufficient */
 
 #define _DBG_PROFILE(fmt, arg...)       DBG(DBG_PROFILE, fmt, ## arg)
 
 struct connman_profile {
         struct connman_storage_ident ident;
+        guint changed_timeout;
         char *path;
         char *name;
         connman_bool_t offlinemode;
 };
 
 static GHashTable *profile_hash = NULL;
 
 static struct connman_profile *profile_stack[PROFILE_MAX];
 static int cur_profile = -1;
 
 static struct connman_storage_ident default_ident = {
         .ident = PROFILE_DEFAULT_IDENT
 };
 static struct connman_profile *default_profile = NULL;
 
 static DBusConnection *connection = NULL;
 
+/*
+ * Loading/Saving objects.
+ *
+ * Service objects go to the profile they are pinned too (typically

[Paul Stewart, 2011/03/30 00:56:18]

s/too/to/

+ * the active profile at the time they were created but this can be
+ * changed, e.g. from private -> global).
+ *
+ * Device and ipconfig objects go in the global profile (if any).
+ * This ensures that enable/disable state is maintained between
+ * users (and reboots); or possibly discarded (e.g. for testing).
+ *
+ * Likewise global state like offline mode is stored in the global
+ * profile (see above).
+ */
+
+/*
+ * Return the active profile; it's on the top of the stack.
+ */
+static inline struct connman_profile *active_profile(void)
+{
+        return cur_profile >= 0 ? profile_stack[cur_profile] : NULL;
+}
+
+/*
+ * Return the global profile; it's top-most non-user profile.
+ */
+static struct connman_profile *global_profile(void)
+{
+        /* TODO(sleffler) cheat for now */
+        return default_profile != NULL ? default_profile : NULL;
+}
+
 static int ident_equal(const struct connman_storage_ident *a,
                        const struct connman_storage_ident *b)
 {
         return (g_strcmp0(a->user, b->user) == 0 &&
                 g_strcmp0(a->ident, b->ident) == 0);
 }
 
 static void append_path(gpointer key, gpointer value, gpointer user_data)
 {
         struct connman_profile *profile = value;
@@ skipping 10 matching lines @@
 
 static void profiles_changed(void)
 {
         connman_dbus_send_property_changed_array(CONNMAN_MANAGER_PATH,
             CONNMAN_MANAGER_INTERFACE, "Profiles",
             DBUS_TYPE_OBJECT_PATH, __connman_profile_list, NULL);
 }
 
 connman_bool_t __connman_profile_get_offlinemode(void)
 {
-        return (default_profile == NULL) ? FALSE : default_profile->offlinemode;
+        struct connman_profile *profile = global_profile();
+        return (profile == NULL) ? FALSE : profile->offlinemode;
 }
 
 int __connman_profile_set_offlinemode(connman_bool_t offlinemode)
 {
-        _DBG_PROFILE("offlinemode %d", offlinemode);
+        struct connman_profile *profile = global_profile();
+        int ret;
 
-        /* TODO(sleffler) disallow if no default profile? */
-        if (default_profile != NULL) {
+        _DBG_PROFILE("offlinemode %d profile %p", offlinemode, profile);
+
+        /* NB: always succeeds (ATM) */
+        ret = __connman_device_set_offlinemode(offlinemode);
+        if (ret != 0)
+                return ret;
+
+        /* TODO(sleffler) sallow even if no global profile? */
+        if (profile != NULL) {
                 /*
                  * OfflineMode is only saved to the default profile;
                  * this ensures it is preserved across user changes.
                  */
-                if (default_profile->offlinemode == offlinemode)
+                if (profile->offlinemode == offlinemode)
                         return -EALREADY;
 
-                default_profile->offlinemode = offlinemode;
+                profile->offlinemode = offlinemode;
 
                 connman_dbus_send_property_changed_variant(
-                    default_profile->path,
+                    profile->path,
                     CONNMAN_PROFILE_INTERFACE, "OfflineMode",
                     DBUS_TYPE_BOOLEAN, &offlinemode);
+
+                __connman_storage_save_profile(profile);
         }
-        return __connman_device_set_offlinemode(offlinemode);
+        return 0;
 }
 
-/*
- * Return the active profile; it's on the top of the stack.
- */
-static inline struct connman_profile *active_profile(void)
-{
-        return cur_profile >= 0 ? profile_stack[cur_profile] : NULL;
-}
-
-/*
- * Load/Save objects.  When loading we walk the stack of profiles
- * until we find a successful load.  Saving always happens to the
- * top-most/active profile.
- */
-
 static inline int load_continue(int err)
 {
-        /* NB: ENXIO for no file, ESRCH for no group/key */
+        /* NB: ENXIO for no file, ESRCH for no entry */
         return (err == -ENXIO || err == -ESRCH);
 }
 
 int __connman_profile_load_service(struct connman_service *service)
 {
-        int i, err;
+        struct connman_profile *profile =
+            __connman_service_get_profile(service);
+        int err, i;
 
-        _DBG_PROFILE("service %p", service);
+        _DBG_PROFILE("service %p profile %p", service, profile);
 
+        if (profile != NULL)
+                return __connman_storage_load_service(service, &profile->ident);
+        /*
+         * Not bound to a profile yet, search the stack for an
+         * entry and if found bind the profile to the service.
+         */
         err = 0;
         for (i = cur_profile; i >= 0; i--) {
-                const struct connman_profile *profile = profile_stack[i];
-
+                profile = profile_stack[i];
                 err = __connman_storage_load_service(service, &profile->ident);
+                if (err == 0) {
+                        _DBG_PROFILE("bind to profile %p", profile);
+                        __connman_service_set_profile(service, profile);
+                        return 0;
+                }
                 if (!load_continue(err))
                         break;
         }
         return err;
 }
 
 int __connman_profile_save_service(struct connman_service *service)
 {
-        struct connman_profile *profile = active_profile();
+        struct connman_profile *profile =
+            __connman_service_get_profile(service);
 
         _DBG_PROFILE("service %p profile %p", service, profile);
 
+        if (profile == NULL) {
+                /* not bound yet, bind to the active profile */
+                profile = active_profile();
+                _DBG_PROFILE("bind to profile %p", profile);
+                __connman_service_set_profile(service, profile);
+        }
         return (profile == NULL) ? 0 :
             __connman_storage_save_service(service, &profile->ident);
 }
 
 int __connman_profile_load_device(struct connman_device *device)
 {
-        int i, err;
+        struct connman_profile *profile = global_profile();
 
-        _DBG_PROFILE("device %p", device);
+        _DBG_PROFILE("device %p profile %p", device, profile);
 
-        err = 0;
-        for (i = cur_profile; i >= 0; i--) {
-                const struct connman_profile *profile = profile_stack[i];
-
-                err = __connman_storage_load_device(device, &profile->ident);
-                if (!load_continue(err))
-                        break;
-        }
-        return err;
+        return (profile == NULL) ? 0 :
+            __connman_storage_load_device(device, &profile->ident);
 }
 
 int __connman_profile_save_device(struct connman_device *device)
 {
-        struct connman_profile *profile = active_profile();
+        struct connman_profile *profile = global_profile();
 
         _DBG_PROFILE("device %p profile %p", device, profile);
 
         return (profile == NULL) ? 0:
             __connman_storage_save_device(device, &profile->ident);
 }
 
 int __connman_profile_load_ipconfig(struct connman_ipconfig *ipconfig)
 {
-        int i, err;
+        struct connman_profile *profile = global_profile();
 
-        _DBG_PROFILE("ipconfig %p", ipconfig);
+        _DBG_PROFILE("ipconfig %p profile %p", ipconfig, profile);
 
-        err = 0;
-        for (i = cur_profile; i >= 0; i--) {
-                const struct connman_profile *profile = profile_stack[i];
-
-                err = __connman_storage_load_ipconfig(ipconfig,
-                    &profile->ident);
-                if (!load_continue(err))
-                        break;
-        }
-        return err;
+        return (profile == NULL) ? 0:
+            __connman_storage_load_ipconfig(ipconfig, &profile->ident);
 }
 
 int __connman_profile_save_ipconfig(const struct connman_ipconfig *ipconfig)
 {
-        struct connman_profile *profile = active_profile();
+        struct connman_profile *profile = global_profile();
 
         _DBG_PROFILE("ipconfig %p profile %p", ipconfig, profile);
 
         return (profile == NULL) ? 0 :
             __connman_storage_save_ipconfig(ipconfig, &profile->ident);
 }
 
 int __connman_profile_append_hidden_ssids(GSList **hidden_ssids,
     void (*append_hidden_ssids)(GKeyFile *keyfile, GSList **hidden_ssids))
 {
         int i;
 
         _DBG_PROFILE("");
 
         for (i = cur_profile; i >= 0; i--) {
                 const struct connman_profile *profile = profile_stack[i];
                 GKeyFile *keyfile;
 
                 keyfile = __connman_storage_open(&profile->ident);
                 if (keyfile != NULL) {
                         append_hidden_ssids(keyfile, hidden_ssids);
                         __connman_storage_close(&profile->ident, keyfile,
                             FALSE);
                 }
         }
         return 0;
 }
 
 /*
- * Save the default profile if registered.
+ * Return the object path for the specified profile.
  */
-int __connman_profile_save_default(void)
+const char *__connman_profile_get_path(const struct connman_profile *profile)
 {
-        if (default_profile != NULL)
-                __connman_storage_save_profile(default_profile);
-        return 0;
+        return profile != NULL ? profile->path : NULL;
 }
 
 /*
- * Save the active profile (if any).
+ * Return the profile given an object path.
  */
-int __connman_profile_save_active(void)
+struct connman_profile *__connman_profile_lookup_profile(const char *path)
 {
-        struct connman_profile *profile = active_profile();
-        return (profile == NULL) ? -EINVAL :
-            __connman_storage_save_profile(profile);
+        return g_hash_table_lookup(profile_hash, path);
 }
 
 /*
- * Return the identifier for the active profile or NULL
- * if there is none.
+ * Return the active profile or NULL
  */
+struct connman_profile *__connman_profile_active_profile(void)
+{
+        return active_profile();
+}
+
 const struct connman_storage_ident *__connman_profile_active_ident(void)
 {
         struct connman_profile *profile = active_profile();
         return profile != NULL ? &profile->ident : NULL;
 }
 
 /*
  * Return the object path for the active profile or NULL
  * if there is none.
  */
 const char *__connman_profile_active_path(void)
 {
         struct connman_profile *profile = active_profile();
         return profile != NULL ? profile->path : NULL;
 }
 
-static guint changed_timeout = 0;
+/*
+ * Delete an entry in the specified profile.
+ */
+int __connman_profile_delete_entry(struct connman_profile *profile,
+    const char *group)
+{
+        GKeyFile *keyfile;
+        gboolean status;
 
-static void clear_timeout(void)
+        _DBG_PROFILE("profile %p group %s", profile, group);
+
+        keyfile = __connman_storage_open(&profile->ident);
+        if (keyfile == NULL) {
+                _DBG_PROFILE("cannot open key file");
+                return -EINVAL;
+        }
+
+        status = g_key_file_remove_group(keyfile, group, NULL);
+        __connman_storage_close(&profile->ident, keyfile, status);
+
+        if (status == FALSE) {
+                _DBG_PROFILE("cannot remove %s", group);
+                return -ENXIO;
+        }
+        return 0;
+}
+
+static void clear_timeout(struct connman_profile *profile)
 {
-        if (changed_timeout > 0) {
-                g_source_remove(changed_timeout);
-                changed_timeout = 0;
+        if (profile->changed_timeout > 0) {
+                g_source_remove(profile->changed_timeout);
+                profile->changed_timeout = 0;
         }
 }
 
 static void append_services(DBusMessageIter *iter, void *arg)
 {
         __connman_service_list(iter, arg);
 }
 static gboolean services_changed(gpointer user_data)
 {
-        struct connman_profile *profile = active_profile();
+        struct connman_profile *profile = user_data;
 
-        changed_timeout = 0;
+        profile->changed_timeout = 0;
 
         if (profile != NULL) {
                 connman_dbus_send_property_changed_array(profile->path,
                     CONNMAN_PROFILE_INTERFACE, "Services",
                     DBUS_TYPE_OBJECT_PATH, append_services, NULL);
         }
 
         connman_dbus_send_property_changed_array(CONNMAN_MANAGER_PATH,
             CONNMAN_MANAGER_INTERFACE, "Services",
             DBUS_TYPE_OBJECT_PATH, append_services, NULL);
         return FALSE;
 }
 
 /*
- * Handle changes to the profile.  Generate PropertyChanged signals
+ * Handle changes to a profile.  Generate PropertyChanged signals
  * on Manager.Services and Profile.Services for the currently active
  * profile.  To minimize overhead requests may be coalesced using a
  * 1 second delay on the signals.
  */
-void __connman_profile_changed(gboolean delayed)
+void __connman_profile_changed(struct connman_profile *profile,
+    gboolean delayed)
 {
-        _DBG_PROFILE("delayed %d changed_timeout %d", delayed, changed_timeout);
+        if (profile == NULL)
+                return;
 
-        clear_timeout();
+        _DBG_PROFILE("profile %p delayed %d changed_timeout %d",
+            profile, delayed, profile->changed_timeout);
+
+        clear_timeout(profile);
 
         if (delayed == TRUE) {
-                changed_timeout = g_timeout_add_seconds(1, services_changed,
-                    NULL);
+                profile->changed_timeout = g_timeout_add_seconds(1,
+                    services_changed, profile);
         } else
-                services_changed(NULL);
+                services_changed(profile);
 }
 
 int __connman_profile_add_device(struct connman_device *device)
 {
         struct connman_service *service;
 
         _DBG_PROFILE("device %p", device);
 
         service = __connman_service_create_from_device(device);
         if (service == NULL)
@@ skipping 117 matching lines @@
 
         dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 
         if (profile->name != NULL)
                 connman_dbus_dict_append_variant(&dict, "Name",
                     DBUS_TYPE_STRING, &profile->name);
 
-        if (profile == default_profile)
+        if (profile == global_profile())
                 connman_dbus_dict_append_variant(&dict, "OfflineMode",
                     DBUS_TYPE_BOOLEAN, &profile->offlinemode);
 
         if (profile == active_profile())
                 connman_dbus_dict_append_variant_array(&dict, "Services",
                     DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL);
 
         connman_dbus_dict_append_variant_array(&dict, "Entries",
             DBUS_TYPE_STRING, __profile_entry_list, profile);
 
@@ skipping 168 matching lines @@
 #undef ADD_STR
 }
 
 static DBusMessage *delete_entry(DBusConnection *conn,
                                         DBusMessage *msg, void *data)
 {
         struct connman_profile *profile = data;
         DBusMessageIter iter;
         const char *identifier;
         struct connman_service *service;
-        GKeyFile *keyfile;
-        gboolean status;
+        int err;
 
         _DBG_PROFILE("profile %s:%s", profile->ident.user,
             profile->ident.ident);
 
         if (dbus_message_iter_init(msg, &iter) == FALSE)
                 return __connman_error_invalid_arguments(msg);
 
         dbus_message_iter_get_basic(&iter, &identifier);
 
         if (__connman_security_check_privilege(msg,
                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
                 return __connman_error_permission_denied(msg);
 
         service = __connman_service_lookup(identifier);
         if (service != NULL) {
                 /* NB: this does not remove the service */
                 __connman_service_reset(service);
         }
 
         /* Remove directly from profile */
-        keyfile = __connman_storage_open(&profile->ident);
-        if (keyfile == NULL) {
-                _DBG_PROFILE("cannot open key file");
-                return __connman_error_invalid_arguments(msg);
-        }
-
-        status = g_key_file_remove_group(keyfile, identifier, NULL);
-        __connman_storage_close(&profile->ident, keyfile, status);
-
-        if (status == FALSE) {
-                _DBG_PROFILE("cannot remove %s", identifier);
-                return __connman_error_not_found(msg);
-        }
+        err = __connman_profile_delete_entry(profile, identifier);
+        if (err)
+                return __connman_error_failed(msg, -err);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static GDBusMethodTable profile_methods[] = {
         { "GetProperties", "",   "a{sv}", get_properties },
         { "SetProperty",   "sv", "",      set_property   },
         { "GetEntry",      "s",  "a{sv}", get_entry },
         { "DeleteEntry",   "s",  "",      delete_entry },
         { },
@@ skipping 26 matching lines @@
         struct connman_profile *profile = data;
 
         _DBG_PROFILE("profile %p", profile);
 
         connman_info("Remove profile %s:%s", profile->ident.user,
             profile->ident.ident);
 
         g_dbus_unregister_interface(connection, profile->path,
                                                 CONNMAN_PROFILE_INTERFACE);
 
+        clear_timeout(profile);
+
         if (profile == default_profile)
                 default_profile = NULL;
 
         free_profile(profile);
 }
 
 static char *getpath(const struct connman_storage_ident *ident)
 {
         if (ident->user != NULL) {
                 /* NB: check for two tokens done in validate_ident */
@@ skipping 199 matching lines @@
                         return -EEXIST;
                 }
                 if (path != NULL)
                         *path = profile->path;
         }
 
         profile_stack[++cur_profile] = profile;
 
         profiles_changed();
 
-        /* NB: this is a noop if we are online (or trying to get online) */
-        __connman_service_auto_connect_any();
+        __connman_notifier_profile_push(profile);
 
         return 0;
 }
 
 /*
  * Pop the profile from the top of the stack and remove it from
  * the in-memory table.  Any associated services are invalidated
  * (credentials revoked and connections closed). After a pop we
  * generate a PropertyChanged signal for Manager.Profiles.
  *
@@ skipping 26 matching lines @@
                 }
                 if (ident_equal(&profile->ident, &sid) == FALSE) {
                         connman_error("%s: %s is not the active profile",
                             __func__, ident);
                         free_ident(&sid);
                         return -ENXIO;
                 }
                 free_ident(&sid);
         }
 
-        __connman_service_invalidate_profile(&profile->ident);
+        /*
+         * Pop the stack, invalidate all objects holding references
+         * to the profile, then remove it from the in-memory table.
+         * We do the reclaim after notification in case anyone holding
+         * a reference tries to use it.
+         */
+        cur_profile--;
+
+        __connman_notifier_profile_pop(profile);
 
         g_hash_table_remove(profile_hash, profile->path);
-        cur_profile--;
 
         profiles_changed();
 
-        /* NB: no need to kick auto-connect; it will happen due to invalidate */
-
         return 0;
 }
 
 /*
  * Create a profile file and register it in memory.  The
  * file is created with minimal contents.
  * TODO(sleffler) disallow overwriting an existing file?
  */
 int __connman_profile_create(const char *name, const char **path)
 {
@@ skipping 195 matching lines @@
 
         if (connection == NULL)
                 return;
 
         while (cur_profile >= 0)
                 __connman_profile_pop(NULL);
 
         g_hash_table_destroy(profile_hash);
         profile_hash = NULL;
 
-        clear_timeout();                /* cancel any pending timer */
-
         connman_storage_unregister(&profile_storage);
 
         dbus_connection_unref(connection);
 }