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

src/service.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 41 matching lines @@
 
 static DBusConnection *connection = NULL;
 
 static GSequence *service_list = NULL;
 static GHashTable *service_hash = NULL;
 
 struct connman_service {
         gint refcount;
         char *identifier;
         char *path;
+        struct connman_profile *profile;
         enum connman_service_type type;
         enum connman_service_mode mode;
         enum connman_service_security security;
         enum connman_service_state state;
         enum connman_service_error error;
         enum connman_service_connectivity_state connectivity_state;
         connman_uint8_t pri;
         connman_uint8_t strength;
         connman_bool_t favorite;
         connman_bool_t hidden;
@@ skipping 17 matching lines @@
                 char *private_key_passwd;
                 char *key_id;
                 char *ca_cert; /* formerly authpath */
                 char *ca_cert_id;
                 connman_bool_t use_system_cas;
                 char *pin;
                 char *password;
                 char *key_mgmt;
         } eap;
 
-        const struct connman_storage_ident *profile;
         char *proxy_config;
 
         /* TODO(sleffler) overlay storage */
         struct {
                 char *operator_name;
                 char *operator_code;
                 char *olp_url;
                 char *usage_url;
                 enum connman_network_activation_state activation_state;
                 enum connman_network_cellular_technology network_technology;
@@ skipping 279 matching lines @@
 {
         struct find_data data = { .path = path, .service = NULL };
 
         _DBG_SERVICE("path %s", path);
 
         g_sequence_foreach(service_list, compare_path, &data);
 
         return data.service;
 }
 
+struct connman_profile *__connman_service_get_profile(
+    struct connman_service *service)
+{
+        return service->profile;
+}
+
+/*
+ * Set the service's bound profile. 
+ */
+void __connman_service_set_profile(struct connman_service *service,
+    struct connman_profile *profile)
+{
+        _DBG_SERVICE("profile %p -> %p", service->profile, profile);
+
+        service->profile = profile;
+}
+
+/*
+ * Handle a profile being pop'd off the stack (e.g. on logout).
+ * Invalidate and possibly disconnect all services bound to the
+ * specified profile.  Then re-load state from the profile (if
+ * available).  Note this is assumed called AFTER the specified
+ * profile is pop'd off the stack (so we can explicitly re-load
+ * state and get any other data present, e.g. in the global profile).
+ */
 static void invalidate_profile(gpointer value, gpointer user_data)
 {
         struct connman_service *service = value;
-        const struct connman_storage_ident *profile = user_data;
+        const struct connman_profile *profile = user_data;
 
         if (service->profile == profile) {
-                /*
-                 * Invalidate profile-related data and force a re-load
-                 * the next time the service is to be used (so it can
-                 * come from the active profile).
-                 */
+                _DBG_SERVICE("service %p", service);
+
                 service->profile = NULL;
 
                 /*
                  * network_disconnect may drop the last reference to the
                  * service and cause it to be freed, so take a reference
                  * temporarily until we are done with it.
                  */
                 connman_service_ref(service);
+
                 /* TODO(sleffler) skip wired ethernet, open auth? */
+                service->autoconnect = FALSE;
                 __connman_service_disconnect(service);
                 service_clear_passphrase(service);
                 service_clear_eap(service);
+
+                /* re-load profile state */
+                __connman_profile_load_service(service);
+
                 connman_service_unref(service);
         }
 }
+static void service_profile_pop(struct connman_profile *profile)
+{
+        _DBG_SERVICE("profile %p", profile);
 
-void __connman_service_invalidate_profile(const struct connman_storage_ident *ident)
+        g_sequence_foreach(service_list, invalidate_profile, (gpointer)profile);
+        /* NB: no need to kick auto-connect; it will happen due to invalidate */
+}
+
+/*
+ * Handle a profile being push'd on the stack (e.g. on login).
+ * Try to bind any service objects that are currently unbound
+ * and kick the autoconnect logic in case we can now login.
+ */
+static void load_profile(gpointer value, gpointer user_data)
 {
-        _DBG_SERVICE("ident %s/%s", ident->user, ident->ident);
+        struct connman_service *service = value;
 
-        g_sequence_foreach(service_list, invalidate_profile, (gpointer) ident);
+        if (service->profile == NULL)
+                __connman_profile_load_service(service);
+}
+static void service_profile_push(struct connman_profile *profile)
+{
+        _DBG_SERVICE("profile %p", profile);
+
+        g_sequence_foreach(service_list, load_profile, NULL);
+
+        __connman_service_auto_connect_any();
 }
 
 static const char *identifier(struct connman_service *service)
 {
         return service ? service->identifier : "<nil>";
 }
 
 static const char *type2string(enum connman_service_type type)
 {
         switch (type) {
@@ skipping 432 matching lines @@
 static void proxy_configuration_changed(struct connman_service *service)
 {
         if (service->proxy_config == NULL)
                 return;
 
         connman_dbus_send_property_changed_variant(service->path,
                 CONNMAN_SERVICE_INTERFACE, "ProxyConfig",
                 DBUS_TYPE_STRING, &service->proxy_config);
 }
 
+static void profile_changed(struct connman_service *service)
+{
+        const char *path;
+
+        CONNMAN_ASSERT(service->profile != NULL);
+
+        path = __connman_profile_get_path(service->profile);
+        connman_dbus_send_property_changed_variant(service->path,
+                CONNMAN_SERVICE_INTERFACE, "Profile",
+                DBUS_TYPE_STRING, &path);
+}
+
 static void get_properties_802_1x(DBusMessageIter *dict,
                                   struct connman_service *service)
 {
         if (service->eap.identity != NULL)
                 connman_dbus_dict_append_variant(dict, kEAPIdentity,
                         DBUS_TYPE_STRING, &service->eap.identity);
         if (service->eap.eap != NULL)
                 connman_dbus_dict_append_variant(dict, kEAPEAP,
                         DBUS_TYPE_STRING, &service->eap.eap);
         if (service->eap.inner_eap != NULL)
@@ skipping 97 matching lines @@
         str = security2string(service->security);
         if (str != NULL)
                 connman_dbus_dict_append_variant(&dict, "Security",
                                                 DBUS_TYPE_STRING, &str);
 
         str = connman_service_get_state(service);
         if (str != NULL)
                 connman_dbus_dict_append_variant(&dict, "State",
                                                 DBUS_TYPE_STRING, &str);
 
+        if (service->profile != NULL) {
+                str = __connman_profile_get_path(service->profile);
+                connman_dbus_dict_append_variant(&dict, "Profile",
+                                                DBUS_TYPE_STRING, &str);
+        }
+
         str = error2string(service->error);
         if (str != NULL)
                 connman_dbus_dict_append_variant(&dict, "Error",
                                                 DBUS_TYPE_STRING, &str);
 
         if (service->pri != CONNMAN_SERVICE_PRI_NONE) {
                 int pri = service->pri;
                 connman_dbus_dict_append_variant(&dict, "Priority",
                                         DBUS_TYPE_INT32, &pri);
         }
@@ skipping 545 matching lines @@
         dbus_message_iter_get_basic(&iter, &name);
         dbus_message_iter_next(&iter);
         dbus_message_iter_recurse(&iter, &value);
 
         if (__connman_security_check_privilege(msg,
                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
                 return __connman_error_permission_denied(msg);
 
         type = dbus_message_iter_get_arg_type(&value);
 
-        if (g_str_equal(name, "WiFi.HiddenSSID") == TRUE) {
+        if (g_str_equal(name, "Profile") == TRUE) {
+                const char *path;
+                struct connman_profile *profile;
+
+                if (type != DBUS_TYPE_STRING)
+                        return __connman_error_invalid_arguments(msg);
+
+                dbus_message_iter_get_basic(&value, &path);
+
+                profile = __connman_profile_lookup_profile(path);
+                /* TODO(sleffler) support setting a NULL profile? */
+                if (profile == NULL)
+                        return __connman_error_not_found(msg);
+
+                if (service->profile != profile) {
+                        if (service->profile != NULL) {
+                                /* remove old entry */
+                                (void) __connman_profile_delete_entry(
+                                    service->profile, service->identifier);
+                        }
+                        service->profile = profile;
+
+                        profile_changed(service);
+
+                        service_modified(service);
+                }
+        } else if (g_str_equal(name, "WiFi.HiddenSSID") == TRUE) {
                 connman_bool_t hidden_ssid;
 
                 if (type != DBUS_TYPE_BOOLEAN)
                         return __connman_error_invalid_arguments(msg);
 
                 if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
                         return __connman_error_invalid_service(msg);
 
                 dbus_message_iter_get_basic(&value, &hidden_ssid);
 
@@ skipping 246 matching lines @@
 {
         service_clear_passphrase(service);
 
         passphrase_required_changed(service);
 }
 
 static void service_modified(struct connman_service *service)
 {
         g_get_current_time(&service->modified);
 
-        service->profile = __connman_profile_active_ident();
         __connman_profile_save_service(service);
 }
 
 static void service_clear_eap(struct connman_service *service)
 {
         g_free(service->eap.identity);
         service->eap.identity = NULL;
 
         g_free(service->eap.eap);
         service->eap.eap = NULL;
@@ skipping 828 matching lines @@
         if (target->state != service->state)
                 return __connman_error_invalid_service(msg);
 
         service_modified(service);
 
         src = g_hash_table_lookup(service_hash, service->identifier);
         dst = g_hash_table_lookup(service_hash, target->identifier);
 
         g_sequence_move(src, dst);
 
-        __connman_profile_changed(FALSE);
+        __connman_profile_changed(service->profile, FALSE);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *move_after(DBusConnection *conn,
                                         DBusMessage *msg, void *user_data)
 {
         struct connman_service *service = user_data;
         struct connman_service *target;
         const char *path;
@@ skipping 87 matching lines @@
         if (service->in_watchlist == TRUE)
                 connman_service_notify_watchlist(CONNMAN_SERVICE_STATE_UNKNOWN);
 
         remove_timeout(service);
 
         g_hash_table_remove(service_hash, service->identifier);
 
         service->path = NULL;
 
         if (path != NULL) {
-                __connman_profile_changed(FALSE);
+                __connman_profile_changed(service->profile, FALSE);
 
                 g_dbus_unregister_interface(connection, path,
                                                 CONNMAN_SERVICE_INTERFACE);
                 g_free(path);
         }
 
         if (service->network != NULL)
                 connman_network_unref(service->network);
         if (service->provider != NULL)
                 connman_provider_unref(service->provider);
@@ skipping 313 matching lines @@
         if (iter == NULL)
                 return -ENOENT;
 
         if (service->favorite == favorite)
                 return -EALREADY;
 
         service->favorite = favorite;
 
         g_sequence_sort_changed(iter, service_compare, NULL);
 
-        __connman_profile_changed(FALSE);
+        __connman_profile_changed(service->profile, FALSE);
 
         return 0;
 }
 
 /**
  * connman_service_get_device:
  * @service: service structure
  *
  * Return device for specified service.
  */
@@ skipping 95 matching lines @@
         if (state == CONNMAN_SERVICE_STATE_FAILURE) {
                 remove_timeout(service);
 
                 if (service->userconnect == FALSE)
                         connman_service_auto_connect(service);
 
                 service_modified(service);
         } else if (state != CONNMAN_SERVICE_STATE_ACTIVATION_FAILURE)
                 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
 
-        __connman_profile_changed(FALSE);
+        __connman_profile_changed(service->profile, FALSE);
 
         if (state == CONNMAN_SERVICE_STATE_DISCONNECT) {
                 struct connman_service *act_service = get_active_service();
 
                 /* TODO(sleffler) this looks wrong */
                 if (__connman_connection_is_online() == FALSE &&
                     act_service != NULL && act_service->provider != NULL)
                         __connman_provider_disconnect(act_service->provider);
         }
 
@@ skipping 677 matching lines @@
         }
 
         service = connman_service_create();
         if (service == NULL)
                 return NULL;
 
         _DBG_SERVICE("service %p", service);
 
         service->identifier = g_strdup(identifier);
 
-        service->profile = __connman_profile_active_ident();
-
         __connman_profile_load_service(service);
 
         iter = g_sequence_insert_sorted(service_list, service,
                                                 service_compare, NULL);
 
         g_hash_table_insert(service_hash, service->identifier, iter);
 
         return service;
 }
 
 static int service_register(struct connman_service *service)
 {
-        const char *path = __connman_profile_active_path();
-
         _DBG_SERVICE("service %p", service);
 
         if (service->path != NULL)
                 return -EALREADY;
 
-        service->path = g_strdup_printf("%s/%s", path, service->identifier);
-
-        _DBG_SERVICE("path %s", service->path);
+        service->path = g_strdup_printf("/%s", service->identifier);
 
         g_dbus_register_interface(connection, service->path,
                                         CONNMAN_SERVICE_INTERFACE,
                                         service_methods, service_signals,
                                                         NULL, service, NULL);
 
         __connman_profile_load_service(service);
 
         __service_resort(service);
 
-        __connman_profile_changed(TRUE);
+        __connman_profile_changed(service->profile, TRUE);
 
         return 0;
 }
 
 /**
  * __connman_service_lookup_from_device:
  * @device: device structure
  *
  * Look up a service by device (reference count will not be increased)
  */
@@ skipping 34 matching lines @@
 
         name = g_strdup_printf("%s_%s",
                                 __connman_device_get_type(device), ident);
         service = __connman_service_get(name);
         g_free(name);
 
         if (service == NULL)
                 return NULL;
 
         if (service->path != NULL) {
-                __connman_profile_changed(TRUE);
+                __connman_profile_changed(service->profile, TRUE);
                 return service;
         }
 
         service->type = __connman_device_get_service_type(device);
 
         service->autoconnect = FALSE;
 
         service->device = device;
 
         __connman_profile_load_service(service);
 
         service_register(service);
 
-        __connman_profile_changed(TRUE);
+        __connman_profile_changed(service->profile, TRUE);
 
         if (service->favorite == TRUE)
                 connman_service_auto_connect(service);
 
         return service;
 }
 
 void __connman_service_remove_from_device(struct connman_device *device)
 {
         struct connman_service *service;
@@ skipping 351 matching lines @@
         g_free(name);
 
         if (service == NULL)
                 return NULL;
 
         if (__connman_network_get_weakness(network) == TRUE)
                 return service;
 
         if (service->path != NULL) {
                 update_from_network(service, network, FALSE);
-                __connman_profile_changed(TRUE);
+                __connman_profile_changed(service->profile, TRUE);
                 return service;
         }
 
         service->type = convert_network_type(network);
 
         switch (service->type) {
         case CONNMAN_SERVICE_TYPE_UNKNOWN:
         case CONNMAN_SERVICE_TYPE_ETHERNET:
         case CONNMAN_SERVICE_TYPE_WIMAX:
         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
@@ skipping 24 matching lines @@
 
         str = connman_network_get_string(network, "WiFi.Security");
         service->security = convert_wifi_security(str);
 
         update_from_network(service, network, FALSE);
 
         __connman_profile_load_service(service);
 
         service_register(service);
 
-        __connman_profile_changed(TRUE);
+        __connman_profile_changed(service->profile, TRUE);
 
         if (service->favorite == TRUE)
                 connman_service_auto_connect(service);
 
         return service;
 }
 
 /**
  * connman_service_set_current_network:
  * @network: network structure
@@ skipping 642 matching lines @@
         .service_load   = service_load,
         .service_save   = service_save,
 };
 
 static struct connman_notifier service_notifier = {
         .name           = "service",
         .priority       = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
         .service_state_changed = notify_state_changed,
         .system_suspend = service_system_suspend,
         .system_resume  = service_system_resume,
+        .profile_push   = service_profile_push,
+        .profile_pop    = service_profile_pop,
 };
 
 int __connman_service_init(const char *option_order)
 {
         _DBG_SERVICE("");
 
         connection = connman_dbus_get_connection();
 
         if (connman_storage_register(&service_storage) < 0)
                 connman_error("Failed to register service storage");
@@ skipping 25 matching lines @@
         service_list = NULL;
 
         g_hash_table_destroy(service_hash);
         service_hash = NULL;
 
         connman_storage_unregister(&service_storage);
         connman_notifier_unregister(&service_notifier);
 
         dbus_connection_unref(connection);
 }